test(workspace): answer awaited skill syncs offline in the swept tests

Syncs these tests now await could hit the real network: launch-resolve always
(`localhost:5001`), state-account-scope and the plugin cache tests when
`ALTIMATE_WORKSPACE` is exported. One shared stub, restored per test. Also
asserts the unlink step makes no second request.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0174HUYiaceApqHP7EKMNgnb

Author: ralphstodomingo

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

@@ -52,6 +52,7 @@ const { syncInternals } = await import("../../../src/altimate/workspace/engine-s
 // and recordApprovedBinding for tenant/apiUrl scoping. Re-import allows
 // per-test override of the module state.
 import { AltimateApi } from "../../../src/altimate/api/client"
+import { stubEmptySkillList } from "../workspace/skill-list-fixture"
 const originalIsConfigured = AltimateApi.isConfigured
 const originalGetCreds = AltimateApi.getCredentials
 type Creds = Awaited<ReturnType<typeof AltimateApi.getCredentials>>
@@ -145,9 +146,13 @@ describe("detectProjectRemote", () => {
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe("workspace binding cache", () => {
+  let restoreFetch = () => {}
   beforeEach(() => {
     stubCreds("acme", "https://api.acme.example.com")
+    // Recording a link here awaits its skill sync; answered offline, whatever the workspace flag is.
+    restoreFetch = stubEmptySkillList("api.acme.example.com")
   })
+  afterEach(() => restoreFetch())
 
   test("records and reads back a binding for the same directory + tenant", async () => {
     await recordApprovedBinding("/work/proj-a", {

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

@@ -517,6 +517,7 @@ describe("systemSection", () => {
     // step 2 needs no request of its own; joined to step 1's resolve, it could only render what
     // step 1 knew.
     const next = await inProject(systemSection)
+    expect(calls).toBe(1)
     release()
     await first
     expect(next).not.toContain('is "old"')

packages/opencode/test/altimate/workspace/launch-resolve.test.ts

@@ -41,6 +41,7 @@ const { recordApprovedBinding, cachePath } = await import(
 
 // Stub credentials so state.ts's tenant/apiUrl scoping is deterministic.
 import { AltimateApi } from "../../../src/altimate/api/client"
+import { stubEmptySkillList } from "./skill-list-fixture"
 type Creds = Awaited<ReturnType<typeof AltimateApi.getCredentials>>
 const originalIsConfigured = AltimateApi.isConfigured
 const originalGetCreds = AltimateApi.getCredentials
@@ -62,8 +63,12 @@ function unstubCreds() {
     originalGetCreds
 }
 
+let restoreFetch = () => {}
+
 beforeEach(() => {
   stubCreds()
+  // The resolver fixture awaits the skill sync that recording a link starts; answered offline.
+  restoreFetch = stubEmptySkillList("localhost:5001")
   setResolvedWorkspaceId(null)
   // Clean cache file between tests so state doesn't leak across cases.
   try {
@@ -77,6 +82,7 @@ beforeEach(() => {
 })
 afterEach(() => {
   unstubCreds()
+  restoreFetch()
   setResolvedWorkspaceId(null)
   delete process.env.ALTIMATE_WORKSPACE
 })

packages/opencode/test/altimate/workspace/routing-pin.test.ts

@@ -22,6 +22,7 @@ const { resolvePinnedBindingForRouting, recordApprovedBinding, __resetPinValidat
 const { refresh, precedenceInternals } = await import("../../../src/altimate/workspace/precedence")
 const { Instance } = await import("../../../src/project/instance")
 const { SNOWFLAKE_TOOLS } = await import("./precedence-fixture")
+const { stubEmptySkillList } = await import("./skill-list-fixture")
 const { AltimateApi } = await import("../../../src/altimate/api/client")
 const { WorkspaceApi } = await import("../../../src/altimate/workspace/api-client")
 
@@ -39,27 +40,6 @@ function stubCreds() {
     ({ altimateInstanceName: "acme", altimateUrl: "https://api.test", altimateApiKey: "k" }) as Creds
 }
 
-const originalFetch = globalThis.fetch
-
-/** Seeding a link runs a skill sync (awaited, see `seedLocalLink`) that lists the workspace's
- * skills from `api.test`. Answered here with an empty page, so that sync finishes offline instead
- * of waiting on however long a resolver takes to fail a name that cannot exist. */
-function stubFetch() {
-  globalThis.fetch = (async (input: string | URL, init?: RequestInit) => {
-    const url = new URL(String(input))
-    if (url.host !== "api.test") return originalFetch(input, init)
-    const skills = url.pathname.endsWith("/skills")
-    // The page is echoed back: the skill-list parser rejects a page that does not match its request.
-    const body = skills
-      ? { items: [], page: Number(url.searchParams.get("page") ?? "1"), pages: 1, total: 0 }
-      : { detail: "not found" }
-    return new Response(JSON.stringify(body), {
-      status: skills ? 200 : 404,
-      headers: { "content-type": "application/json" },
-    })
-  }) as typeof fetch
-}
-
 let listCalls = 0
 
 function stubList(rows: { id: number; name: string }[]) {
@@ -118,6 +98,7 @@ async function seedLocalLink(datamateId = 7, datamateName = "project-link") {
 }
 
 const ORIGINAL_PILOT = process.env.ALTIMATE_WORKSPACE
+let restoreFetch = () => {}
 
 beforeEach(() => {
   // `derive` short-circuits on `pilot-off` before it ever reads a binding.
@@ -126,7 +107,8 @@ beforeEach(() => {
   listCalls = 0
   __resetPinValidation()
   stubCreds()
-  stubFetch()
+  // Seeding a link awaits its skill sync (`seedLocalLink`); answered offline, per test.
+  restoreFetch = stubEmptySkillList("api.test")
   stubList([
     { id: 42, name: "pinned-workspace" },
     { id: 7, name: "project-link" },
@@ -135,6 +117,7 @@ beforeEach(() => {
 })
 
 afterEach(() => {
+  restoreFetch()
   clearPin()
   delete process.env.ALTIMATE_INTEGRATIONS
   // Restored per test, not only in `afterAll`: `beforeEach` sets it unconditionally, so leaving
@@ -155,7 +138,6 @@ afterAll(() => {
   ;(AltimateApi as unknown as { isConfigured: unknown }).isConfigured = originalIsConfigured
   ;(AltimateApi as unknown as { getCredentials: unknown }).getCredentials = originalGetCreds
   ;(WorkspaceApi as unknown as { listDatamates: unknown }).listDatamates = originalList
-  globalThis.fetch = originalFetch
   if (ORIGINAL_XDG_STATE_HOME === undefined) delete process.env.XDG_STATE_HOME
   else process.env.XDG_STATE_HOME = ORIGINAL_XDG_STATE_HOME
   rmSync(SANDBOX, { recursive: true, force: true })

packages/opencode/test/altimate/workspace/skill-list-fixture.ts

@@ -0,0 +1,28 @@
+// altimate_change - new file
+//
+// Recording a link starts a skill sync, and a test that awaits it (`awaitBackfill`) waits on that
+// sync's skill-list request. Against a stubbed Altimate host with no fetch stub, that request goes
+// to the real network and holds the test for as long as the host takes to fail — up to the API
+// client's 15s timeout. This answers it offline instead.
+
+/** Answer `host`'s skill-list request with an empty page, and anything else on it with a 404.
+ * Other hosts pass through to the fetch that was installed before. Returns the restore. */
+export function stubEmptySkillList(host: string): () => void {
+  const original = globalThis.fetch
+  globalThis.fetch = (async (input: string | URL, init?: RequestInit) => {
+    const url = new URL(String(input))
+    if (url.host !== host) return original(input, init)
+    const skills = url.pathname.endsWith("/skills")
+    // The page is echoed back: the skill-list parser rejects a page that does not match its request.
+    const body = skills
+      ? { items: [], page: Number(url.searchParams.get("page") ?? "1"), pages: 1, total: 0 }
+      : { detail: "not found" }
+    return new Response(JSON.stringify(body), {
+      status: skills ? 200 : 404,
+      headers: { "content-type": "application/json" },
+    })
+  }) as typeof fetch
+  return () => {
+    globalThis.fetch = original
+  }
+}

packages/opencode/test/altimate/workspace/state-account-scope.test.ts

@@ -24,6 +24,7 @@ process.env.OPENCODE_TEST_STATE_HOME = path.join(SANDBOX, "state")
 const { recordApprovedBinding, readLocalBinding, clearLocalBinding, cachePath, credentialDigest } =
   await import("../../../src/altimate/workspace/state")
 const { AltimateApi } = await import("../../../src/altimate/api/client")
+const { stubEmptySkillList } = await import("./skill-list-fixture")
 
 const ROOT = path.join(SANDBOX, "project")
 mkdirSync(ROOT, { recursive: true })
@@ -51,11 +52,16 @@ const binding = (datamateId: number, datamateName: string) => ({
   linkedAt: Date.now(),
 })
 
+let restoreFetch = () => {}
+
 beforeEach(() => {
   rmSync(cachePath(), { force: true })
+  // Recording a link here awaits its skill sync; answered offline, whatever the workspace flag is.
+  restoreFetch = stubEmptySkillList(new URL(API_URL).host)
 })
 
 afterEach(() => {
+  restoreFetch()
   ;(AltimateApi as unknown as { isConfigured: unknown }).isConfigured = originalIsConfigured
   ;(AltimateApi as unknown as { getCredentials: unknown }).getCredentials = originalGetCreds
 })