@humwick/runner 0.130.5 → 0.130.6

package/src/adapters/opencode-model-registry.ts

@@ -10,7 +10,7 @@ import { openCodeBackend, openCodeCustomBackendIDs, openCodeHostAuthKey, openCod
 import { openCodeMessageModel } from "./opencode-token-usage-capture";
 
 /**
- * #2659 — the host's opencode model registry, used to normalize a launch model before spawn.
+ * the host's opencode model registry, used to normalize a launch model before spawn.
  *
  * Primary: `opencode models --pure` run with the launch env but isolated XDG config/data (the
  * spawned server gets fresh isolated homes too), so it lists exactly the providers the server
@@ -55,7 +55,7 @@ export async function probeOpenCodeModelRegistry(
   extraProviders: string[],
   deps: OpenCodeRegistryProbeDeps = {},
 ): Promise<OpenCodeModelRegistry | undefined> {
-  const scratch = mkdtempSync(join(tmpdir(), "agent-relay-opencode-models-"));
+  const scratch = mkdtempSync(join(tmpdir(), "humwick-opencode-models-"));
   try {
     const { exitCode, stdout } = await (deps.run ?? runProbe)(
       [command, "models", "--pure"],
@@ -89,7 +89,7 @@ export function cachedOpenCodeModelRegistry(command: string, env: Record<string,
 }
 
 /**
- * #2659 — normalize the launch model against the host's opencode registry BEFORE the server
+ * normalize the launch model against the host's opencode registry BEFORE the server
  * starts: a registry-listed id passes through unchanged, and an unknown/ambiguous id fails the
  * spawn here with candidates instead of dying later as a provider 400.
  */
@@ -99,13 +99,13 @@ export async function resolveOpenCodeLaunchModel(
   provider: string,
   registryFor: typeof cachedOpenCodeModelRegistry = cachedOpenCodeModelRegistry,
 ): Promise<OpenCodeModelId> {
-  const env: Record<string, string> = writeChildEnv({}, { ...config.env, ...providerConfig.env, PATH: config.env.PATH ?? providerConfig.env.PATH ?? process.env.PATH ?? "" });
-  // #2866 — the registry probe runs under fresh XDG roots too, so a hostAuth backend only lists
+  const env: Record<string, string> = writeChildEnv({}, { ...config.env, ...providerConfig.env, PATH: config.env.PATH ?? providerConfig.env.PATH ?? process.env.PATH ?? "" }, []);
+  // the registry probe runs under fresh XDG roots too, so a hostAuth backend only lists
   // its models when the host login key rides in as the backend's env credential.
   const { backend } = openCodeBackend(provider);
   if (backend.hostAuth && !relayEnv(env, backend.apiKeyEnvVar)) {
     const hostKey = openCodeHostAuthKey(backend.opencodeProviderID, env);
-    if (hostKey) writeChildEnv(env, { [backend.apiKeyEnvVar]: hostKey });
+    if (hostKey) writeChildEnv(env, { [backend.apiKeyEnvVar]: hostKey }, []);
   }
   const registry = await registryFor(providerConfig.command || "opencode", env, openCodeCustomBackendIDs());
   const launch = openCodeLaunchModel(config.model, provider, openCodeModelRecord(config.modelRecord, provider), registry);
@@ -114,7 +114,7 @@ export async function resolveOpenCodeLaunchModel(
 }
 
 /**
- * #2659 — a model the human picked in the attached TUI rides on that prompt's user row
+ * a model the human picked in the attached TUI rides on that prompt's user row
  * (`info.model = {providerID, modelID}`). Adopt it as the session model so the next Relay chat
  * turn keeps it instead of re-sending the launch model.
  */

package/src/adapters/opencode-provider.ts

@@ -19,7 +19,7 @@ export function openCodeBackend(provider: string): OpenCodeBackend {
 }
 
 /**
- * #2599 — resolve the payload record for THIS provider, or reject an unknown provider LOUD.
+ * resolve the payload record for THIS provider, or reject an unknown provider LOUD.
  * A record whose providerModel/alias resolves against a DIFFERENT registered provider is a
  * routing error, not a fallback: silently running it under the wrong backend namespace would
  * launch the wrong model. The manifest fallback only applies when NO record is present at all.
@@ -36,7 +36,7 @@ export function openCodeBackendApiKeyEnvVar(backendID: string): string | undefin
 }
 
 /**
- * #2659 — the launch model: THE one normalization of a spawn's model through the shared seam
+ * the launch model: THE one normalization of a spawn's model through the shared seam
  * (`resolveOpenCodeModelId`). A server-threaded record's qualified name wins over the alias.
  * With a host registry (spawn), unknown/ambiguous ids throw with candidates; without one
  * (static fallback) a known-backend first segment is structural, anything else is a
@@ -61,7 +61,7 @@ export function openCodeModelDescriptor(model: string | undefined, provider = "o
 }
 
 /**
- * #2659 — the per-turn descriptor for an ALREADY-normalized qualified name (process meta.model).
+ * the per-turn descriptor for an ALREADY-normalized qualified name (process meta.model).
  * Never re-resolves: re-running the static split here re-prefixed live-only backends with the
  * default backend on every chat turn.
  */
@@ -72,7 +72,7 @@ export function openCodeTurnDescriptor(qualified: string, provider = "opencode")
 }
 
 /**
- * #2600 — the config-block + credential-env half of the per-model backend decision: the
+ * the config-block + credential-env half of the per-model backend decision: the
  * openCodeProviderID to key `provider.<id>` under, the apiKey env var the config references and
  * the launch env must carry (undefined for a live-registry backend Relay has no credential
  * mapping for — opencode then authenticates it from the inherited env itself), and any
@@ -111,7 +111,7 @@ export function openCodeContextWindowTokens(_model: string | undefined, provider
 }
 
 /**
- * #2599 — the record's explicit threshold, when present (precedence payload > manifest-derived).
+ * the record's explicit threshold, when present (precedence payload > manifest-derived).
  * Returns undefined when the record carries none — the caller then derives from the window.
  */
 export function openCodeContextThreshold(record: ResolvedModelRecord | undefined, provider = "opencode"): ResolvedModelRecord["contextThreshold"] {
@@ -121,7 +121,7 @@ export function openCodeContextThreshold(record: ResolvedModelRecord | undefined
 }
 
 /**
- * #2600/#2659 — the selected backend's credential from the runner or provider-config env
+ * the selected backend's credential from the runner or provider-config env
  * (`||`: an empty runner var must not mask a provider-config key). A live-registry backend
  * without a Relay credential mapping has none — opencode authenticates it from the inherited env.
  */
@@ -133,7 +133,7 @@ export function openCodeBackendCredential(apiKeyEnvVar: string | undefined, runn
 }
 
 /**
- * #2866 — the host's own `opencode auth login` key (`<data home>/opencode/auth.json`), which the
+ * the host's own `opencode auth login` key (`<data home>/opencode/auth.json`), which the
  * isolated XDG launch hides from the server. Only for manifests with `opencode.hostAuth`.
  */
 export function openCodeHostAuthKey(backendID: string, env: Record<string, string>): string | undefined {
@@ -147,7 +147,7 @@ export function openCodeHostAuthKey(backendID: string, env: Record<string, strin
   }
 }
 
-/** #2659 — is the session still on its launch model (no terminal model switch adopted)? */
+/** is the session still on its launch model (no terminal model switch adopted)? */
 export function openCodeOnLaunchModel(meta: Record<string, unknown> | undefined, model: string | undefined): boolean {
   const launchModel = typeof meta?.launchModel === "string" ? meta.launchModel : undefined;
   return !launchModel || !model || model === launchModel;

package/src/adapters/opencode-provisioning.ts

@@ -0,0 +1,30 @@
+import { join } from "node:path";
+import { writeFileSync } from "node:fs";
+import { sanitizeFsName } from "@humwick/sdk/fs-name";
+import type { RunnerSpawnConfig } from "../adapter";
+import { providerHomeRootFromEnv } from "../config";
+import { bundledIntegrationAssets } from "../provider-integration";
+import { materializeResolvedAssets, resolveProvisionedSkillPaths } from "../provisioning";
+import { profileAllowsRelayFeature, resolveRelayContext } from "../relay-instructions";
+import { launchWebTools } from "../web-tools";
+
+export function openCodeHome(config: RunnerSpawnConfig, provider = config.provider): string {
+  const profile = sanitizeFsName(config.agentProfile?.name || config.profile || "default", { replacement: "-", lowercase: true });
+  const instance = sanitizeFsName(config.instanceId || config.runnerId, { replacement: "-", lowercase: true });
+  return join(providerHomeRootFromEnv(), provider, profile, instance);
+}
+
+export function resolveOpenCodeAssets(config: RunnerSpawnConfig) {
+  const configDir = join(openCodeHome(config), "config", "opencode");
+  const provisioned = resolveProvisionedSkillPaths(configDir, config);
+  const bundled = profileAllowsRelayFeature(config, "skills") ? bundledIntegrationAssets(config) : [];
+  const context = resolveRelayContext({ slug: "relay.context.opencode", config, webTools: { names: launchWebTools(config), claude: false } });
+  const instructions = [context.text, config.systemPromptAppend?.trim()].filter(Boolean).join("\n\n");
+  return { configDir, provisioned, bundled, skills: [...provisioned, ...bundled], context,
+    instructions: instructions ? { path: join(configDir, "humwick-instructions.md"), text: instructions } : undefined };
+}
+
+export function materializeOpenCodeAssets(assets: ReturnType<typeof resolveOpenCodeAssets>): void {
+  materializeResolvedAssets(assets.skills);
+  if (assets.instructions) writeFileSync(assets.instructions.path, assets.instructions.text, { mode: 0o600 });
+}

package/src/adapters/opencode-server-retry.ts

@@ -1,4 +1,4 @@
-// #2775 — OpenCode's OWN in-session retry. On a retryable provider error OpenCode does not end the
+// OpenCode's OWN in-session retry. On a retryable provider error OpenCode does not end the
 // turn: it reports `session.status` `{ type: "retry", attempt, message, next, action? }` and keeps
 // the synchronous /message POST open until it succeeds. A free-tier wall schedules `next` for the
 // daily reset (hours out), so the agent sat busy and silent. These pure helpers decide when that

package/src/adapters/opencode-soft-steer.ts

@@ -1,4 +1,4 @@
-// #2539 Phase B — OpenCode/ZAI non-destructive soft-steer lane.
+// Phase B — OpenCode/ZAI non-destructive soft-steer lane.
 //
 // The soft op is `POST /session/:id/message` with a CALLER messageID + `noReply:true`: it
 // persists a user row WITHOUT joining/cancelling the active run, and the run's loop reloads
@@ -24,9 +24,9 @@ import { logger } from "../logger";
  * The one-row-per-batch marker the design mandates: tells the model the payload is a steer, not
  * a new assignment, and that completed work must not be discarded to act on it.
  */
-export const OPENCODE_SOFT_STEER_MARKER = "Agent Relay soft steer: incorporate at next safe step; do not discard completed work.";
+export const OPENCODE_SOFT_STEER_MARKER = "Humwick soft steer: incorporate at next safe step; do not discard completed work.";
 
-/** Short deadlines only — never the 60m whole-turn budget (#2539 design F). */
+/** Short deadlines only — never the 60m whole-turn budget. */
 export const OPENCODE_SOFT_STEER_POST_TIMEOUT_MS = 5_000;
 export const OPENCODE_SOFT_STEER_RECONCILE_TIMEOUT_MS = 5_000;
 
@@ -41,7 +41,7 @@ export const OPENCODE_SOFT_STEER_MAX_BATCH_BYTES = 48 * 1024;
  * `send()` turn gives the wake a real busy/idle pair and the full retry semantics instead of a
  * second, parallel turn machinery.
  */
-export const OPENCODE_SOFT_STEER_WAKE_TEXT = "Agent Relay: soft-steer guidance above is pending. Incorporate it now at this safe step; do not discard completed work. If nothing needs incorporating, reply with a single line: ACK.";
+export const OPENCODE_SOFT_STEER_WAKE_TEXT = "Humwick: soft-steer guidance above is pending. Incorporate it now at this safe step; do not discard completed work. If nothing needs incorporating, reply with a single line: ACK.";
 
 /**
  * Caller-side OpenCode messageID for a soft batch — `msg_` prefix (the shape the server accepts
@@ -99,7 +99,7 @@ export interface SoftSteerEntry {
 }
 
 /**
- * #2539 Phase A reconciliation — the ledger's settlement exits are the RUNNER's seams, handed in
+ * Phase A reconciliation — the ledger's settlement exits are the RUNNER's seams, handed in
  * through ProviderDeliverContext (settleMidTurnConsumed / reofferMidTurnIds). The ledger never
  * settles on its own: an absent callback is a fail-safe hold, never a silent settle.
  */

package/src/adapters/opencode-spawn.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { sanitizeFsName } from "@humwick/sdk/fs-name";
 import { providerScratchEnvOf } from "@humwick/sdk/provider-scratch";
 import { openCodeProjectShellEnv } from "./project-shell";
-import { providerHomeRootFromEnv } from "../config";
+import { openCodeHome, resolveOpenCodeAssets, materializeOpenCodeAssets } from "./opencode-provisioning";
 import { materializeProviderHome } from "../profile-home";
 import { syncOpenCodeRedactPlugin } from "../agent-redact";
 import type { ProviderConfig, RunnerSpawnConfig, SpawnArgs } from "../adapter";
@@ -40,14 +40,14 @@ export function assertOpenCodeManagedServerArgs(providerArgs: string[]): void {
   }
 }
 
-/** Prevent config substitution in caller-supplied model names (#2378). */
+/** Prevent config substitution in caller-supplied model names. */
 export function assertOpenCodeSafeModel(model: string | undefined): void {
   if (model?.includes("{")) {
     throw new Error(`OpenCode model must not contain "{" (would be spliced by OpenCode's own {env:...}/{file:...} config substitution): received ${JSON.stringify(model)}`);
   }
 }
 
-/** Preserve host gh auth while isolating OpenCode XDG state (#2531). */
+/** Preserve host gh auth while isolating OpenCode XDG state. */
 export function resolveGhConfigDir(inputEnv: Record<string, string | undefined>): string | undefined {
   const explicit = inputEnv.GH_CONFIG_DIR;
   if (explicit) return explicit;
@@ -64,14 +64,14 @@ export function buildOpenCodeSpawnArgs(config: RunnerSpawnConfig, providerConfig
   assertOpenCodeSafeModel(config.model);
   assertOpenCodeSafeModel(config.modelRecord?.qualifiedModel);
   openCodeBackend(provider);
-  // The selected model owns its backend and credential (#2599/#2600).
+  // The selected model owns its backend and credential.
   const resolved = openCodeResolvedBackend(launch.backendID, provider);
   // `||`, not `??`: an empty-string runner env var must not mask a valid providerConfig key.
   const apiKey = openCodeApiKey(config, launch.qualified) ?? openCodeBackendCredential(resolved.apiKeyEnvVar, config.env, providerConfig.env, resolved.hostAuth ? resolved.opencodeProviderID : undefined);
   const assembled = assembleLaunch(provider, config, providerConfig);
   const profile = sanitizeFsName(config.agentProfile?.name || config.profile || "default", { replacement: "-", lowercase: true });
   const instanceId = sanitizeFsName(config.instanceId || config.runnerId, { replacement: "-", lowercase: true });
-  const root = join(providerHomeRootFromEnv(), provider, profile, instanceId);
+  const root = openCodeHome(config, provider);
   materializeProviderHome(root, { provider: provider, profile, instanceId, agentId: config.agentId }, 0o700);
   const xdgConfig = join(root, "config");
   const xdgData = join(root, "data");
@@ -79,14 +79,18 @@ export function buildOpenCodeSpawnArgs(config: RunnerSpawnConfig, providerConfig
   const xdgCache = join(root, "cache");
   const configDir = join(xdgConfig, "opencode");
   for (const path of [xdgConfig, xdgData, xdgState, xdgCache, configDir]) mkdirSync(path, { recursive: true, mode: 0o700 });
+  const assets = resolveOpenCodeAssets(config);
+  materializeOpenCodeAssets(assets);
   // Permission is pinned in the isolated server config. A guarded/read-only request rejects
   // before this file is written, so a policy downgrade can never become a permissive launch.
   const configFile = join(configDir, "opencode.json");
   const mcp = openCodeMcpConfigForLaunch(config);
-  // Keep credentials out of disk config using native env references (#2378).
+  // Keep credentials out of disk config using native env references.
   writeFileSync(configFile, `${JSON.stringify({
     $schema: "https://opencode.ai/config.json",
     model: launch.qualified,
+    ...(assets.instructions ? { instructions: [assets.instructions.path] } : {}),
+    ...(assets.skills.length ? { skills: { paths: assets.skills.map(skill => skill.dir) } } : {}),
     ...(launch.backendID === "openai" ? { small_model: launch.qualified, enabled_providers: ["openai"] } : {}),
     provider: {
       [resolved.opencodeProviderID]: {
@@ -100,11 +104,11 @@ export function buildOpenCodeSpawnArgs(config: RunnerSpawnConfig, providerConfig
     permission: openCodePermissions(config), ...(Object.keys(mcp).length ? { mcp } : {}), ...openCodeToolsConfig(config, Object.keys(mcp).length > 0),
   }, null, 2)}\n`, { mode: 0o600 });
   chmodSync(configFile, 0o600);
-  // #3025 — `--pure` skips every plugin, so it is dropped only when agent-redact's plugin is in place.
+  // `--pure` skips every plugin, so it is dropped only when agent-redact's plugin is in place.
   const pure = syncOpenCodeRedactPlugin(configDir, assembled.redaction) ? [] : ["--pure"];
-  // Bridge gh from the host env before overlaying isolated XDG roots (#2531).
+  // Bridge gh from the host env before overlaying isolated XDG roots.
   const ghConfigDir = resolveGhConfigDir({ ...config.env, ...providerConfig.env, ...assembled.env });
-  // #2719 — allocated, never derived from another port. `controlPort + 1_000` overflowed 65535
+  // allocated, never derived from another port. `controlPort + 1_000` overflowed 65535
   // whenever the OS handed the runner a high ephemeral control port (macOS: 49152-65535), and
   // `serve --port 66178` did not fail loudly: opencode bound a different port, so readiness
   // polled the wrong URL for 20s and the runner exited 1 with no report.
@@ -113,12 +117,12 @@ export function buildOpenCodeSpawnArgs(config: RunnerSpawnConfig, providerConfig
   const env: SpawnArgs["env"] = writeChildEnv({}, {
     ...config.env,
     ...providerConfig.env,
-    // #3084 — the runner already nested the agent's private TMPDIR under any provider-config one;
-    // the shell hooks keep it (and #2947's toolchain PATH) after a login profile runs.
+    // the runner already nested the agent's private TMPDIR under any provider-config one;
+    // the shell hooks keep it (and the toolchain PATH) after a login profile runs.
     ...providerScratchEnvOf(config.env),
     ...openCodeProjectShellEnv(config.env),
     ...assembled.env,
-    // #2531 — gh (and git credential helpers wrapping gh) read the HOST gh config even
+    // gh (and git credential helpers wrapping gh) read the HOST gh config even
     // under the isolated XDG roots below. No other credential surface is bridged.
     ...(ghConfigDir ? { GH_CONFIG_DIR: ghConfigDir } : {}),
     XDG_CONFIG_HOME: xdgConfig,
@@ -131,8 +135,8 @@ export function buildOpenCodeSpawnArgs(config: RunnerSpawnConfig, providerConfig
     ...(resolved.apiKeyEnvVar && apiKey ? { [resolved.apiKeyEnvVar]: apiKey } : {}),
     OPENCODE_SERVER_PASSWORD: crypto.randomUUID(),
     OPENCODE_SERVER_URL: serverUrl,
-    AGENT_RELAY_PROVIDER: provider,
-  });
+    HUMWICK_PROVIDER: provider,
+  }, []);
   if (launch.backendID === "openai") {
     for (const key of ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN", "OPENCODE_API_KEY"]) writeChildEnv(env, {}, [key]);
   }

package/src/adapters/opencode-token-usage-capture.ts

@@ -1,13 +1,13 @@
-// #2484 — per-turn OpenCode/Zai token-usage capture, reusing the #2482/#2485 spine seam
+// per-turn OpenCode/Zai token-usage capture, reusing the spine seam
 // (ProviderTokenUsageReporter + POST /api/agents/:id/token-usage, validated live via Claude's
-// #2491 capture). Unlike Claude, OpenCode never hands the runner a transcript file to tail: the
+// capture). Unlike Claude, OpenCode never hands the runner a transcript file to tail: the
 // `message.updated` SSE door already carries a structured per-assistant-message `tokens` object
 // once a message finalizes — `{ input, output, reasoning, cache: { read, write } }`, confirmed
-// live against a real captured v1.18.21 session (see opencode-context.ts's #2355 note beside the
+// live against a real captured v1.18.21 session (see opencode-context.ts's note beside the
 // same wire shape). So there is no incremental-file tail here: this module is a pure decoder from
 // that object to the spine's required breakdown, called straight from the SSE handler.
 //
-// Dedupe: the door fires more than once per message as it streams toward its final total (#2427).
+// Dedupe: the door fires more than once per message as it streams toward its final total.
 // Keying on the message id makes every echo collapse onto the SAME spine row via the dedupe_key
 // upsert (`created_at >= existing` replaces) — the row simply refines towards the message's true
 // total rather than posting a new one per frame, exactly like Claude's uuid-keyed entries collapse
@@ -35,7 +35,7 @@ export function openCodeTokenUsageRecord(input: {
   messageId: string;
   tokens: unknown;
   createdAt?: number;
-  /** #3351 — the message is final, so unreadable counts mean unknown spend, not "not yet". */
+  /** the message is final, so unreadable counts mean unknown spend, not "not yet". */
   finished?: boolean;
 }): OpenCodeTokenUsageSpineRecord | undefined {
   const unknown = (): OpenCodeTokenUsageSpineRecord | undefined => input.finished ? {
@@ -53,7 +53,7 @@ export function openCodeTokenUsageRecord(input: {
   const cacheReadTokens = numberOrZero(cache?.read);
   const cacheWriteTokens = numberOrZero(cache?.write);
   // A recognised-but-entirely-empty object carries no signal — the same no-signal rule
-  // `openCodeContextState` applies to a `tokensUsed:0` reading of this identical shape (#2355
+  // `openCodeContextState` applies to a `tokensUsed:0` reading of this identical shape (
   // review MED-1: a genuinely engaged assistant message always has input > 0).
   if (inputTokens === 0 && outputTokens === 0 && reasoningOutputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0) return unknown();
   return {
@@ -71,9 +71,9 @@ export function openCodeTokenUsageRecord(input: {
 }
 
 /**
- * #2484 round 1 review (F6) — the message's OWN observed usage time: `time.completed` once
+ * round 1 review (F6) — the message's OWN observed usage time: `time.completed` once
  * finalized, else `time.created` (present on every AssistantMessage, per opencode-context.ts's
- * #2355 note on this same wire family). Reading this instead of `Date.now()` at report time
+ * note on this same wire family). Reading this instead of `Date.now` at report time
  * removes the equal-millisecond upsert race for the TERMINAL echo specifically: every
  * streaming echo of a still-open message shares the SAME `time.created`, and the terminal
  * echo's own `time.completed` is always `>=` it — so the spine's `created_at >= existing`
@@ -98,10 +98,10 @@ export function openCodeMessageFinished(info: unknown): boolean {
 }
 
 /**
- * #2484 round 1 review (F5) — the model the message was actually generated with, read off its own
+ * round 1 review (F5) — the model the message was actually generated with, read off its own
  * `providerID`/`modelID` (the same shape `openCodeModelDescriptor` sends on the request) rather
  * than the session's currently-configured model, which can have moved on (a mid-session
- * model/provider swap, a #2397 retry re-roll) by the time this echo is processed.
+ * model/provider swap, a retry re-roll) by the time this echo is processed.
  */
 export function openCodeMessageModel(info: unknown): string | undefined {
   if (!isRecord(info)) return undefined;
@@ -113,7 +113,7 @@ export function openCodeMessageModel(info: unknown): string | undefined {
 const TOKEN_USAGE_DEBOUNCE_MS = 300;
 
 /**
- * #2484 round 1 review (F2/F3) — the `message.updated` door fires repeatedly as one message
+ * round 1 review (F2/F3) — the `message.updated` door fires repeatedly as one message
  * streams to completion; posting on every echo means an HTTP POST + SQLite write per frame,
  * fleet-wide, for a value the very next echo immediately supersedes. Trailing-debounce per
  * message id: each new echo replaces the pending record and resets the timer, so a whole
@@ -137,7 +137,7 @@ export class OpenCodeTokenUsagePoster {
     this.pending.set(record.dedupeKey, { record, timer });
   }
 
-  // #2484 round 2 review (MED-1) — returns the in-flight delivery so a teardown caller can
+  // round 2 review (MED-1) — returns the in-flight delivery so a teardown caller can
   // actually await it (previously fire-and-forget: a caller that returned right after calling
   // this had no guarantee the POST had even started, let alone landed — the repo's
   // persisted-is-not-delivered shape). A live turn-boundary call (closeSuppressedTurn/

package/src/adapters/opencode-tool-events.ts

@@ -1,5 +1,5 @@
 /**
- * #2354 — decode OpenCode's `message.part.updated` tool parts (v1.18.21 `ToolPart`) into the
+ * decode OpenCode's `message.part.updated` tool parts (v1.18.21 `ToolPart`) into the
  * provider-neutral tool-step shape the chat/timeline already renders (TraceView `ToolCallRow`).
  *
  * `opencode.ts` is near the module-size ceiling, so the wire-decoding lives here as a small,
@@ -31,16 +31,16 @@ export interface OpenCodeToolStep {
   status: OpenCodeToolStepStatus;
   /** Safe one-line summary (redacted + clipped) of what the tool is doing. */
   body: string;
-  /** #2437 — redacted, size-capped tool input. Only present on the "running" state (the ToolPart
+  /** redacted, size-capped tool input. Only present on the "running" state (the ToolPart
    *  wire shape drops `input` once the tool completes) — undefined here means "not captured on
    *  THIS decode", not "no params exist"; see `emitToolStep`'s stepId cache for the carry-forward
    *  onto the terminal state. */
   params?: unknown;
-  /** #3411 — absolute paths a file tool reads or edits, from the raw input (running state only). */
+  /** absolute paths a file tool reads or edits, from the raw input (running state only). */
   paths?: string[];
 }
 
-/** OpenCode built-in tool name → the provider-independent category taxonomy (#1498). Anything
+/** OpenCode built-in tool name → the provider-independent category taxonomy. Anything
  *  not a known built-in (an MCP tool, a future built-in) falls to the mcp/generic default —
  *  never force-fit, so nothing is hidden from the trace. */
 const OPENCODE_TOOL_CATEGORIES: Record<string, ToolCallCategory> = {
@@ -56,7 +56,7 @@ const OPENCODE_TOOL_CATEGORIES: Record<string, ToolCallCategory> = {
   todoread: "plan",
 };
 
-/** #3411 — OpenCode's file tools; each names its file in `input.filePath`. */
+/** OpenCode's file tools; each names its file in `input.filePath`. */
 const OPENCODE_FILE_TOOLS = new Set(["read", "edit", "write", "multiedit"]);
 
 /** Extra input-field names OpenCode's built-in tools use that aren't in the shared candidate
@@ -67,7 +67,7 @@ export function openCodeToolCategory(tool: string): ToolCallCategory {
   const known = OPENCODE_TOOL_CATEGORIES[tool.toLowerCase()];
   if (known) return known;
   // MCP tools surface through OpenCode with a namespaced name; the `__` convention (shared with
-  // Claude's `mcp__server__tool`) is the safe signal. Everything else is generic (#2354 rule:
+  // Claude's `mcp__server__tool`) is the safe signal. Everything else is generic (rule:
   // unknown tool → generic), so a mystery tool still renders rather than vanishing.
   if (tool.includes("__") || tool.toLowerCase().startsWith("mcp")) return "mcp-tool-call";
   return "generic";
@@ -169,7 +169,7 @@ export function openCodeToolSessionEvent(step: OpenCodeToolStep, turnId: string
 }
 
 /**
- * #2413 — concatenate the terminal assistant message's text parts (wire order) into the turn-final
+ * concatenate the terminal assistant message's text parts (wire order) into the turn-final
  * response text. Non-text parts (tool, step-start/finish, reasoning) are skipped; the `\n\n` join
  * matches the dashboard's block delimiter, so a multi-part response's leading blocks dedupe against
  * the streamed narration. `undefined` when there is no assistant text.
@@ -186,7 +186,7 @@ export function openCodeAssistantText(parts: unknown[] | undefined): string | un
 }
 
 /**
- * #2605 — decode one `message.part.updated` reasoning part (`{ type: "reasoning", text }`,
+ * decode one `message.part.updated` reasoning part (`{ type: "reasoning", text }`,
  * pinned v1.18.21, live-verified in the provider's own SQLite: opencode/minimax-m2.5-free AND
  * kimi-for-coding sessions persist `{type:"reasoning",text}` parts) into the provider-neutral
  * emit fields. Pure — the adapter owns the dedup/emission, exactly like decodeOpenCodeToolPart.
@@ -202,7 +202,7 @@ export function decodeOpenCodeReasoningPart(part: unknown): { stepId: string; bo
   return { stepId, body };
 }
 
-/** #2605 — build the `reasoning` session event the chat/timeline consumes (TraceView reasoning
+/** build the `reasoning` session event the chat/timeline consumes (TraceView reasoning
  *  row): `stepId` = the stable part id, so the server upserts the row in place on growth instead
  *  of appending a duplicate — the same stable-key shape the Codex adapter flushes with.
  *  `streaming` stays true while the part is unfinished (`time.end` unset), false on finalize. */
@@ -218,7 +218,7 @@ export function openCodeReasoningSessionEvent(step: { stepId: string; body: stri
 }
 
 /**
- * #2605 — one decoded reasoning part with its provider-side identity. The `id` is the wire that
+ * one decoded reasoning part with its provider-side identity. The `id` is the wire that
  * makes the turn-final backstop upsert instead of duplicate: the server keys step rows on
  * `stepId` ONLY, so every turn-final reasoning row must carry the SAME stepId the live SSE door
  * already emitted for that part (see openCodeReasoningSessionEvent) — a merged/concatenated
@@ -231,7 +231,7 @@ export interface OpenCodeReasoningStep {
 }
 
 /**
- * #2605 — decode the completed assistant message's reasoning parts (wire order) into
+ * decode the completed assistant message's reasoning parts (wire order) into
  * per-part steps. Mirrors openCodeAssistantText's part walk, but keeps identity: one entry per
  * non-empty reasoning part (empty text is backend muzak — dropped by decodeOpenCodeReasoningPart
  * — so it never occupies a row). `[]` when the message carried no reasoning.
@@ -247,7 +247,7 @@ export function openCodeAssistantReasoningSteps(parts: unknown[] | undefined): O
 }
 
 /**
- * #2605 — concatenate the terminal assistant message's reasoning parts (wire order) into the
+ * concatenate the terminal assistant message's reasoning parts (wire order) into the
  * turn-final reasoning text. `undefined` when the completed message carried no (non-empty)
  * reasoning. Kept for the completion log line / describeCompletion only — the EMIT path uses
  * openCodeAssistantReasoningSteps (per-part identity) so live+final collapse to one row.
@@ -257,7 +257,7 @@ export function openCodeAssistantReasoning(parts: unknown[] | undefined): string
   return steps.length ? steps.map((step) => step.body).join("\n\n") : undefined;
 }
 
-/** #2413 — build the turn-final `response` event (marks it for Final Response capture / auto-forward
+/** build the turn-final `response` event (marks it for Final Response capture / auto-forward
  *  and styles it apart from reasoning). `undefined` when the turn produced no assistant text. */
 export function openCodeTurnFinalResponseEvent(text: string | undefined, turnId: string | undefined): ProviderSessionEvent | undefined {
   const body = text?.trim();
@@ -266,7 +266,7 @@ export function openCodeTurnFinalResponseEvent(text: string | undefined, turnId:
 }
 
 /**
- * #2605 — emit the turn-final `reasoning` rows (`completion.reasoningSteps`, read from the SAME
+ * emit the turn-final `reasoning` rows (`completion.reasoningSteps`, read from the SAME
  * synchronous POST body as the response below) plus that response, in order. Each reasoning row
  * carries its OWN part id as stepId — the exact key the live SSE door already emitted — so the
  * server upserts live+final into ONE row instead of storing the turn's thinking twice. Pure
@@ -281,7 +281,7 @@ export function openCodeTurnFinalResponseEvent(text: string | undefined, turnId:
  * path) — comparison is scoped to THOSE part ids, never to a global body pool, so an identical
  * body in a later turn is never misread as already-seen.
  *
- * The text is ground truth per #2389: the POST returning IS the provider-native turn-end edge,
+ * The text is ground truth: the POST returning IS the provider-native turn-end edge,
  * hence `confidence:"definitive"` on the response; `final:true` is what makes it a turn-final
  * capture downstream. Emits reasoning first so the trace reads thinking-then-answer, the order
  * the model produced them in. Either half may be absent (reasoning-only or text-only turns).