fix(workspace): retry a failed workspace summary; make the unlink race test prove its claim

- A failed `/summary` fetch was cached as "not known" for the full five
  minutes, so one network blip hid the workspace's integrations that long.
  It is now kept for the failing step only; the next step asks again.
- "a step arriving after an unlink does not join the pre-unlink resolve"
  waited for a second request on the wire. After the unlink there is no
  local binding, so step 2 settles without any request: the second request
  the test saw was a detached skill sync left over from an earlier test's
  bind. Loading `skill-sync` from the contents block shifted that timing and
  made it fail under load. The test now asserts the real invariant — step 2
  settles while step 1 is still parked, and does not name the old workspace —
  and fails when both `inflight.clear()` and the generation check are removed.
- `identity-section` tests reset the contents cache between tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018fJ3X7pcGT4R9yzjsJnqsV

Author: sahrizvi

packages/opencode/src/altimate/workspace/contents.ts

@@ -87,7 +87,8 @@ export async function workspaceSummary(datamateId: number, now = Date.now()): Pr
   let pending = hit?.pending
   if (!pending) {
     pending = fetchSummary(datamateId).then((value) => {
-      summaries.set(datamateId, { at: Date.now(), value })
+      // A failed fetch (integrations unknown) is kept for this step only, so the next step retries.
+      summaries.set(datamateId, { at: value.integrations === null ? 0 : Date.now(), value })
       return value
     })
     summaries.set(datamateId, { at: hit?.at ?? 0, value: hit?.value, pending })

packages/opencode/test/altimate/workspace/contents.test.ts

@@ -73,6 +73,16 @@ describe("workspace summary cache", () => {
     failing.mockRestore()
   })
 
+  test("a failed fetch is not cached: the next step asks again", async () => {
+    const spy = spyOn(AltimateApi, "getDatamate")
+      .mockRejectedValueOnce(new Error("offline"))
+      .mockResolvedValueOnce({ id: "38", name: "w", integrations: [{ id: "github" }], memory_enabled: true } as any)
+    expect(await Contents.workspaceSummary(38)).toEqual({ integrations: null, memoryEnabled: null })
+    expect(await Contents.workspaceSummary(38)).toEqual({ integrations: ["github"], memoryEnabled: true })
+    expect(spy).toHaveBeenCalledTimes(2)
+    spy.mockRestore()
+  })
+
   test("a slow service does not hold the step: the answer is 'not known' until it arrives", async () => {
     let release!: (v: any) => void
     const spy = spyOn(AltimateApi, "getDatamate").mockImplementation(

packages/opencode/test/altimate/workspace/identity-section.test.ts

@@ -30,6 +30,7 @@ afterAll(() => {
 })
 
 const { AltimateApi } = await import("../../../src/altimate/api/client")
+const Contents = await import("../../../src/altimate/workspace/contents")
 const {
   systemSection,
   resetOutcomeMemoForTests,
@@ -73,6 +74,7 @@ let projectDir = ""
 beforeEach(() => {
   process.env.ALTIMATE_WORKSPACE = "1"
   resetOutcomeMemoForTests()
+  Contents.resetForTests()
   projectDir = mkdtempSync(path.join(SANDBOX, "proj-"))
   // Nothing here should need the network; anything that asks gets an empty 200.
   globalThis.fetch = (async () =>
@@ -518,12 +520,15 @@ describe("systemSection", () => {
     const gate = new Promise<void>((r) => (release = r))
     let firstStarted!: () => void
     const firstOnWire = new Promise<void>((r) => (firstStarted = r))
-    let secondStarted!: () => void
-    const secondOnWire = new Promise<void>((r) => (secondStarted = r))
-    let calls = 0
-    globalThis.fetch = (async () => {
-      calls++
-      if (calls === 1) {
+    let bindingCalls = 0
+    globalThis.fetch = (async (input: RequestInfo | URL) => {
+      // Only binding resolves are gated. A detached skill sync left over from an earlier test's bind,
+      // and the contents block's summary request, also reach this mock.
+      if (!String(input instanceof Request ? input.url : input).includes("/datamate-project-bindings/")) {
+        return new Response(JSON.stringify({}), { status: 200, headers: { "content-type": "application/json" } })
+      }
+      bindingCalls++
+      if (bindingCalls === 1) {
         firstStarted()
         await gate
         return new Response(
@@ -534,7 +539,6 @@ describe("systemSection", () => {
           { status: 200, headers: { "content-type": "application/json" } },
         )
       }
-      secondStarted()
       return new Response(JSON.stringify({ detail: "not found" }), {
         status: 404,
         headers: { "content-type": "application/json" },
@@ -543,11 +547,16 @@ describe("systemSection", () => {
     const first = inProject(systemSection)
     await firstOnWire // step 1's request is out and parked on the gate
     await clearLocalBinding(projectDir, { scope: ACME_SCOPE })
-    const second = inProject(systemSection)
-    await secondOnWire // step 2 made its OWN request while step 1 was still pending
+    // Step 2 must settle while step 1 is still parked. Had it joined step 1's resolve it would
+    // wait out RESOLVE_DEADLINE_MS; the bound here is well inside that.
+    const joined = Symbol("joined")
+    const next = await Promise.race([
+      inProject(systemSection),
+      new Promise<typeof joined>((r) => setTimeout(() => r(joined), RESOLVE_DEADLINE_MS / 2)),
+    ])
     release()
-    const [, next] = await Promise.all([first, second])
-    expect(calls).toBe(2)
+    await first
+    expect(next).not.toBe(joined)
     expect(next).not.toContain('is "old"')
     expect(next).toContain("No Altimate Workspace")
   })