fix: a failed prompt leaves no workspace verdict, and the workspace telemetry review's follow-ups

docs/docs/reference/telemetry.md

@@ -114,6 +114,7 @@ Other rows gain workspace fields in a linked project:
 
 - Every event carries `client: "altimate-code"`, which names the product that sent it. `source` still says how the CLI was launched.
 - Rows of a turn in a linked project carry that project's `workspace_id`: `session_start`, `session_end`, `first_prompt_sent`, `first_job_completed`, `skill_used`, `skill_published`, `memory_injection`, `agent_outcome`, `task_classified`, `task_outcome_signal`, `tool_chain_outcome`, `core_failure`, `error_fingerprint`, `plan_revision`, `sql_quality` and `tool_call`.
+- With `ALTIMATE_DISABLE_WORKSPACE` set, no `first_prompt_sent` or `first_job_completed` is sent for the project's saved link, and an onboarding session's own rows name no workspace. The turn's other rows still name that link, read from the local cache with no request; a pin from the IDE extension is not read. Once the switch is off, the workspace's first rows are sent as usual.
 - `session_end` counts the workspace skills, memory blocks and integration calls the session used. `memory_injection` counts the workspace's blocks. `task_outcome_signal` says whether workspace context was used.
 - A call to a workspace integration through the engine is reported as a `tool_call` with `tool_type: "mcp"` and `via_workspace: true`. As for other tools, there are no arguments or outputs, and an error message is masked and capped at 500 characters.
 - An `endpoint` value is a route label with every id and path segment replaced by `:id`, for example `POST /datamate-project-bindings/bind`. It never contains an id, a file path or a query string.

packages/opencode/src/altimate/plugin/onboarding-telemetry.ts

@@ -264,14 +264,20 @@ export async function OnboardingTelemetryPlugin(_input: PluginInput): Promise<Ho
       ) {
         // altimate_change — the workspace of the turn that ran the tool, carried by the hook input
         // from the trigger site: a tool returning after its turn was cancelled and replaced still
-        // names its own turn's workspace, not the replacement's.
+        // names its own turn's workspace, not the replacement's. None with the kill switch set.
+        const workspaceId = WorkspaceFirstEvents.firstEventWorkspace(input.workspaceId)
         void OnboardingTelemetry.emit(
-          { type: "first_job_completed", job, workspace_id: input.workspaceId, origin: "onboarding" },
+          { type: "first_job_completed", job, workspace_id: workspaceId, origin: "onboarding" },
           input.sessionID,
         )
         // Marked so the end of this turn, or a later session, doesn't send the workspace's row as well.
-        if (input.workspaceId !== undefined) {
-          await WorkspaceFirstEvents.claim("first_job_completed", input.workspaceId)
+        // Under the credential of the turn that ran the tool, which its workspace id belongs to.
+        if (workspaceId !== undefined) {
+          await WorkspaceFirstEvents.claim(
+            "first_job_completed",
+            workspaceId,
+            WorkspaceFirstEvents.callScope(input.callID),
+          )
         }
       }
     },

packages/opencode/src/altimate/workspace/first-events.ts

@@ -10,9 +10,13 @@
 // agent does the work with other tools. So a job here is a turn with at least one tool call that
 // didn't fail, ending `completed`, the outcome `task_outcome_signal` reports as `accepted`. It
 // reports as `something_else` because nothing says which job it was.
+//
+// With the workspace kill switch set, no first event names the project's saved link, so a project
+// linked before the switch was set isn't counted as that workspace's first prompt or job.
 import { createHash } from "node:crypto"
 import { mkdir, writeFile } from "node:fs/promises"
 import path from "node:path"
+import { Flag } from "@opencode-ai/core/flag/flag"
 import { Global } from "@/global"
 import { Log } from "@/altimate/util/log"
 import { Telemetry } from "@/altimate/telemetry"
@@ -80,8 +84,38 @@ export async function claim(event: FirstEvent, workspaceId: number, scope?: Scop
   }
 }
 
+/** The credential scope of the turn each tool call ran in, while that call's `tool.execute.after`
+ * plugins run. The trigger site notes it from its own turn, so a mark made there names the tenant the
+ * call's workspace id belongs to, even when the credential has switched since, or the turn was
+ * cancelled and replaced before the tool returned. Keyed by call id, not session: a session's later
+ * turn has its own calls. */
+const callScopes = new Map<string, Scope>()
+
+/** Notes `scope` for `callID` until the returned handle is disposed. */
+export function noteCallScope(callID: string | undefined, scope: Scope | undefined): Disposable {
+  if (callID === undefined || !scope) return { [Symbol.dispose]() {} }
+  callScopes.set(callID, scope)
+  return {
+    [Symbol.dispose]() {
+      if (callScopes.get(callID) === scope) callScopes.delete(callID)
+    },
+  }
+}
+
+/** The scope noted for a tool call, while its plugins run. */
+export function callScope(callID: string): Scope | undefined {
+  return callScopes.get(callID)
+}
+
+/** The workspace a first event may name: none while the workspace kill switch is set. Nothing is
+ * marked then either, so the workspace's rows are still sent once the switch is off. */
+export function firstEventWorkspace(workspaceId: number | undefined): number | undefined {
+  return Flag.ALTIMATE_DISABLE_WORKSPACE ? undefined : workspaceId
+}
+
 /** A typed prompt: the onboarding row and the workspace row are one row when both apply. */
-export async function promptSent(sessionID: string, workspaceId: number | undefined, scope?: Scope): Promise<void> {
+export async function promptSent(sessionID: string, turnWorkspaceId: number | undefined, scope?: Scope): Promise<void> {
+  const workspaceId = firstEventWorkspace(turnWorkspaceId)
   const onboarding = OnboardingTelemetry.isOnboardingSession(sessionID) && OnboardingTelemetry.claimFirstPrompt(sessionID)
   const inWorkspace = workspaceId !== undefined && (await claim("first_prompt_sent", workspaceId, scope))
   if (onboarding || inWorkspace) {
@@ -93,7 +127,12 @@ export async function promptSent(sessionID: string, workspaceId: number | undefi
 }
 
 /** A turn in a workspace that ended `completed` with at least one tool call that didn't fail. */
-export async function jobCompleted(sessionID: string, workspaceId: number | undefined, scope?: Scope): Promise<void> {
+export async function jobCompleted(
+  sessionID: string,
+  turnWorkspaceId: number | undefined,
+  scope?: Scope,
+): Promise<void> {
+  const workspaceId = firstEventWorkspace(turnWorkspaceId)
   if (workspaceId === undefined) return
   if (await claim("first_job_completed", workspaceId, scope)) {
     await OnboardingTelemetry.emit(
@@ -106,5 +145,6 @@ export async function jobCompleted(sessionID: string, workspaceId: number | unde
 /** Test seam: drops this process's memory of the marks, as a new process would start. */
 export function resetForTest() {
   sent.clear()
+  callScopes.clear()
   warnedUnwritable = false
 }

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

@@ -793,7 +793,8 @@ export async function resolveTurnBinding(
   waitMs = TURN_PIN_WAIT_MS,
 ): Promise<TurnBinding | null> {
   // With the workspace kill switch on, nothing else in the session reads the pin, so the turn sends
-  // no validation request and waits for none. Its rows read the link, as they do on `main`.
+  // no validation request and waits for none. Its rows read the link, as they did before the pin
+  // was honoured.
   if (!workspaceEnabled()) return linkedTurnBinding(directory)
   let timer: ReturnType<typeof setTimeout> | undefined
   const deadline = new Promise<BindingOutcome>((done) => {

packages/opencode/src/session/prompt.ts

@@ -125,7 +125,13 @@ 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, endTurnBinding, turnBinding, unvalidatedTurnBinding } from "@/altimate/workspace/state"
+import {
+  canonicalDirectory,
+  endTurnBinding,
+  turnBinding,
+  unvalidatedTurnBinding,
+  type AccountKey,
+} 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
@@ -1825,6 +1831,7 @@ export namespace SessionPrompt {
               // altimate_change start — file rules append only to this tool result
               lessons,
               workspaceId: boundWorkspace?.datamateId,
+              workspaceScope: boundWorkspace?.scope,
               turn: telemetryTurn,
               // altimate_change end
             }),
@@ -2845,6 +2852,8 @@ export namespace SessionPrompt {
     /** The workspace the calling turn resolved, for the rows its MCP calls emit, and the turn itself,
      * so a call landing after the turn was replaced does not count toward the replacement. */
     workspaceId?: number
+    /** The credential that turn's workspace was resolved under, noted for each tool call's plugins. */
+    workspaceScope?: AccountKey
     turn?: number
     // altimate_change end
   }) {
@@ -2970,6 +2979,8 @@ export namespace SessionPrompt {
             // altimate_change start — stamp authoritative tool source so clients render the right
             // badge. Shared with SessionTools.resolve (session/tools.ts) so the resolvers can't drift.
             const stamped = stampRegistryToolSource(output, item)
+            // The turn's credential, for this call's plugins: a first-event mark names its tenant.
+            using _callScope = WorkspaceFirstEvents.noteCallScope(ctx.callID, input.workspaceScope)
             // altimate_change end
             await Plugin.trigger(
               "tool.execute.after",
@@ -3195,6 +3206,14 @@ export namespace SessionPrompt {
         ? await unvalidatedTurnBinding(Instance.directory)
         : await turnBinding(input.sessionID, Instance.directory)
       )?.datamateId
+    // Every part settles before a failed one is rethrown. A part still running after another failed could
+    // otherwise read the turn's workspace once `prompt` has cleared it, and leave a verdict for the next
+    // loop started without a prompt (summarize, resume) to take.
+    function settled<T>(results: PromiseSettledResult<T>[]): T[] {
+      const failed = results.find((result): result is PromiseRejectedResult => result.status === "rejected")
+      if (failed) throw failed.reason
+      return results.map((result) => (result as PromiseFulfilledResult<T>).value)
+    }
     // altimate_change end
     const agentName = input.agent ?? (await Agent.defaultAgent())
     const agent = await Agent.get(agentName)
@@ -3250,7 +3269,9 @@ export namespace SessionPrompt {
       id: part.id ? PartID.make(part.id) : PartID.ascending(),
     })
 
-    const parts = await Promise.all(
+    // altimate_change start — every part settles before a failure is rethrown (see `settled`)
+    const parts = await Promise.allSettled(
+      // altimate_change end
       input.parts.map(async (part): Promise<Draft<MessageV2.Part>[]> => {
         if (part.type === "file") {
           // before checking the protocol we check if this is an mcp resource because it needs special handling
@@ -3580,7 +3601,9 @@ export namespace SessionPrompt {
           },
         ]
       }),
-    ).then((x) => x.flat().map(assign))
+      // altimate_change start — every part settles before a failure is rethrown (see `settled`)
+    ).then((x) => settled(x).flat().map(assign))
+    // altimate_change end
 
     await Plugin.trigger(
       "chat.message",

packages/opencode/test/altimate/telemetry/onboarding.test.ts

@@ -123,6 +123,14 @@ async function runTool(hooks: any, input: any, output: any) {
 
 describe("activation events", () => {
   const SESSION = "ses_test"
+  // The suite's preload sets the workspace kill switch. A test that needs workspaces on, as a user's
+  // CLI has them, clears it, and it is put back after each test.
+  const KILL_SWITCH = process.env.ALTIMATE_DISABLE_WORKSPACE
+  const workspacesOn = () => delete process.env.ALTIMATE_DISABLE_WORKSPACE
+  afterEach(() => {
+    if (KILL_SWITCH === undefined) delete process.env.ALTIMATE_DISABLE_WORKSPACE
+    else process.env.ALTIMATE_DISABLE_WORKSPACE = KILL_SWITCH
+  })
 
   async function plugin() {
     return OnboardingTelemetryPlugin({} as any)
@@ -221,6 +229,7 @@ describe("activation events", () => {
   })
 
   test("the first job's row names the workspace the hook input carries", async () => {
+    workspacesOn()
     const events = captureEvents()
     const hooks = await plugin()
     await startOnboarding(hooks, "skip")
@@ -240,6 +249,7 @@ describe("activation events", () => {
   })
 
   test("the first job's row marks its workspace, so the workspace's own row isn't sent after it", async () => {
+    workspacesOn()
     await withTestStateHome(async () => {
       spyOn(Telemetry, "isEnabled").mockImplementation(() => true)
       spyOn(AltimateApi, "isConfigured").mockImplementation(async () => true)
@@ -264,6 +274,70 @@ describe("activation events", () => {
     })
   })
 
+  test("the first job's mark is the tool's own turn's tenant, when the credential switched before a late return", async () => {
+    workspacesOn()
+    await withTestStateHome(async () => {
+      spyOn(Telemetry, "isEnabled").mockImplementation(() => true)
+      spyOn(AltimateApi, "isConfigured").mockImplementation(async () => true)
+      // By the time the tool returns, the user has signed in to another tenant.
+      spyOn(AltimateApi, "getCredentials").mockImplementation(
+        async () => ({ altimateInstanceName: "other", altimateUrl: "https://api.test", altimateApiKey: "k2" }) as never,
+      )
+      WorkspaceFirstEvents.resetForTest()
+      captureEvents()
+      const hooks = await plugin()
+      await startOnboarding(hooks, "skip")
+      const acme = { tenant: "acme", apiUrl: "https://api.test" }
+      const other = { tenant: "other", apiUrl: "https://api.test" }
+
+      // The cancelled turn's call, and its replacement's, both still running: each trigger site notes
+      // its own turn's credential.
+      using _late = WorkspaceFirstEvents.noteCallScope("c3late", acme)
+      using _replacement = WorkspaceFirstEvents.noteCallScope("c9new", other)
+      await runTool(
+        hooks,
+        { tool: "sample_setup", sessionID: SESSION, callID: "c3late", args: {}, workspaceId: 7 },
+        { title: "", output: "", metadata: { success: true } },
+      )
+      await settle()
+
+      expect(await WorkspaceFirstEvents.claim("first_job_completed", 7, acme)).toBe(false)
+      // The other tenant's workspace 7 is a different workspace: its own first row is still sent.
+      expect(await WorkspaceFirstEvents.claim("first_job_completed", 7, other)).toBe(true)
+      WorkspaceFirstEvents.resetForTest()
+    })
+  })
+
+  test("with the workspace kill switch set, the first job's row names no workspace and marks none", async () => {
+    await withTestStateHome(async () => {
+      process.env.ALTIMATE_DISABLE_WORKSPACE = "1"
+      spyOn(Telemetry, "isEnabled").mockImplementation(() => true)
+      spyOn(AltimateApi, "isConfigured").mockImplementation(async () => true)
+      spyOn(AltimateApi, "getCredentials").mockImplementation(
+        async () => ({ altimateInstanceName: "acme", altimateUrl: "https://api.test", altimateApiKey: "k" }) as never,
+      )
+      WorkspaceFirstEvents.resetForTest()
+      const events = captureEvents()
+      const hooks = await plugin()
+      await startOnboarding(hooks, "skip")
+
+      await runTool(
+        hooks,
+        { tool: "sample_setup", sessionID: SESSION, callID: "c3k", args: {}, workspaceId: 7 },
+        { title: "", output: "", metadata: { success: true } },
+      )
+      await settle()
+
+      const completed = events.find((e) => e.type === "first_job_completed") as any
+      expect(completed.origin).toBe("onboarding")
+      expect(completed.workspace_id).toBeUndefined()
+      // Nothing was marked: with the switch off, the workspace's own first job is still sent.
+      workspacesOn()
+      expect(await WorkspaceFirstEvents.claim("first_job_completed", 7)).toBe(true)
+      WorkspaceFirstEvents.resetForTest()
+    })
+  })
+
   test("a failed sample setup counts as selected but not completed", async () => {
     const events = captureEvents()
     const hooks = await plugin()