fix(workspace): narrow the id-lookup error suppression, stop the test flag leaking

Bot review on the current head.

**An unreadable store reported "not found".** The id path swallowed every read
error so that project scope, which throws outside an instance context, could not
hide a global or workspace match. But probing both scopes is our choice only
when the caller passes `scope: "all"` — when they name a scope, a failure there
is a real error they need to see, not missing memory. Suppression is now limited
to exactly the project-scope-under-`all` case.

**The test flag leaked into the process.** `store-directory.test.ts` set
`ALTIMATE_WORKSPACE=1` at module load and never restored it, so unrelated suites
sharing the process inherited the pilot flag. Saved and restored in teardown,
deleting it when it was previously unset.

Both mutation-checked. The reviewer's other two findings were raised against
`de4201f7b` and are already fixed in `568b7cfae9`: the id path merges the
overlay (it no longer returns before the merge), and hydration commits into the
state that launched it, so a stale in-flight fetch cannot clobber a refreshed
overlay.

Tests: 4481 pass across memory + altimate.

Author: sahrizvi

packages/opencode/src/memory/tools/memory-read.ts

@@ -45,15 +45,17 @@ export const MemoryReadTool = Tool.define("altimate_memory_read", {
 
         const matches: (MemoryBlock & { origin?: string })[] = []
         for (const scope of scopes) {
-          // One scope failing must not take the others down with it. Project
-          // scope throws outside an instance context, which would otherwise
-          // turn an id lookup into a tool error instead of returning the
-          // global and workspace matches. `listAll` already behaves this way.
+          // Narrowly suppressed: probing BOTH scopes is our choice, not the
+          // caller's, and project scope throws outside an instance context --
+          // that must not hide a global or workspace match. A scope the caller
+          // asked for explicitly failing is a real error they need to see,
+          // rather than a misleading "not found".
           let block: MemoryBlock | undefined
           try {
             block = await MemoryStore.read(scope, args.id)
-          } catch {
-            continue
+          } catch (e) {
+            if (args.scope === "all" && scope === "project") continue
+            throw e
           }
           if (!block) continue
           // Respect include_expired for ID reads

packages/opencode/test/memory/overlay-merge.test.ts

@@ -212,6 +212,27 @@ describe("the memory read tool", () => {
     expect(String(res.output ?? "")).not.toContain("EXPIRES SOON")
   })
 
+  test("an explicitly requested scope that cannot be read is an error, not 'not found'", async () => {
+    // Probing both scopes is our choice when scope=all, so a project-scope
+    // failure there is suppressed. When the caller names a scope, swallowing
+    // the failure would report missing memory for a store that is merely
+    // unreadable.
+    const { MemoryStore } = await import("../../src/memory/store")
+    const original = MemoryStore.read
+    ;(MemoryStore as any).read = async () => {
+      throw new Error("store unreadable")
+    }
+    try {
+      const tool = await initTool(MemoryReadTool)
+      const res: any = await tool.execute({ id: "x", scope: "project" }, { sessionID: SES, agent: "build" })
+      const text = String(res.output ?? "")
+      expect(text).not.toContain("No memory block found")
+      expect(text).toContain("store unreadable")
+    } finally {
+      ;(MemoryStore as any).read = original
+    }
+  })
+
   test("surfaces workspace memory, not just the local store", async () => {
     // The tool read MemoryStore only, so it disagreed with what the model was
     // actually given -- injection merges the overlay and the tool did not.

packages/opencode/test/memory/store-directory.test.ts

@@ -1,8 +1,10 @@
 // The workspace flag is read at module load, so it must be set before the
-// modules under test are imported.
+// modules under test are imported -- and restored afterwards so it does not
+// leak into unrelated suites sharing this process.
+const ORIGINAL_WORKSPACE_FLAG = process.env.ALTIMATE_WORKSPACE
 process.env.ALTIMATE_WORKSPACE = "1"
 
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import os from "os"
@@ -12,6 +14,11 @@ import { MemoryStore } from "@/memory/store"
 // and so cannot catch path-resolution bugs. Callers outside an Instance context
 // -- the `link` subcommand is one -- pass `directory` explicitly; every step of
 // the read path has to honour it, not just the directory scan.
+afterAll(() => {
+  if (ORIGINAL_WORKSPACE_FLAG === undefined) delete process.env.ALTIMATE_WORKSPACE
+  else process.env.ALTIMATE_WORKSPACE = ORIGINAL_WORKSPACE_FLAG
+})
+
 describe("MemoryStore project scope with an explicit directory", () => {
   let proj: string