fix: a pinned session's telemetry names the picked workspace

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

@@ -751,6 +751,66 @@ export async function resolvePinnedBindingForRouting(
   return resolvePinnedBinding(directory, pin)
 }
 
+/** How long a turn waits for the pin's verdict before its rows go without a workspace. Past the
+ * validation TTL the verdict is a round trip, and the routing read later in the same turn joins that
+ * request, so giving up here costs routing nothing. Waiting out the request instead would make a
+ * failed validation run twice, once here and once for routing. */
+export const TURN_PIN_WAIT_MS = 3_000
+
+/** The workspace a turn's telemetry rows name: the pin when there is one, else the project's link
+ * from the local cache.
+ *
+ * The pin's verdict comes from `resolvePinnedBindingForRouting`, so a row and the turn's routing
+ * cannot disagree. Unpinned turns stay on the local cache read, which makes no network call. A pin
+ * that cannot be honoured in time names nothing, for the reason routing fails closed: falling
+ * through would credit the turn to a workspace the user did not pick. */
+export async function resolveTurnBinding(
+  directory: string,
+  waitMs = TURN_PIN_WAIT_MS,
+): Promise<CachedBinding | null> {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const deadline = new Promise<BindingOutcome>((done) => {
+    timer = setTimeout(() => done({ status: "unknown" }), waitMs)
+    timer.unref?.()
+  })
+  const pinned = await Promise.race([resolvePinnedBindingForRouting(directory), deadline]).finally(() =>
+    clearTimeout(timer),
+  )
+  if (pinned) return pinned.status === "bound" ? pinned.binding : null
+  return readLocalBinding(directory)
+}
+
+/** Each session's verdict for its current turn, from the first read in the turn until the loop
+ * starts. Bounded: a turn that fails before its loop leaves its entry until the session's next
+ * turn clears it. */
+const turnVerdicts = new Map<string, Promise<CachedBinding | null>>()
+const TURN_VERDICTS_MAX = 256
+
+/** The workspace a session's current turn names. The first read in a turn resolves it and every
+ * later read in the turn gets the same answer: the attachment reads in the user message and the
+ * loop's start. So a turn waits for the pin at most once, adds at most one validation request, and
+ * names one workspace on all its rows. */
+export function turnBinding(
+  sessionID: string,
+  directory: string,
+  waitMs = TURN_PIN_WAIT_MS,
+): Promise<CachedBinding | null> {
+  const known = turnVerdicts.get(sessionID)
+  if (known) return known
+  const verdict = resolveTurnBinding(directory, waitMs).catch(() => null)
+  turnVerdicts.set(sessionID, verdict)
+  if (turnVerdicts.size > TURN_VERDICTS_MAX) {
+    const oldest = turnVerdicts.keys().next()
+    if (!oldest.done) turnVerdicts.delete(oldest.value)
+  }
+  return verdict
+}
+
+/** Ends the session's turn for `turnBinding`: the next read resolves afresh. */
+export function endTurnBinding(sessionID: string): void {
+  turnVerdicts.delete(sessionID)
+}
+
 export async function resolveBindingOutcome(directory: string): Promise<BindingOutcome> {
   // altimate_change — the IDE extension's selection outranks whatever binding this project carries.
   // Checked before the local cache and before any server lookup: the whole point is that the panel,

packages/opencode/src/session/prompt.ts

@@ -125,7 +125,7 @@ import { Telemetry } from "@/telemetry" // altimate_change — session telemetry
 import { ErrorDetail } from "@/altimate/telemetry/error-detail" // altimate_change — error_fingerprint payload
 // altimate_change start — the session's bound workspace rides on every telemetry row; workspace rules canonicalize bound
 // directories like the bindings cache does
-import { canonicalDirectory, readLocalBinding } from "@/altimate/workspace/state"
+import { canonicalDirectory, endTurnBinding, turnBinding } from "@/altimate/workspace/state"
 
 /** The session's workspace use, as session_end fields. Read only: the row is tracked first, then the
  * turn ends its telemetry entries (`Telemetry.endSession`), so the row itself still carries the
@@ -429,6 +429,8 @@ export namespace SessionPrompt {
 
   export const prompt = fn(PromptInput, async (input) => {
     const session = await Session.get(input.sessionID)
+    // altimate_change — a new turn: its rows name the workspace it resolves, not one an earlier turn left
+    endTurnBinding(input.sessionID)
     // altimate_change start — fork Session.Info (index zod) ≡ core Session.Info (session.ts) at the SessionRevert boundary
     await SessionRevert.cleanup(session as unknown as Parameters<typeof SessionRevert.cleanup>[0])
     // altimate_change end
@@ -576,6 +578,7 @@ export namespace SessionPrompt {
     }
 
     if (input.noReply === true) {
+      endTurnBinding(input.sessionID) // altimate_change — no loop takes this turn's workspace
       return message
     }
 
@@ -812,9 +815,12 @@ export namespace SessionPrompt {
       throw e
     }
     // altimate_change end
-    // altimate_change start — the workspace this project is linked to (local binding cache, no
-    // network), named by the rows of this turn that carry workspace_id.
-    const boundWorkspace = await readLocalBinding(Instance.directory).catch(() => null)
+    // altimate_change start — the workspace this turn works against (the IDE extension's pin, else
+    // the project's link), named by the rows of this turn that carry workspace_id.
+    // The verdict the user message's attachment reads used, when it has any, so every row of the turn
+    // names one workspace. Ended here: the next turn resolves its own.
+    const boundWorkspace = await turnBinding(sessionID, Instance.directory)
+    endTurnBinding(sessionID)
     const telemetryTurn = Telemetry.setContext({
       sessionId: sessionID,
       projectId: Instance.project?.id ?? "",
@@ -3382,8 +3388,8 @@ export namespace SessionPrompt {
                 const model = await Provider.getModel(info.model.providerID, info.model.modelID)
                 const readCtx: Tool.Context = {
                   sessionID: input.sessionID,
-                  // altimate_change — the project's binding, so the attachment read's tool rows name the workspace
-                  workspaceId: (await readLocalBinding(Instance.directory).catch(() => null))?.datamateId,
+                  // altimate_change — the turn's workspace, so the attachment read's tool rows name it
+                  workspaceId: (await turnBinding(input.sessionID, Instance.directory))?.datamateId,
                   abort: new AbortController().signal,
                   agent: input.agent!,
                   messageID: info.id,

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

@@ -17,8 +17,15 @@ const SANDBOX = path.join(os.tmpdir(), `altimate-routing-pin-test-${process.pid}
 mkdirSync(path.join(SANDBOX, "state"), { recursive: true })
 process.env.XDG_STATE_HOME = path.join(SANDBOX, "state")
 
-const { resolvePinnedBindingForRouting, recordApprovedBinding, __resetPinValidation, cachePath } =
-  await import("../../../src/altimate/workspace/state")
+const {
+  resolvePinnedBindingForRouting,
+  resolveTurnBinding,
+  turnBinding,
+  endTurnBinding,
+  recordApprovedBinding,
+  __resetPinValidation,
+  cachePath,
+} = await import("../../../src/altimate/workspace/state")
 const { refresh, precedenceInternals } = await import("../../../src/altimate/workspace/precedence")
 const { Instance } = await import("../../../src/project/instance")
 const { SNOWFLAKE_TOOLS } = await import("./precedence-fixture")
@@ -172,6 +179,89 @@ describe("resolvePinnedBindingForRouting", () => {
   })
 })
 
+describe("resolveTurnBinding", () => {
+  test("the pin outranks the project's link", async () => {
+    await seedLocalLink(7, "project-link")
+    setPin()
+    expect((await resolveTurnBinding(ROOT))?.datamateId).toBe(42)
+  })
+
+  test("with no pin it is the project's link, with no network call", async () => {
+    await seedLocalLink(7, "project-link")
+    expect((await resolveTurnBinding(ROOT))?.datamateId).toBe(7)
+    expect(listCalls).toBe(0)
+  })
+
+  test("a malformed pin names nothing, not the project's link", async () => {
+    await seedLocalLink(7, "project-link")
+    setPin({ ALTIMATE_PINNED_WORKSPACE_ID: "not-a-number" })
+    expect(await resolveTurnBinding(ROOT)).toBeNull()
+  })
+
+  test("a directory outside the pinned root names nothing, not the project's link", async () => {
+    await seedLocalLink(7, "project-link")
+    setPin({ ALTIMATE_PINNED_WORKSPACE_ROOT: path.join(SANDBOX, "elsewhere") })
+    expect(await resolveTurnBinding(ROOT)).toBeNull()
+  })
+
+  test("a validation that outlasts the wait names nothing, and routing joins that same request", async () => {
+    await seedLocalLink(7, "project-link")
+    const answer = Promise.withResolvers<{ id: number; name: string }[]>()
+    ;(WorkspaceApi as unknown as { listDatamates: () => Promise<unknown> }).listDatamates = () => {
+      listCalls += 1
+      return answer.promise
+    }
+    setPin()
+    expect(await resolveTurnBinding(ROOT, 5)).toBeNull()
+    const routing = resolvePinnedBindingForRouting(ROOT)
+    answer.resolve([{ id: 42, name: "pinned-workspace" }])
+    expect((await routing)?.status).toBe("bound")
+    expect(listCalls).toBe(1)
+  })
+})
+
+describe("turnBinding", () => {
+  test("every read in a turn gets the first verdict, even once validation has finished", async () => {
+    const answer = Promise.withResolvers<{ id: number; name: string }[]>()
+    ;(WorkspaceApi as unknown as { listDatamates: () => Promise<unknown> }).listDatamates = () => {
+      listCalls += 1
+      return answer.promise
+    }
+    setPin()
+    expect(await turnBinding("ses_turn_slow", ROOT, 5)).toBeNull()
+    answer.resolve([{ id: 42, name: "pinned-workspace" }])
+    expect(await resolvePinnedBindingForRouting(ROOT)).toMatchObject({ status: "bound" })
+    expect(await turnBinding("ses_turn_slow", ROOT, 5)).toBeNull()
+
+    endTurnBinding("ses_turn_slow")
+    expect((await turnBinding("ses_turn_slow", ROOT, 5))?.datamateId).toBe(42)
+    expect(listCalls).toBe(1)
+    endTurnBinding("ses_turn_slow")
+  })
+
+  test("a refused pin is checked once per turn, however many reads the turn makes", async () => {
+    stubList([{ id: 7, name: "project-link" }])
+    setPin()
+    for (let read = 0; read < 3; read++) expect(await turnBinding("ses_turn_refused", ROOT)).toBeNull()
+    expect(listCalls).toBe(1)
+
+    endTurnBinding("ses_turn_refused")
+    expect(await turnBinding("ses_turn_refused", ROOT)).toBeNull()
+    expect(listCalls).toBe(2)
+    endTurnBinding("ses_turn_refused")
+  })
+
+  test("each session has its own turn", async () => {
+    await seedLocalLink(7, "project-link")
+    expect((await turnBinding("ses_turn_a", ROOT))?.datamateId).toBe(7)
+    setPin()
+    expect((await turnBinding("ses_turn_b", ROOT))?.datamateId).toBe(42)
+    expect((await turnBinding("ses_turn_a", ROOT))?.datamateId).toBe(7)
+    endTurnBinding("ses_turn_a")
+    endTurnBinding("ses_turn_b")
+  })
+})
+
 describe("precedence.derive — the routing read", () => {
   const SESSION = "ses_routing_pin"