test(workspace): await the last detached link syncs, bound the TUI flush

skill-sync's negative-cache test and the new isApprovedRow tests seeded links
without `awaitBackfill`, so the guard could fail them at random. The TUI flush
is bounded at 5s; comments state the guard's serial-test assumption and that
it reads skill-sync's store key.

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

Author: ralphstodomingo

packages/opencode/src/altimate/workspace/skill-sync.ts

@@ -210,6 +210,8 @@ const REALM_ID = Math.random().toString(36).slice(2, 8)
  * (review) */
 const STAGING_LEASE_MS = 30 * 60 * 1000
 
+// test/preload.ts reads this store through this key (its skill-sync leak guard), without
+// importing this module. Renaming the key or `inFlight` silently disables that guard.
 const STORE_KEY = Symbol.for("altimate.workspace.skill-sync.store")
 
 export interface SkippedSkill {

packages/opencode/test/altimate/workspace/create-then-rebind.test.ts

@@ -120,7 +120,9 @@ beforeEach(() => {
 afterEach(async () => {
   // The TUI create leaves its skill sync detached so the dialog can close at once. Settled here,
   // against this file's stub, so it cannot run on into the next test.
-  await flushPendingSyncs()
+  // Bounded well inside the test timeout: a sync that never settles is the guard's to name, not a
+  // 30s stall here.
+  await flushPendingSyncs(5_000)
   globalThis.fetch = ORIGINAL_FETCH
   process.exitCode = 0 // Bun ignores `= undefined`; a leaked 1 fails later files
 })

packages/opencode/test/altimate/workspace/skill-sync.test.ts

@@ -2383,14 +2383,15 @@ describe("workspace skill sync", () => {
     }) as unknown as typeof fetch
     await syncSkills(project)
 
-    // The link. Deliberately still inside the miss window.
+    // The link. Deliberately still inside the miss window. Awaited: the sync it starts registers
+    // only once its dynamic import settles, so the `syncSkills` below may not join it.
     await recordApprovedBinding(project, {
       datamateId: 7,
       datamateName: "ws-7",
       repoRemote: null,
       projectPath: project,
       linkedAt: Date.now(),
-    })
+    }, { awaitBackfill: true })
     serve({ "pub-1": { "SKILL.md": "one" } })
     await syncSkills(project)
 

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

@@ -191,40 +191,40 @@ describe("isApprovedRow: whether this call's approval was written", () => {
   test("the row this call wrote is approved", async () => {
     asAccount("key-a")
     const row = binding(35, "Growth")
-    await recordApprovedBinding(ROOT, row, { account: A, seed: false })
+    await recordApprovedBinding(ROOT, row, { awaitBackfill: true, account: A, seed: false })
     expect(isApprovedRow(ROOT, A, 35, row.linkedAt)).toBe(true)
     expect(isApprovedRow(ROOT, A, 36, row.linkedAt)).toBe(false)
   })
 
   test("a write refused because the account changed first leaves nothing approved", async () => {
     asAccount("key-b")
     const row = binding(35, "Growth")
-    expect((await recordApprovedBinding(ROOT, row, { account: A }))?.status).toBe("account-changed")
+    expect((await recordApprovedBinding(ROOT, row, { awaitBackfill: true, account: A }))?.status).toBe("account-changed")
     expect(isApprovedRow(ROOT, A, 35, row.linkedAt)).toBe(false)
   })
 
   test("an approval recorded earlier does not vouch for a later write that was refused", async () => {
     asAccount("key-a")
-    await recordApprovedBinding(ROOT, { ...binding(35, "Growth"), linkedAt: Date.now() - 60_000 }, { account: A, seed: false })
+    await recordApprovedBinding(ROOT, { ...binding(35, "Growth"), linkedAt: Date.now() - 60_000 }, { awaitBackfill: true, account: A, seed: false })
     asAccount("key-b")
     const attempt = binding(35, "Growth")
-    expect((await recordApprovedBinding(ROOT, attempt, { account: A }))?.status).toBe("account-changed")
+    expect((await recordApprovedBinding(ROOT, attempt, { awaitBackfill: true, account: A }))?.status).toBe("account-changed")
     expect(isApprovedRow(ROOT, A, 35, attempt.linkedAt)).toBe(false)
   })
 
   test("a row another account wrote is not this account's approval", async () => {
     asAccount("key-b")
     const B = credentialDigest(API_URL, TENANT, "key-b")
     const row = binding(35, "Growth")
-    await recordApprovedBinding(ROOT, row, { account: B, seed: false })
+    await recordApprovedBinding(ROOT, row, { awaitBackfill: true, account: B, seed: false })
     expect(isApprovedRow(ROOT, B, 35, row.linkedAt)).toBe(true)
     expect(isApprovedRow(ROOT, A, 35, row.linkedAt)).toBe(false)
   })
 
   test("an adopted row for the same workspace is not an approval", async () => {
     asAccount("key-a")
     const row = { ...binding(35, "Growth"), adopted: true }
-    await recordApprovedBinding(ROOT, row, { account: A, seed: false })
+    await recordApprovedBinding(ROOT, row, { awaitBackfill: true, account: A, seed: false })
     expect(isApprovedRow(ROOT, A, 35, row.linkedAt)).toBe(false)
   })
 })

packages/opencode/test/preload.ts

@@ -140,6 +140,9 @@ initProjectors()
 // Syncs already running when a test starts are reported as inherited, not as that test's. One
 // whose start was deferred past its own test's end still lands on the next test; the message
 // says so, since telling them apart would mean tagging each sync with its owner in skill-sync.
+// Both rely on tests running one at a time in this process: under same-process `test.concurrent`
+// one test could be blamed for another's sync. Today's concurrent tests either spawn CLI
+// subprocesses (their own globals) or never reach skill-sync.
 type SkillSyncStore = { inFlight?: Map<string, Promise<unknown>> }
 const runningSyncs = () => [
   ...((globalThis as unknown as Record<symbol, SkillSyncStore | undefined>)[