@humwick/runner 0.130.5 → 0.130.6

package/src/adapters/opencode.ts

@@ -27,9 +27,9 @@ import { OPENCODE_SOFT_STEER_POST_TIMEOUT_MS, OPENCODE_SOFT_STEER_RECONCILE_TIME
 export { openCodeContextThreshold, openCodeContextWindowTokens, openCodeModelDescriptor, openCodeModelRecord, openCodeQualifiedModel } from "./opencode-provider";
 
 /**
- * #2459 — the non-secret attachment generation for a web-terminal guest: a short one-way
+ * the non-secret attachment generation for a web-terminal guest: a short one-way
  * digest of the ACTIVE OpenCode session id. It changes exactly when the session rotates
- * (clearContext / the #2397 retry re-roll) and lets the orchestrator detect a stale guest
+ * (clearContext / the retry re-roll) and lets the orchestrator detect a stale guest
  * TUI — attached to a dead conversation — WITHOUT ever seeing the session id itself or any
  * credential (a digest of a 122-bit-random uuid is not reversible in practice). Rides the
  * attach spec, the runner's GET /terminal/generation, and the orchestrator's guest registry;
@@ -47,7 +47,7 @@ export interface OpenCodeServerEvent {
 type OpenCodeFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 
 /**
- * #2428 — Bun extends its fetch init with a per-request `timeout` field that the standard
+ * Bun extends its fetch init with a per-request `timeout` field that the standard
  * RequestInit type does not declare (`number | false`; `false` disables Bun's native HTTP idle
  * watchdog for that one request). Neither @types/node's nor bun-types 1.3.14's ambient
  * RequestInit/BunFetchRequestInit declares the field, so it is declared here rather than reached
@@ -60,7 +60,7 @@ type OpenCodeFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<R
 export type OpenCodeRequestInit = RequestInit & { timeout?: number | false };
 
 /**
- * #2425 — whole-turn budget for `OpenCodeClient.sendMessage`'s synchronous POST (see its doc).
+ * whole-turn budget for `OpenCodeClient.sendMessage`'s synchronous POST (see its doc).
  * Env-tunable so an operator can trade a tighter bound for faster abandonment-detection on a
  * flaky network, or a longer one for a model/workload that legitimately runs longer than an hour.
  * The default is intentionally large rather than unbounded — `AbortSignal.timeout` requires a
@@ -136,14 +136,14 @@ export class OpenCodeClient {
   }
 
   /**
-   * #2389 — this POST is the SYNCHRONOUS endpoint: it returns only once the assistant message is
+   * this POST is the SYNCHRONOUS endpoint: it returns only once the assistant message is
    * complete, so its status and duration describe the whole turn, not just the hand-off.
    *
    * It used to be entirely silent on success — no status, no timing, no access log — so when a
    * spawned agent idled forever there was no way to establish whether its first prompt had even
    * been accepted; that took reading the provider's own retained SQLite. Log it.
    *
-   * #2425 — this call used to carry NO abort signal at all, yet a live, still-running turn was
+   * this call used to carry NO abort signal at all, yet a live, still-running turn was
    * observed being cut off client-side at roughly 294s regardless. Combined with the old PERMANENT
    * idle suppression, that stranded the agent's status at "idle" forever even though the server
    * kept working — see the `suppressProviderIdle` field doc on `OpenCodeAdapter`. Passing an
@@ -151,7 +151,7 @@ export class OpenCodeClient {
    * never the thing that trips it, and gives `send()` a deterministic abandonment point to recover
    * from if it ever does.
    *
-   * #2428 — ROOT CAUSED (Bun repro): that ~294s cutoff is Bun's native HTTP idle watchdog — a
+   * ROOT CAUSED (Bun repro): that ~294s cutoff is Bun's native HTTP idle watchdog — a
    * fetch whose response sends no bytes for BUN_CONFIG_HTTP_IDLE_TIMEOUT (default 300s) dies
    * client-side with TimeoutError "The operation timed out" INDEPENDENTLY of the AbortSignal
    * above, which bounds only its own much longer duration. This endpoint is synchronous, so any
@@ -171,7 +171,7 @@ export class OpenCodeClient {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ model: openCodeTurnDescriptor(model, this.provider), parts: [{ type: "text", text }] }),
         signal: AbortSignal.timeout(timeoutMs),
-        // #2428 — disable Bun's native HTTP idle watchdog for this whole-turn request only; the
+        // disable Bun's native HTTP idle watchdog for this whole-turn request only; the
         // signal above remains the sole deadline. See OpenCodeRequestInit for the verified semantics.
         timeout: false,
       });
@@ -185,7 +185,7 @@ export class OpenCodeClient {
   }
 
   /**
-   * #2534 — bounded read of a session's persisted messages, used ONLY by the acceptance
+   * bounded read of a session's persisted messages, used ONLY by the acceptance
    * reconciliation when a context-carrying turn's completion await failed: a user message whose
    * persisted text equals the outbound prompt is positive proof the server ACCEPTED it, even
    * though the await never resolved. Kept on a short, explicit deadline — this runs on a failure
@@ -197,7 +197,7 @@ export class OpenCodeClient {
   }
 
   /**
-   * #2539 Phase B — the soft-steer persist primitive: POST /session/:id/message with a CALLER
+   * Phase B — the soft-steer persist primitive: POST /session/:id/message with a CALLER
    * messageID + noReply:true. LIVE-PROVEN on pinned 1.18.21: persists the user row in single-digit
    * milliseconds WITHOUT joining/cancelling an in-flight run (does not touch the runner effect that
    * prompt_async would join), and the response body IS the persisted user message — so
@@ -227,7 +227,7 @@ export class OpenCodeClient {
   }
 
   /**
-   * #2539 Phase B — the ambiguous-outcome reconcile: does the session's persisted message list
+   * Phase B — the ambiguous-outcome reconcile: does the session's persisted message list
    * contain EXACTLY this caller messageID? true/false are definitive (the GET succeeded and the
    * full session listing either has the row or does not); undefined means the listing itself was
    * unavailable — still ambiguous. Matching is by exact id, never by text (a resend must never
@@ -248,10 +248,10 @@ export class OpenCodeClient {
   }
 
   /**
-   * #2440 — OpenCode's own native session-compaction endpoint (a prior effort, #2431, wrongly
+   * OpenCode's own native session-compaction endpoint (a prior effort, wrongly
    * concluded it did not exist and shipped clear-inject only). Like `sendMessage`, this may run
    * long server-side, so it gets the same Bun idle-watchdog bypass (`timeout: false`) plus an
-   * explicit bounded `AbortSignal` — see `sendMessage`'s doc for the verified #2428 semantics.
+   * explicit bounded `AbortSignal` — see `sendMessage`'s doc for the verified semantics.
    * A session-not-found / compact-already-in-progress / server error all surface as the same
    * `request()`-thrown `HTTP <status>` error; the adapter's caller resets its busy hold on catch.
    */
@@ -278,8 +278,8 @@ export class OpenCodeClient {
 }
 
 /**
- * Retry/re-roll policy for a retryable turn-ending provider error (#2397). Direct measurement
- * (issue #2397 comment) showed these failures are BIMODAL per OpenCode session — a session either
+ * Retry/re-roll policy for a retryable turn-ending provider error. Direct measurement
+ * showed these failures are BIMODAL per OpenCode session — a session either
  * succeeds on every attempt or fails on every attempt for its whole life — so retrying harder
  * into the SAME session eventually accomplishes nothing. Bound the in-session retry tightly, then
  * re-roll to a fresh session (new session id, same server process) exactly once before giving up.
@@ -289,24 +289,24 @@ const OPENCODE_ERROR_RETRY_BASE_DELAY_MS = 1_000;
 
 /** Exponential backoff for retry attempt N (1-indexed): 1s, 2s, 4s at the defaults above. Driven
  *  entirely by our own policy — OpenRouter sends neither `retry-after` nor `x-ratelimit-*` for
- *  this error class (confirmed live, #2397), so there is nothing external to read. */
+ *  this error class, so there is nothing external to read. */
 export function openCodeErrorRetryDelayMs(attempt: number): number {
   return OPENCODE_ERROR_RETRY_BASE_DELAY_MS * 2 ** Math.max(0, attempt - 1);
 }
 
 /**
- * #2397 — a parsed assistant-message error off the pinned v1.18.21 wire.
+ * a parsed assistant-message error off the pinned v1.18.21 wire.
  *
  * `AssistantMessage.error` is a union (ProviderAuthError | UnknownError |
  * MessageOutputLengthError | MessageAbortedError | ApiError — see @opencode-ai/sdk's generated
  * types). Only `ApiError` carries a structured `statusCode`/`isRetryable`; OpenCode falls back to
- * `UnknownError` for anything it doesn't recognize. Verified live (#2397): a real OpenRouter 429
+ * `UnknownError` for anything it doesn't recognize. Verified live: a real OpenRouter 429
  * arrived as `UnknownError` with the raw provider response embedded as a JSON STRING in
  * `data.message` (`{"code":429,"message":"...","metadata":{"error_type":"rate_limit_exceeded"}}`),
  * not as a structured ApiError. So this parses defensively — peeling that nested JSON when
  * present — rather than trusting a shape that is usually absent for the errors that matter most.
  */
-/** #2619 — how one `send()` turn ended; see its doc. */
+/** how one `send` turn ended; see its doc. */
 type OpenCodeSendOutcome = "ok" | "failed" | "held";
 
 export interface OpenCodeAssistantError {
@@ -349,7 +349,7 @@ export function parseOpenCodeAssistantError(raw: unknown): OpenCodeAssistantErro
 }
 
 /**
- * #2443 — a 404 from OpenCode's own session-message endpoint means OpenRouter has no route for
+ * a 404 from OpenCode's own session-message endpoint means OpenRouter has no route for
  * the requested provider/model at all (retired, mistyped, or never released) — generic across
  * ANY OpenRouter-routed model, never a specific one. Classifying it as the SDK's canonical
  * `model-unavailable` reason (already used by the Claude adapter for its own "model doesn't
@@ -361,7 +361,7 @@ export function openCodeTerminalFailureReason(error: Pick<OpenCodeAssistantError
 }
 
 /**
- * #2397 — the operator-visible providerState for "still trying" (retrying in-session, or
+ * the operator-visible providerState for "still trying" (retrying in-session, or
  * re-rolled to a fresh session and retrying), reusing `buildRateLimitProviderState`'s shape
  * (label/kind/source/errorType/timestamps) rather than a bespoke one. `reason` is overridden away
  * from `RATE_LIMIT_BLOCK_REASON` ("rate_limit") deliberately: that reason is special-cased in
@@ -372,7 +372,7 @@ export function openCodeTerminalFailureReason(error: Pick<OpenCodeAssistantError
  * ordinary busy-claim path (the same path `permission.asked` already uses below).
  */
 export function openCodeUpstreamRetryState(input: { attempt: number; rerolled: boolean; message: string; errorType?: string }): ProviderState {
-  // #2397 round 2 (F7) — only call it a rate limit when the parsed error actually said so.
+  // round 2 (F7) — only call it a rate limit when the parsed error actually said so.
   // `errorType` used to default to "rate_limit_exceeded" here, and the label was hardcoded to
   // "Rate-limited upstream" regardless of cause, so a 500/503 (isRetryable via the >=500 branch
   // in parseOpenCodeAssistantError, with no errorType at all) was misreported as a rate limit.
@@ -397,7 +397,7 @@ export function openCodeUpstreamRetryState(input: { attempt: number; rerolled: b
 }
 
 /**
- * #2389 — what the synchronous `/message` POST hands back: the completed assistant message.
+ * what the synchronous `/message` POST hands back: the completed assistant message.
  *
  * This is ground truth for the incident and needs no inference at all. The stranded agent's turn
  * came back `finish=stop` with no text part, no tool part and zero tokens — an empty completion the
@@ -406,7 +406,7 @@ export function openCodeUpstreamRetryState(input: { attempt: number; rerolled: b
  * Read defensively: OpenCode's wire is only pinned at v1.18.21, so an unrecognised shape yields
  * `undefined` counts and simply contributes no signal, leaving the cross-provider ledger to decide.
  *
- * #2397 — also carries the assistant message's `error`, when positively parseable. This is a
+ * also carries the assistant message's `error`, when positively parseable. This is a
  * STRONGER signal than `empty`: a turn can end with a non-empty `parts` count (the live incident's
  * completion carried one bare step-start part) and still be a turn-ending PROVIDER failure, so
  * `error` is checked ahead of (and independently of) the `empty` heuristic by every reader.
@@ -414,7 +414,7 @@ export function openCodeUpstreamRetryState(input: { attempt: number; rerolled: b
 export interface OpenCodeCompletion {
   parts?: number;
   /**
-   * #2397 round 3 (HIGH-1) — `parts` count MINUS bookkeeping-only parts (`step-start`,
+   * round 3 (HIGH-1) — `parts` count MINUS bookkeeping-only parts (`step-start`,
    * `step-finish`), which the server emits on every turn — including one that produced nothing
    * but a provider error. The live incident this issue was filed on captured exactly that shape:
    * one bare `step-start` part, zero tokens, a 429. `parts` alone is 1, which reads as "the model
@@ -425,8 +425,8 @@ export interface OpenCodeCompletion {
   finish?: string;
   error?: OpenCodeAssistantError;
   /**
-   * #2413 — the terminal assistant message's TEXT, concatenated from its text parts. This
-   * synchronous POST returns the completed assistant message (ground truth, #2389), so the
+   * the terminal assistant message's TEXT, concatenated from its text parts. This
+   * synchronous POST returns the completed assistant message, so the
    * turn-final response is read from it directly rather than reconstructed from a possibly-late
    * or lost SSE frame. Present only when the completed message carried assistant text; absent for
    * a tools-only or empty turn.
@@ -435,7 +435,7 @@ export interface OpenCodeCompletion {
   /** True only when the shape WAS understood and it says the model produced nothing. */
   empty: boolean;
   /**
-   * #2605 — the terminal assistant message's REASONING as per-part steps (`{stepId, body}[]`,
+   * the terminal assistant message's REASONING as per-part steps (`{stepId, body}`,
    * wire order). Present only when the completed message carried non-empty reasoning; absent
    * for text/tools-only or empty turns. Per-part identity (not a joined string) is what lets
    * the turn-final emit upsert the live SSE rows instead of duplicating them — the server keys
@@ -444,13 +444,13 @@ export interface OpenCodeCompletion {
    */
   reasoningSteps?: OpenCodeReasoningStep[];
   /**
-   * #2605 — the same reasoning as one joined string (the steps' bodies, `\n\n` join mirroring
+   * the same reasoning as one joined string (the steps' bodies, `\n\n` join mirroring
    * `text`). Kept for the completion log line only — the EMIT path reads `reasoningSteps`.
    */
   reasoning?: string;
 }
 
-/** #2397 round 3 (HIGH-1) — a bookkeeping marker the server emits around every turn regardless of
+/** round 3 (HIGH-1) — a bookkeeping marker the server emits around every turn regardless of
  *  outcome, never evidence the model produced anything. An unrecognised part shape is counted as
  *  output (the conservative default): under-counting risks re-treating real work as empty and
  *  re-executing it, which is the worse failure. */
@@ -471,7 +471,7 @@ function countTokens(value: unknown): number | undefined {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (!isRecord(value)) return undefined;
   // `{ input, output, reasoning, cache: {...} }` on the pinned version, plus — confirmed against a
-  // real captured v1.18.21 session (#2355) — a top-level `total` that is ALREADY the sum of every
+  // real captured v1.18.21 session — a top-level `total` that is ALREADY the sum of every
   // other leaf here (`input + output + reasoning + cache.read + cache.write`). When present it is
   // authoritative and must be returned directly: falling through to the leaf sum below as well
   // would double-count it (`total` + its own constituent parts).
@@ -511,7 +511,7 @@ export function openCodeCompletion(body: unknown): OpenCodeCompletion {
     ...(reasoning ? { reasoning } : {}),
     // Only claim emptiness when the shape was actually understood: a body we could not parse must
     // never be reported as an empty completion.
-    // #2397 round 3 review (LOW-4r) — must agree with `completionProducedOutput`'s `outputParts`,
+    // round 3 review (LOW-4r) — must agree with `completionProducedOutput`'s `outputParts`,
     // not raw `parts`, or a bookkeeping-only body (step-start, tokens:0, no error) slips past BOTH
     // predicates in send(): not `producedOutput` (correctly), but also not `empty` — landing on
     // "if (!completion.empty) return true" with no turnActivityCb, no retry-hold clear, and no
@@ -530,7 +530,7 @@ function describeCompletion(completion: OpenCodeCompletion): string {
   return ` → ${bits.join(", ")}${completion.empty ? " — EMPTY COMPLETION" : ""}`;
 }
 
-/** Bound on the live per-session bookkeeping in `OpenCodeAdapter` (#2347): a headless agent can
+/** Bound on the live per-session bookkeeping in `OpenCodeAdapter`: a headless agent can
  *  run for days across many turns, so unbounded maps keyed by message/part id would leak. Both
  *  `messageRoles` and `emittedTextParts` are pruned back to this size, oldest first, whenever a
  *  write would exceed it. */
@@ -551,7 +551,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   readonly reportsContextResets = true;
   readonly provider: string;
   readonly statusSourceId: string;
-  // #2440 — unlocks `context.resume = "native"` capability advertisement (see
+  // unlocks `context.resume = "native"` capability advertisement (see
   // runtimeProviderContextCapabilities). `opts.instructions` is deliberately NOT threaded into the
   // `/compact` HTTP call itself (see `performCompact`'s doc) — the relay's own reactive
   // continuation inject already delivers it as a follow-up message either way, exactly like
@@ -560,7 +560,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // OpenCode's `/compact` endpoint is NOT instruction-steerable — `performCompact` never sends the
   // continuation on the wire at all, so the summarizer itself never sees it. Setting this flag true
   // is what makes `resume:"native"` selectable; the actual delivery guarantee comes entirely from
-  // the reactive inject, not from this flag. Follow-up #2442 tracks a cleaner capability bit that
+  // the reactive inject, not from this flag. Tracks a cleaner capability bit that
   // distinguishes "native resume is offered" from "the compact call itself accepts steering text",
   // so a future reader doesn't read this as "the summary is instructable" when it is not.
   readonly compactSupportsInstructions = true;
@@ -568,53 +568,53 @@ export class OpenCodeAdapter implements ProviderAdapter {
   private sessionEventCb: (event: ProviderSessionEvent) => void = () => {};
   private turnActivityCb: () => void = () => {};
   // `message.updated` (role) always precedes that message's `message.part.updated` events on the
-  // real v1.18.21 wire (verified live against OpenRouter meta/muse-spark-1.3-contributor, #2347) — spawn()
+  // real v1.18.21 wire (verified live against OpenRouter meta/muse-spark-1.3-contributor) — spawn
   // subscribes before any prompt is sent, so there is no race for the normal launch flow.
   private readonly messageRoles = new Map<string, string>();
   private readonly emittedTextParts = new Set<string>();
-  // #2354 — stepId → highest lifecycle rank already emitted for that tool part, so a duplicate or
+  // stepId → highest lifecycle rank already emitted for that tool part, so a duplicate or
   // reordered `message.part.updated` (a late `running` after `completed`, a repeated frame) never
   // regresses or double-emits the step. Pruned to OPENCODE_EVENT_STATE_LIMIT like the maps above.
   private readonly emittedToolSteps = new Map<string, number>();
-  // #2437 — the ToolPart wire shape only carries `input` while `running`; a `completed` decode has
+  // the ToolPart wire shape only carries `input` while `running`; a `completed` decode has
   // none. Cache the redacted params captured at running, keyed by stepId, and carry them forward
   // onto the terminal event so the row's params don't vanish when the server upserts it in place
   // (upsertSessionStepInPlace replaces the whole payload with the incoming one, not a merge).
   private readonly toolStepParams = new Map<string, unknown>();
-  // #2605 — reasoning part id → full body already emitted for that part, so a repeated or
+  // reasoning part id → full body already emitted for that part, so a repeated or
   // finalized `message.part.updated` frame for the same reasoning part emits the CURRENT full
   // text (the server upserts the trace row in place by stepId) instead of appending a duplicate
   // row. Pruned to OPENCODE_EVENT_STATE_LIMIT like the maps above.
   private readonly emittedReasoningParts = new Map<string, string>();
-  // #2413 review (HIGH-1) — a genuinely PER-SEND turn id, minted at the top of each `send()` and
+  // review (HIGH-1) — a genuinely PER-SEND turn id, minted at the top of each `send` and
   // used for the busy edge, narration, tool steps, and the turn-final response alike. Was
   // `process.meta.sessionId`, which PERSISTS across sends: two turns in one session then shared a
   // turnId, so lineage dedup (promoteLineageCapturedResponse/flushWorkFinalReports) forwarded the
   // FIRST turn's body and dropped the SECOND — the real final report never reached the coordinator.
   private sendTurnId: string | undefined;
-  // #2397 round 2 (F3/F4) — live-confirmed: the real server emits its OWN busy/idle
+  // round 2 (F3/F4) — live-confirmed: the real server emits its OWN busy/idle
   // session.status pair around EVERY attempt, including failed ones (two `idle` events for one
   // errored turn). Left alone, each failed attempt's idle looks like a real provider-turn close
-  // to runner-core's #2389 seam: it clears `currentTurnId` and judges that blip as an empty turn,
+  // to runner-core's seam: it clears `currentTurnId` and judges that blip as an empty turn,
   // then the next attempt's busy mints a brand-new turn id — up to
   // `OPENCODE_ERROR_RETRY_MAX_ATTEMPTS * 2` extra empty-turn closes the operator sees, and a
   // premature nudge/escalation mid-retry. Raised for the WHOLE `send()` call (see the loop entry),
   // this swallows every transient idle for the call's own turn so the whole retry sequence stays
   // ONE turn from the runner's view.
-  // #2397 round 5 review (MED-1) — this is now a STICKY suppression, not cleared at close time:
+  // round 5 review (MED-1) — this is now a STICKY suppression, not cleared at close time:
   // `closeSuppressedTurn` used to lower it as it fired, so a HEALTHY turn's own trailing real SSE
   // idle — if processed after the POST already resolved — sailed through unsuppressed and closed
   // the same turn a SECOND time (duplicate reInjectPendingObligation, duplicate
   // completeObservedTaskClaims/Task-done). The invariant that actually holds: an idle belonging to
   // a turn `send()` already closed must stay swallowed; only an idle for a turn that STARTS AFTER
   // that close may pass.
-  // #2397 round 6 review (MED-1r) — round 5 had `handleEvent`'s BUSY door lower this flag whenever
+  // round 6 review (MED-1r) — round 5 had `handleEvent`'s BUSY door lower this flag whenever
   // `turnInFlight` was false, on the assumption that such a busy edge could only be a genuinely new
   // turn. That is a timing assumption, not an invariant: `subscribe()` dispatches a whole SSE chunk
   // synchronously in one loop, and the SSE/POST sockets have no cross-ordering guarantee, so a late
   // own-turn busy+idle pair batched together AFTER the POST resolves cleared suppression via the
   // busy half and then let the idle half sail straight through — double-closing the turn.
-  // #2397 round 7 review (MED-1/MED-2/LOW-1) — round 6 only made the reopen one-shot (the FIRST
+  // round 7 review (MED-1/MED-2/LOW-1) — round 6 only made the reopen one-shot (the FIRST
   // post-close idle lowered this flag again), which still let a SECOND trailing idle in the same
   // window (two late idles; a 429-retry where both attempts' own idles land after send() returns;
   // a foreign child session's busy+idle, since `handleEvent` never filters `properties.sessionID`)
@@ -623,19 +623,19 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // real turn-boundary transition for a turn `send()` actually SAW END is already emitted
   // EXPLICITLY by `send()` (its own `busy` at each attempt's start) and by
   // `closeSuppressedTurn`/`failTurn` (their own `idle`/`error`) — never by this SSE echo.
-  // #2425 — that reasoning has exactly one hole: it assumes `send()` always learns how its own
+  // that reasoning has exactly one hole: it assumes `send` always learns how its own
   // turn ended. `sendMessage`'s POST can instead THROW with the server-side turn's outcome
   // unknown (a client-side timeout on a turn that keeps running upstream) — see `turnAbandoned`
   // below. In that one case ONLY, staying permanent forever would swallow every subsequent real
   // busy/idle for the rest of this adapter instance's life, freezing status at whatever
   // `send()`'s own `finally` guessed. Both SSE doors below therefore also check `turnAbandoned`
-  // — the per-session filter (also added for #2425) is what makes that safe: a foreign session's
+  // — the per-session filter is what makes that safe: a foreign session's
   // busy/idle can never reach here regardless of `turnAbandoned`, so lifting suppression for OUR
   // OWN session's real events reopens no hazard round 7 was guarding against.
   private suppressProviderIdle = false;
-  // #2425 — true once THIS call's own `finally` closed the turn WITHOUT any deterministic
+  // true once THIS call's own `finally` closed the turn WITHOUT any deterministic
   // success/failure branch having run first (i.e. `sendMessage` or something else in the retry
-  // loop threw — a client-side timeout being the motivating case, #2425's incident). The server-
+  // loop threw — a client-side timeout being the motivating case, the incident). The server-
   // side outcome is genuinely unknown in that case, unlike a normal completion or `failTurn`
   // (both of which set `turnClosed` themselves before the `finally` runs, so `turnAbandoned` stays
   // false for them — see the `finally` block). While true, the two SSE doors above stop enforcing
@@ -645,35 +645,35 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // boundary, its own explicit busy/idle is authoritative again, and any stray leftover event from
   // a truly-abandoned previous turn must stay suppressed rather than corrupt the new turn's state.
   private turnAbandoned = false;
-  // #2619 — a session re-roll already spent in the current provider-hold episode; cleared by the
+  // a session re-roll already spent in the current provider-hold episode; cleared by the
   // first turn that goes through (send() → "ok"). Bounds a long wall to ONE history-dropping re-roll.
   private rerolledThisHoldEpisode = false;
-  // #2775 — a wall OpenCode's own retry hit during this send(); the session is aborted and send() holds.
+  // a wall OpenCode's own retry hit during this send; the session is aborted and send holds.
   private serverRetryWall?: OpenCodeServerRetry;
-  // #2397 round 5 review (MED-1/LOW-2) — true from the moment `send()` is actually about to run an
+  // round 5 review (MED-1/LOW-2) — true from the moment `send` is actually about to run an
   // attempt (past the readiness guard, so a "session not ready" throw never sets it) through the
   // call's `finally`.
-  // #2397 round 7 review — no longer read by either SSE door (both now key only on the permanent
+  // round 7 review — no longer read by either SSE door (both now key only on the permanent
   // `suppressProviderIdle` above). Still captured by `send()`'s `finally` (round 6, MED-2r) to
   // decide whether THIS call ever actually started an attempt, so a "session not ready" throw
   // never triggers a close for a turn that never began.
   private turnInFlight = false;
-  // #2397 round 5 review (MED-1) — true once THIS call's own close has already fired (via
+  // round 5 review (MED-1) — true once THIS call's own close has already fired (via
   // `closeSuppressedTurn` or `failTurn`), reset at the top of every `send()` call. Distinct from
   // `suppressProviderIdle` (which deliberately stays raised after firing, per above): this is the
   // idempotency guard that stops the SAME call's multiple close sites — an explicit branch call
   // plus the `finally` fallback — from emitting a second idle for one call.
-  // #2425 — also doubles as the double-close guard for the `turnAbandoned` escape hatch: once
+  // also doubles as the double-close guard for the `turnAbandoned` escape hatch: once
   // abandonment force-closes a turn, this stays true until a genuine same-session busy re-arms it
   // (see the busy door), so a stray trailing idle for the SAME abandoned turn finds it already
   // closed and is a no-op rather than a second `idle` dispatch.
   private turnClosed = false;
-  // #2431 round 1 (HIGH) — FIFO serializer making `clearContext()` safe against an IN-FLIGHT turn.
+  // round 1 (HIGH) — FIFO serializer making `clearContext` safe against an IN-FLIGHT turn.
   // `agent.clearContext` is dispatched fire-and-forget (dispatchCommand holds no provider-input
   // ticket for it — PROVIDER_INPUT_COMMAND_TYPES is inject-only) and OpenCode's `/message` POST is
-  // SYNCHRONOUS (#2389), so the model calling relay_compact_and_resume from within its own turn
+  // SYNCHRONOUS, so the model calling humwick_compact_and_resume from within its own turn
   // means the command genuinely runs WHILE send() is still awaiting that POST. send()'s retry loop
-  // re-reads process.meta.sessionId every iteration and cannot tell its own #2397 reroll from an
+  // re-reads process.meta.sessionId every iteration and cannot tell its own reroll from an
   // external swap, so an unserialized clear redirected the live turn's retries/rerolls — and their
   // reportContextUsage writes — straight into the freshly cleared session. Every writer of that
   // per-call state therefore goes through this queue: both send() call sites (deliverInitialPrompt/
@@ -686,11 +686,11 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // command early, because "clear anyway on timeout" would reintroduce exactly this bug.
   private turnQueue: Promise<unknown> = Promise.resolve();
 
-  // ─── #2539 Phase B — non-destructive soft-steer lane (default-OFF kill switch) ───
+  // ─── Phase B — non-destructive soft-steer lane (default-OFF kill switch) ───
   // Durable-until-consumed ledger for positively-persisted soft batches (persistence != delivery).
   private readonly softSteer = new OpenCodeSoftSteerLedger();
   // The soft lane's OWN one-in-flight FIFO (fast loopback POSTs) — deliberately NOT turnQueue:
-  // serializing soft steers behind whole turns is the 84-minute #2539 delay this lane exists to
+  // serializing soft steers behind whole turns is the 84-minute delay this lane exists to
   // remove. Only the POST+reconcile run here; the wake turn (rare, fallback) goes through
   // turnQueue like any normal turn so it owns a real busy/idle pair.
   private softSteerQueue: Promise<unknown> = Promise.resolve();
@@ -700,7 +700,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   private softSteerProcess: ManagedProcess | undefined;
 
   /**
-   * #2544 — the operator-facing capability bit. DEFAULT-ON since the review-gated flip: the
+   * the operator-facing capability bit. DEFAULT-ON since the review-gated flip: the
    * deployed-fleet canary soak (one opencode/zai agent, 2026-09-11) proved the end-to-end path
    * through A's seam — fold-in, durable-until-consumed settlement, no dup/loss/hot-loop, no run
    * disruption. The per-offer policy reads `ProviderConfig.activeTurnMessageDelivery` via
@@ -710,8 +710,8 @@ export class OpenCodeAdapter implements ProviderAdapter {
    */
   readonly supportsMidTurnSteer = true;
 
-  // #2459 — event-driven turn identity for TERMINAL-origin turns. OpenCode is headless with no
-  // server-initiated turns (the #2397 round-7 invariant), so a session.status:busy arriving for
+  // event-driven turn identity for TERMINAL-origin turns. OpenCode is headless with no
+  // server-initiated turns, so a session.status:busy arriving for
   // the active session OUTSIDE send() can only be a prompt typed into an attached web-terminal
   // TUI. send() is not running then, so its sticky `suppressProviderIdle` would otherwise swallow
   // the whole turn, and the events would fall back to the STALE `sendTurnId` of the last headless
@@ -721,7 +721,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // Assistant text accumulated (finalized text parts, active session) while the event turn is
   // open, so its close can emit the turn-final response exactly like send()'s POST path does.
   private eventTurnText: string[] = [];
-  // #2605 — reasoning observed this event turn, keyed by part id to the LATEST body seen. The
+  // reasoning observed this event turn, keyed by part id to the LATEST body seen. The
   // terminal-origin path has no completed-message POST to read back from, so the close must
   // reconcile from what the live door saw — but keyed per part (not a body pool): a growth
   // frame for an already-emitted part only needs the newest snapshot, and an identical body in
@@ -729,17 +729,17 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // Bounded: part ids are server-unique per turn and the map is reset every turn, so it holds
   // at most one entry per reasoning part of the CURRENT turn — no prefix scan, no growth.
   private eventTurnReasoning = new Map<string, string>();
-  // #2459 round 1 (review D) — the EVENT-SOURCE discriminator replacing the round-0 time
+  // round 1 (review D) — the EVENT-SOURCE discriminator replacing the round-0 time
   // window. A terminal-origin turn is always PRECEDED by its prompt: the attached TUI's
   // POST creates the user message on the active session before/while the turn's busy edge
   // flows, so the message.updated(role=user) door arms this flag. The busy door admits a
-  // terminal turn only when armed (or when no headless turn ever suppressed, or #2425
+  // terminal turn only when armed (or when no headless turn ever suppressed, or
   // abandonment). A HEADLESS echo — the buffered busy+idle pair of a turn send() just
   // closed — has NO such fresh user message by construction, so it stays suppressed with NO
   // time bound: a delayed echo of any age is indistinguishable from a stale one and both are
-  // dropped, restoring #2397 round-7 permanence positively instead of heuristically.
+  // dropped, restoring round-7 permanence positively instead of heuristically.
   private pendingTerminalPrompt = false;
-  // #2459 round 2 (review D) — the terminal user prompt BUFFER. The [user message.updated →
+  // round 2 (review D) — the terminal user prompt BUFFER. The [user message.updated →
   // user part → busy] wire ordering means the prompt can arrive BEFORE the busy that mints
   // the terminal turn id; buffering keeps the prompt from publishing a raw session id as its
   // turnId and from splitting off from its trace/final. SINGLE SLOT (the bound): a newer
@@ -748,13 +748,13 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // send() takeover, and the clear/re-roll swap — the fallback id is ALWAYS the session
   // pseudo-turn or the minted id, never a stale headless sendTurnId.
   private bufferedTerminalPrompt: { body: string; occurredAt: number } | undefined;
-  // #2459 round 1 (review D) — permanent marker that at least one headless turn ran on this
+  // round 1 (review D) — permanent marker that at least one headless turn ran on this
   // process. Once true, the busy door admits a terminal-origin turn ONLY through the armed
   // `pendingTerminalPrompt` (fresh first-seen user message), with NO time bound: a headless
   // busy echo of any age stays suppressed. Fresh adapters (no headless turn yet) admit freely,
   // preserving pure-terminal sessions whose busy arrives before any user-message echo.
   private headlessTurnSeen = false;
-  // #2459 round 1 (review D) — user-message ids already observed on this process (bounded like
+  // round 1 (review D) — user-message ids already observed on this process (bounded like
   // the other event-state maps). A REPEAT user message.updated is a buffered duplicate of a
   // turn that already ran (send()'s own POST echo delivered late) and must never re-arm the
   // terminal gate; only a FIRST-SEEN user message is evidence of a freshly typed TUI prompt.
@@ -762,11 +762,11 @@ export class OpenCodeAdapter implements ProviderAdapter {
 
   private readonly sleepImpl: (ms: number) => Promise<void>;
 
-  // #2484 — the token-usage spine transport, wired by runner-core (Claude's #2482/#2491 seam).
+  // the token-usage spine transport, wired by runner-core.
   private readonly apiBudgets = new WeakMap<ManagedProcess, OpenCodeApiBudget>();
 
   private tokenUsageReporter?: ProviderTokenUsageReporter;
-  // #2484 round 1 review (F2/F3) — collapses the message.updated door's streaming echoes to one
+  // round 1 review (F2/F3) — collapses the message.updated door's streaming echoes to one
   // spine post per message; flushed early at real turn boundaries (see flushAll() call sites).
   private readonly tokenUsagePoster = new OpenCodeTokenUsagePoster(() => this.tokenUsageReporter);
 
@@ -796,11 +796,11 @@ export class OpenCodeAdapter implements ProviderAdapter {
     this.tokenUsageReporter = reporter;
   }
 
-  // #2484 round 2 review (MED-1) — the runner's ONE awaited, time-boxed teardown seam
+  // round 2 review (MED-1) — the runner's ONE awaited, time-boxed teardown seam
   // (RunnerCore.settleTerminalTokenUsage, wired at stop() / restartUnexpectedProviderExit /
   // runPreSessionDestroy) previously no-op'd for OpenCode because it bails on a falsy
   // transcriptPath — a Claude-shaped precondition OpenCode never has (it has no transcript file
-  // to tail; #2484's capture is event-sourced from the message.updated SSE door). Owning that
+  // to tail; the capture is event-sourced from the message.updated SSE door). Owning that
   // bail here — ignore transcriptPath, just settle the poster — means the crash-exit and
   // pre-session-destroy paths (which never call adapter.shutdown()) now reach the same debounced
   // report shutdown() already flushes, instead of losing the session's final token counts.
@@ -818,7 +818,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     openCodeApiKey(config, launch.qualified);
     const args = this.buildSpawnArgs(config, config.providerConfig as ProviderConfig, launch);
     const apiBudget = launch.backendID === "openai" ? new OpenCodeApiBudget(config) : undefined;
-    await apiBudget?.start(relayEnv(config.env, "AGENT_RELAY_PROVIDER_SESSION_ID") ?? crypto.randomUUID());
+    await apiBudget?.start(relayEnv(config.env, "HUMWICK_PROVIDER_SESSION_ID") ?? crypto.randomUUID());
     const server = await spawnOpenCodeServer(args, apiBudget);
     const password = args.env.OPENCODE_SERVER_PASSWORD!;
     const client = new OpenCodeClient(args.env.OPENCODE_SERVER_URL!, password, fetch, this.provider);
@@ -827,23 +827,23 @@ export class OpenCodeAdapter implements ProviderAdapter {
       const sessionTitle = config.label ?? config.agentId;
       const sessionId = await client.createSession(sessionTitle);
       const events = new AbortController();
-      // sessionTitle is also read by a #2397 session re-roll (a fresh session created mid-flight
+      // sessionTitle is also read by a session re-roll (a fresh session created mid-flight
       // after repeated retryable errors); sessionId is MUTATED IN PLACE there, so every other
       // reader of process.meta.sessionId (send/interrupt/shutdown) picks the new session up too.
-      // #2459 — the launch metadata terminalAttachSpec() needs is retained here as well:
+      // the launch metadata terminalAttachSpec needs is retained here as well:
       // resolved executable, loopback server URL, agent cwd and the server password. These live
       // ONLY in this runner-local memory (and the password ONLY re-emerges as the guest process
       // env inside the attach spec); they are never persisted, logged, or returned anywhere else.
-      // #2599 — the payload record (when present) pins meta.model to the server-computed
+      // the payload record (when present) pins meta.model to the server-computed
       // qualified name, so later reportContextUsage calls keep payload precedence instead of
       // re-deriving from a possibly-ambiguous alias. Manifest path unchanged when absent.
-      // #2659 — meta.model is the normalized launch model; turns split it verbatim, never re-resolve.
+      // meta.model is the normalized launch model; turns split it verbatim, never re-resolve.
       const process: ManagedProcess = { pid: server.pid, process: server, meta: { client, sessionId, events, model: launch.qualified, launchModel: launch.qualified, sessionTitle, config, relayContextSent: false, launchContextSent: false, attachCommand: args.command, cwd: args.cwd, serverUrl: args.env.OPENCODE_SERVER_URL!, serverPassword: password, stateDir: args.env.XDG_STATE_HOME } };
       if (apiBudget) this.apiBudgets.set(process, apiBudget);
-      // #2443 — both used to be a bare `void promise.catch(...)`: a synchronous throw from
+      // both used to be a bare `void promise.catch(...)`: a synchronous throw from
       // `this.statusCb`/`handleEvent` inside the fulfillment or catch handler produced a SECOND,
       // truly unhandled rejection nothing consumed (Bun exits(1) on that; nothing respawns the
-      // runner — #1618). `fireAndForget` guarantees the rejection — from either the initial call
+      // runner —). `fireAndForget` guarantees the rejection — from either the initial call
       // or the handler itself — is always logged, never escapes.
       void fireAndForget(`opencode SSE subscribe (session ${sessionId})`, () => client.subscribe(events.signal, (event) => this.handleEvent(event, process)), (message) => logger.error("opencode", message));
       void fireAndForget(`opencode server exit status callback (session ${sessionId})`, async () => {
@@ -861,19 +861,19 @@ export class OpenCodeAdapter implements ProviderAdapter {
     }
   }
 
-  // #2659 — spawn() passes the registry-normalized launch model; direct callers resolve statically.
+  // spawn passes the registry-normalized launch model; direct callers resolve statically.
   buildSpawnArgs(config: RunnerSpawnConfig, providerConfig: ProviderConfig, launch = openCodeLaunchModel(config.model, this.provider, openCodeModelRecord(config.modelRecord, this.provider))): SpawnArgs {
     return buildOpenCodeSpawnArgs(config, providerConfig, this.provider, launch);
   }
 
   /**
-   * #2459 — the web-terminal attach spec for an interactive `opencode attach` guest TUI,
+   * the web-terminal attach spec for an interactive `opencode attach` guest TUI,
    * reusing the codex guest-terminal path downstream (runner /terminal/attach-spec →
    * orchestrator guest tmux → Relay's authenticated terminal proxy → dashboard xterm).
    *
    * Fail-closed BEFORE readiness/session: every input is read from the launch metadata
    * retained at spawn() and a missing piece throws rather than degrading. The command is
-   * exactly the pinned-CLI seam the #2459 feasibility verified against v1.18.21:
+   * exactly the pinned-CLI seam the feasibility verified against v1.18.21:
    * `opencode attach <loopback server URL> --session <active session id> --dir <agent cwd>
    * --pure`. `--dir` MUST equal the server/session cwd — OpenCode sessions are
    * project-directory scoped and attach fails (or silently diverges) when the client and
@@ -916,7 +916,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2459 — the CURRENT attachment generation (derived from the active session id), read by
+   * the CURRENT attachment generation (derived from the active session id), read by
    * the runner control server's GET /terminal/generation so the orchestrator can detect a
    * session rotation without learning the session id or any credential. undefined when the
    * session is not ready (nothing to check).
@@ -927,7 +927,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2431 round 1 (HIGH) — run `operation` as the exclusive holder of the turn queue (see the
+   * round 1 (HIGH) — run `operation` as the exclusive holder of the turn queue (see the
    * `turnQueue` field doc for why this exists). FIFO: an operation enqueued while a turn is
    * mid-flight starts only after that turn's promise settles, success or failure.
    */
@@ -938,23 +938,23 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   async deliverInitialPrompt(process: ManagedProcess, prompt: string, options?: PromptOfferOptions): Promise<void | "held"> {
-    // #2397 round 3 review (LOW-5r) — `send()`'s boolean is intentionally NOT surfaced as a throw
+    // round 3 review (LOW-5r) — `send`'s boolean is intentionally NOT surfaced as a throw
     // here: this method's `Promise<void>` contract is shared by every adapter, and a throw would
     // route into attemptInitialPromptDelivery's (runner-core.ts) generic retry-and-eventually-
     // give-up path, re-sending the SAME prompt on top of the retry+reroll budget `send()` already
     // exhausted. Instead, runner-core reads `this.terminalFailure` (set by failTurn's own `error`
     // status, cleared by the `busy` edge this very call started with) right after this resolves, so
     // it can log the terminal outcome correctly without inventing a second retry loop.
-    // #2619 — a refusal under a provider hold is surfaced ("held"): the runner parks the prompt.
+    // a refusal under a provider hold is surfaced ("held"): the runner parks the prompt.
     if (await this.enqueueTurn(() => this.send(process, prompt, options?.inputObserver)) === "held") return "held";
   }
 
   async deliver(process: ManagedProcess, messages: Message[], ctx?: ProviderDeliverContext): Promise<DeliverResult> {
-    // #2539 Phase B — the paste-instant soft-steer routing (Phase A's single-call-path pattern,
+    // Phase B — the paste-instant soft-steer routing (Phase A's single-call-path pattern,
     // codex.ts:435): a mid-turn offer with steerable content goes through the adapter's
     // deliverMidTurn (noReply persist, settlement deferred through ctx); boundary-only classes
     // and the lane-off/idle cases keep the turn-end path below. Policy resolves per offer from
-    // the spawn config; this adapter's default is "steer" (#2544 flip), "defer" the kill switch.
+    // the spawn config; this adapter's default is "steer", "defer" the kill switch.
     if (messages.length > 0 && this.softSteerPolicyFor(process) === "steer" && ctx?.isRecipientMidTurn?.() === true) {
       // r3 HIGH — steer ONLY the steerable partition, never the whole batch: the omitted ids
       // (claimables and synthetic memory/resume injections) stay in this
@@ -967,21 +967,21 @@ export class OpenCodeAdapter implements ProviderAdapter {
       const { steerable } = partitionMidTurnDelivery(messages);
       if (steerable.length > 0) return this.deliverMidTurn(process, steerable, ctx);
     }
-    // #2397 round 3 (MED-3) — only a message `send()` actually got through (no terminal failure)
+    // round 3 (MED-3) — only a message `send` actually got through (no terminal failure)
     // is acknowledged. runner-core marks every acknowledged id read and re-queues everything else
     // (runner-core.ts ~969-995); returning ALL ids unconditionally — the old behavior — marked a
     // message that provoked 8 failed POSTs and a terminal failure as delivered+read though the
-    // model never processed it: recorded delivered, silently lost. #2397 round 3 (MED-6) — once a
+    // model never processed it: recorded delivered, silently lost. Round 3 (MED-6) — once a
     // message fails terminally the session is now `error`/offline, so stop rather than burn the
     // same ~16-minute worst-case retry budget on every remaining queued message in this batch.
-    // #2397 round 3 review (MED-3r) — `terminalFailureIds` tells runner-core WHY this id was not
+    // round 3 review (MED-3r) — `terminalFailureIds` tells runner-core WHY this id was not
     // acknowledged, so its re-drain paces with bounded exponential backoff instead of hammering an
     // upstream that is already rate-limiting on the very next tick.
     const acknowledgedIds: number[] = [];
     const terminalFailureIds: number[] = [];
     const providerHeldIds: number[] = [];
     for (const message of messages) {
-      let disarmOpener: (() => void) | undefined; // #2840 — each send is its own turn, opened by this message
+      let disarmOpener: (() => void) | undefined; // each send is its own turn, opened by this message
       try {
         const outcome = await this.enqueueTurn(() => { disarmOpener = ctx?.openTurnFor?.([message]); return this.send(process, providerMessageText([message]), ctx?.inputObserver); });
         if (outcome !== "ok") disarmOpener?.();
@@ -989,7 +989,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
           terminalFailureIds.push(message.id);
           break;
         }
-        // #2619 — refused under a provider hold: neither delivered nor failed. Stop the batch and
+        // refused under a provider hold: neither delivered nor failed. Stop the batch and
         // hand the refused id AND the untried tail to the runner to park — they would only hit
         // the same wall; the runner redelivers them once a provider turn goes through again.
         if (outcome === "held") {
@@ -997,7 +997,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
           break;
         }
       } catch (error) {
-        // #2534 review (LOW-3) — symmetric with runner-core's attemptInitialPromptDelivery: a
+        // review (LOW-3) — symmetric with runner-core's attemptInitialPromptDelivery: a
         // PromptAcceptedError means the provider ACCEPTED this queued message's POST and the
         // completion await failed/aborted on a still-running turn. Propagating it reached
         // runner-core's drain, which requeued the whole batch and double-POSTed into that live
@@ -1012,7 +1012,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2539 Phase B — the soft-steer op (see the adapter-interface doc): persist the batch into
+   * Phase B — the soft-steer op (see the adapter-interface doc): persist the batch into
    * the in-flight turn WITHOUT touching any send() turn state. Non-negotiable invariants:
    * - send()/its instance fields stay non-reentrant: this path must not read or write
    *   sendTurnId/turnInFlight/suppressProviderIdle/turnClosed/retry/reroll and must never emit a
@@ -1030,7 +1030,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
    * - At-least-once with explicit ambiguity: one POST, then (only on ambiguity) ONE bounded
    *   exact-id reconcile; a positive persistence is NEVER re-POSTed.
    *
-   * #2539 Phase A reconciliation — the result speaks the shared DeliverResult vocabulary:
+   * Phase A reconciliation — the result speaks the shared DeliverResult vocabulary:
    * persisted/ambiguous ids return as `awaitingConsumptionIds` (their settlement completes later
    * through ctx.settleMidTurnConsumed / ctx.reofferMidTurnIds — persistence is not delivery);
    * everything NOT accepted (lane off, boundary-only, cap overflow, pre-POST fencing loss) is
@@ -1115,7 +1115,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     // Force-tracked even at the ledger cap: the cap gates new POSITIVE persists (backpressure to
     // the normal queue), never the RESOLVABILITY of an already-attempted POST — an untracked
     // unknown batch could never be resolved by any ledger exit while this contract reports it as
-    // held (silent orphan under exactly the long-turn + one-timeout scenario #2539 exists for).
+    // held (silent orphan under exactly the long-turn + one-timeout scenario exists for).
     this.softSteer.noteBatch(messageID, includedIds, sessionId, { force: true, inputObserver: ctx?.inputObserver });
     // Same swap-inside-the-POST-window fence as the persisted path: a batch noted onto a dead
     // session can never be resolved there (the same-session consumption door and the
@@ -1131,7 +1131,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   // The spawn config the adapter was launched with (meta.config is the RunnerSpawnConfig handed
   // to spawn()); the steer policy reads its providerConfig — never a provider-name branch.
   // Same shape as codex's spawnProviderConfig (kept per-adapter, matching the landed precedent).
-  // #2544: the absent-config default is "steer" (default-on); an explicit "defer" is the
+  // the absent-config default is "steer" (default-on); an explicit "defer" is the
   // per-agent kill switch, resolved through the shared seam like codex's "steer" default.
   private softSteerPolicyFor(process: ManagedProcess): "steer" | "defer" {
     const config = (process.meta?.config as { providerConfig?: ProviderConfig } | undefined)?.providerConfig;
@@ -1159,7 +1159,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2539 Phase B — the bounded idle-wake fallback: the provider just went idle with
+   * Phase B — the bounded idle-wake fallback: the provider just went idle with
    * positively-persisted-but-unconsumed soft batches (mid-run reload missed them — the live
    * at-stop strand, or an unknown-outcome batch). Arm EXACTLY ONE content-free wake turn through
    * turnQueue (a NORMAL send() turn: real busy/idle pair, full retry semantics — no second turn
@@ -1198,16 +1198,16 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2431 — self-resume clear-inject support: mint a fresh, history-less session and make it the
-   * active one. This REUSES the proven #2397 re-roll seam (the same `POST /session` via
+   * self-resume clear-inject support: mint a fresh, history-less session and make it the
+   * active one. This REUSES the proven re-roll seam (the same `POST /session` via
    * `createSession`, which explicitly drops conversation history, and the same in-place
    * `process.meta.sessionId` swap so every reader — send/interrupt/shutdown and the SSE doors'
    * foreign-session filter — picks the new id up with no separate bookkeeping); it does not invent
    * a second session-minting mechanism.
    *
-   * Ordering/composition with the turn state machine (#2397/#2425/#2427/#2428) is ENFORCED, not
+   * Ordering/composition with the turn state machine is ENFORCED, not
    * assumed (round 1 HIGH): the whole swap runs inside `enqueueTurn`, so a clear that arrives while
-   * a turn is mid-flight — which DOES happen, since the model calls relay_compact_and_resume from
+   * a turn is mid-flight — which DOES happen, since the model calls humwick_compact_and_resume from
    * within its own synchronous `/message` turn and dispatchCommand gives agent.clearContext no
    * provider-input ticket — waits for that turn to settle and completes it wholly on the session
    * it started with before minting anything. The reactive continuation inject is separately
@@ -1216,9 +1216,9 @@ export class OpenCodeAdapter implements ProviderAdapter {
    * closed turn left `turnClosed` set and `suppressProviderIdle` sticky per round-5 MED-1; those
    * fields are deliberately NOT touched — resetting them could double-close an already-closed turn,
    * and any trailing SSE event belonging to the PRE-clear turn carries the OLD sessionID, which the
-   * #2425 foreign-session filter now drops against the NEW active id. Same reasoning leaves
+   * foreign-session filter now drops against the NEW active id. Same reasoning leaves
    * `messageRoles`/`emittedTextParts`/`emittedToolSteps` alone: ids are server-global on this one
-   * process and pruned to OPENCODE_EVENT_STATE_LIMIT regardless (the #2397 re-roll leaves them
+   * process and pruned to OPENCODE_EVENT_STATE_LIMIT regardless (the re-roll leaves them
    * too). The SSE subscription is per-server, not per-session, so the new session stays fully
    * observable through the existing wiring.
    *
@@ -1237,12 +1237,12 @@ export class OpenCodeAdapter implements ProviderAdapter {
     const client = process.meta?.client as OpenCodeClient | undefined;
     const previousSessionId = stringValue(process.meta?.sessionId);
     if (!client || !previousSessionId) throw new Error("OpenCode session is not ready");
-    // #2459 — the session swap is also an attachment-generation rotation: any open event-driven
+    // the session swap is also an attachment-generation rotation: any open event-driven
     // terminal turn belongs to the OLD session (its matching idle carries the old sessionID and
     // would be dropped by the foreign-session filter, stranding runner-core busy). Close it on
     // the old session's truth before the swap; the orchestrator's generation check kills the
     // stale guest TUI on its next input/stream contact.
-    // #2459 round 2 (review D) — flush a buffered terminal prompt under the OLD session
+    // round 2 (review D) — flush a buffered terminal prompt under the OLD session
     // pseudo-turn before the swap (the operator typed there; the buffer must not leak into
     // the new session), then close any open terminal turn as in send() takeover.
     this.flushBufferedPrompt(previousSessionId || undefined);
@@ -1250,7 +1250,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     this.statusCb({ status: "busy", reason: "provider-turn", timeline: { status: "clearing-context", timestamp: Date.now() } });
     let newSessionId: string;
     try {
-      newSessionId = await client.createSession(stringValue(process.meta?.sessionTitle) ?? "agent-relay");
+      newSessionId = await client.createSession(stringValue(process.meta?.sessionTitle) ?? "humwick");
     } catch (error) {
       // The old session is still intact and active — restore idle so the failed command doesn't
       // strand a provider-turn busy hold (same recovery shape as Codex's clearContext).
@@ -1260,7 +1260,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     const clearedAt = Date.now();
     if (process.meta) {
       process.meta.sessionId = newSessionId;
-      // #2539 Phase B — soft-steer fencing: batches accepted-but-unconsumed on the replaced
+      // Phase B — soft-steer fencing: batches accepted-but-unconsumed on the replaced
       // session can never be consumed on the fresh one; their relay ids go BACK to the runner's
       // normal queue (the settlement callback fires inside sessionReplaced — never reposted into
       // the cleared session).
@@ -1278,12 +1278,12 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2440 — native self-resume compaction via OpenCode's own `POST /session/{id}/compact`
-   * (mistakenly believed unavailable when #2431 shipped clear-inject only). Reuses the SAME
+   * native self-resume compaction via OpenCode's own `POST /session/{id}/compact`
+   * (mistakenly believed unavailable when shipped clear-inject only). Reuses the SAME
    * turnQueue FIFO serializer clearContext() established: `agent.compact` is dispatched
    * fire-and-forget with no provider-input ticket (like `agent.clearContext`), and OpenCode's
    * `/message` POST is synchronous, so a compact triggered from inside the model's own turn
-   * (relay_compact_and_resume) genuinely races an in-flight send() without it. See the
+   * (humwick_compact_and_resume) genuinely races an in-flight send() without it. See the
    * `turnQueue` field doc for the full race shape this closes off.
    */
   async compact(process: ManagedProcess, opts?: { instructions?: string }): Promise<Record<string, unknown>> {
@@ -1299,7 +1299,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
    * (no `couplesClearInjectContinuation`, same as its clear-inject path today), so the relay's own
    * reactive continuation inject (`enqueueContinuationInjectionAfterSelfResume`, src/self-resume.ts)
    * delivers the SAME continuation as a follow-up `agent.injectContext` once this command succeeds
-   * — the identical path clear-inject already relies on for OpenCode (see the #2431 test "the first
+   * — the identical path clear-inject already relies on for OpenCode (see the test "the first
    * post-clear delivery lands in the NEW session ... through the same deliver()/send() path").
    */
   private async performCompact(process: ManagedProcess, _opts?: { instructions?: string }): Promise<Record<string, unknown>> {
@@ -1318,7 +1318,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     const compactedAt = Date.now();
     const currentContext = process.meta?.context as ContextState | undefined;
     if (process.meta) {
-      // #2440 round 2 — stamp unconditionally, mirroring swapSessionForClear's shape: a compact
+      // round 2 — stamp unconditionally, mirroring swapSessionForClear's shape: a compact
       // that lands before any context state was ever reported (e.g. immediately after spawn) must
       // still record the compaction rather than silently no-oping, exactly like clearContext's
       // always-fresh stamp below. Falls back to clearContext's own baseline defaults (utilization
@@ -1338,13 +1338,13 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   async shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<ShutdownOutcome> {
-    // #2539 Phase B — anything accepted-but-unconsumed goes back to the runner's normal queue via
+    // Phase B — anything accepted-but-unconsumed goes back to the runner's normal queue via
     // the settlement callback (inside reofferAll) before teardown; the ledger itself never drops
     // an id silently — a failed callback re-inserts the entries for the next exit.
     const softSteerLeftovers = await this.softSteer.reofferAll();
     if (softSteerLeftovers.length > 0) logger.info("opencode", `soft-steer: shutdown reoffering ${softSteerLeftovers.length} relay id(s)`);
     this.softSteerProcess = undefined;
-    // #2484 round 1 review (F2/F3) — session end: force any still-pending debounced token-usage
+    // round 1 review (F2/F3) — session end: force any still-pending debounced token-usage
     // report out now, rather than losing it to a timer that never gets to fire. Round 2 (MED-1)
     // — awaited, not fire-and-forget: this covers the controlled-teardown paths that call
     // adapter.shutdown() directly (restartProvider, shutdownProvider) without going through
@@ -1360,7 +1360,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   /**
    * Exported behavior through the adapter so fixture contracts can pin the v1.18.21 event shapes.
    *
-   * Reproduced live against a real server (#2347): the wire shapes here were captured directly
+   * Reproduced live against a real server: the wire shapes here were captured directly
    * off `/event`, not inferred from docs. Two things the previous implementation got wrong:
    *
    * 1. `session.status` carries a nested `{ status: { type: "busy" | "idle" } }`, not a bare
@@ -1376,12 +1376,12 @@ export class OpenCodeAdapter implements ProviderAdapter {
   handleEvent(event: OpenCodeServerEvent, process?: ManagedProcess): void {
     const properties = event.properties ?? {};
     if (event.type === "session.status") {
-      // #2425 — a foreign-session event must never affect this adapter's turn/idle state, full
+      // a foreign-session event must never affect this adapter's turn/idle state, full
       // stop, regardless of suppression state. This is what makes it safe for the two doors below
       // to stop enforcing PERMANENT suppression once `turnAbandoned`: an unfiltered foreign child
       // session's busy/idle was exactly the hazard round 7 made suppression permanent to guard
       // against, and this filter closes it directly instead.
-      // #2459 round 1 (review C) — FAIL CLOSED: whenever the active session id is known (a live
+      // round 1 (review C) — FAIL CLOSED: whenever the active session id is known (a live
       // spawn always carries one), an event WITHOUT a sessionID is rejected too — a session-
       // less status cannot be positively attributed to the active conversation, and acting on
       // it could open/close a turn for a dead session. Test-only call sites that pass no
@@ -1397,26 +1397,26 @@ export class OpenCodeAdapter implements ProviderAdapter {
       }
       if (status === "busy") {
         // send() owns the turn boundary while a headless delivery is in flight — its own
-        // explicit busy (with its minted id) is authoritative, exactly as before #2459. Only
+        // explicit busy (with its minted id) is authoritative, exactly as before. Only
         // busy events OUTSIDE send() can open a terminal-origin turn below.
         if (this.turnInFlight) return;
         // A terminal turn is already open — its matching idle owns the close; a duplicate
         // busy must not re-mint.
         if (this.eventTurnId) return;
-        // #2425 — re-arm the close guard: this real busy is evidence the turn (from
+        // re-arm the close guard: this real busy is evidence the turn (from
         // `send()`'s perspective, already force-closed to idle by the abandonment path) is
         // actually still running, so the eventual matching idle must be allowed to close it
         // again.
         if (this.turnAbandoned) this.turnClosed = false;
-        // #2459 round 1 (review D) — #2397 round-7 echo guard, restored to PERMANENT and made
+        // round 1 (review D) — round-7 echo guard, restored to PERMANENT and made
         // POSITIVE (no time heuristic): once any headless turn has run on this process, a busy
         // is admitted ONLY when a fresh terminal user prompt armed `pendingTerminalPrompt` (the
         // TUI's POST creates the user message before the turn's busy flows). The buffered
         // own-turn echo has no fresh user message by construction — at ANY delay — so it stays
-        // swallowed. (#2425 abandonment keeps this door open — those server events are the only
+        // swallowed. (abandonment keeps this door open — those server events are the only
         // remaining proof of the turn's real state.)
         if (!this.turnAbandoned && this.headlessTurnSeen && !this.pendingTerminalPrompt) return;
-        // #2459 round 1 (review D) — a genuinely new, terminal-origin turn: mint its provider turn id and hand it
+        // round 1 (review D) — a genuinely new, terminal-origin turn: mint its provider turn id and hand it
         // to runner-core (which keys currentTurnId off this busy), then associate every user/
         // assistant/tool message id of the turn with it (see activeTurnId()) until the matching
         // idle closes it. Un-stick the idle suppression so this turn's own idle can pass.
@@ -1425,7 +1425,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
         this.eventTurnText = [];
         this.eventTurnReasoning = new Map();
         this.suppressProviderIdle = false;
-        // #2459 round 2 (review D) — a prompt buffered by the [user message → user part →
+        // round 2 (review D) — a prompt buffered by the [user message → user part →
         // busy] ordering is emitted NOW under the freshly minted id, so prompt → trace →
         // final-response all share one opencode-turn-* id.
         this.flushBufferedPrompt(this.eventTurnId);
@@ -1434,16 +1434,16 @@ export class OpenCodeAdapter implements ProviderAdapter {
       if (status === "idle") {
         // send() closes its own turn deterministically (closeSuppressedTurn / failTurn / the
         // finally) — an SSE idle while a headless delivery is in flight stays swallowed, as
-        // since #2397 round 2.
+        // since round 2.
         if (this.turnInFlight) return;
-        // #2459 round 2 (review D) — bounded fallback: an active-session idle with a prompt
+        // round 2 (review D) — bounded fallback: an active-session idle with a prompt
         // still buffered means the turn ended without us seeing its busy (or it was itself an
         // echo). Flush under the session pseudo-turn so the operator's input is never stranded
         // in the buffer; RunnerCore's injection dedup guards the chat-echo case.
         if (this.bufferedTerminalPrompt && !this.eventTurnId) {
           this.flushBufferedPrompt(stringValue(process?.meta?.sessionId) || undefined);
         }
-        // #2459 — the matching close of an event-driven (terminal) turn: emit the turn-final
+        // the matching close of an event-driven (terminal) turn: emit the turn-final
         // response accumulated from the turn's live assistant text parts (mirroring send()'s
         // emitTurnFinalResponse → close ordering) and then the idle edge that closes
         // runner-core's turn.
@@ -1451,17 +1451,17 @@ export class OpenCodeAdapter implements ProviderAdapter {
           this.closeEventTurn();
           return;
         }
-        // #2397 round 2 (F4) — a transient idle from a failed attempt, still mid-retry-loop.
-        // #2397 round 7 review (MED-2/LOW-1) — round 6's one-shot reopen (lower the flag on the
+        // round 2 (F4) — a transient idle from a failed attempt, still mid-retry-loop.
+        // round 7 review (MED-2/LOW-1) — round 6's one-shot reopen (lower the flag on the
         // FIRST post-close idle, keyed on `turnInFlight`) let a SECOND idle in the same trailing-
         // echo window pass through and double-close. There is no legitimate turn boundary this SSE
         // door needs to report that `send()`/`closeSuppressedTurn`/`failTurn` don't already emit
         // explicitly for a DETERMINISTIC outcome (see the field comment) — so there is no reopen on
         // that path: suppression stays permanent for any turn `send()` itself closed knowingly.
-        // #2459 — EXCEPT the terminal-origin path above: an idle outside send() with no event
+        // EXCEPT the terminal-origin path above: an idle outside send with no event
         // turn open is still an echo/stray (the busy that minted a turn would have set one), so
         // the permanent suppression holds exactly as before for chat turns.
-        // #2425 — the one exception is the same `turnAbandoned` escape hatch as the busy door
+        // the one exception is the same `turnAbandoned` escape hatch as the busy door
         // above; `turnClosed` (not `suppressProviderIdle`) is what still prevents a double-close
         // here — either the abandonment path's own forced idle already closed it (this real idle
         // is then a no-op confirmation), or a real busy re-armed it above and this is the genuine
@@ -1489,15 +1489,15 @@ export class OpenCodeAdapter implements ProviderAdapter {
         this.messageRoles.set(id, role);
         pruneToLimit(this.messageRoles, OPENCODE_EVENT_STATE_LIMIT);
       }
-      // #2427 — the SSE echo of a finalized assistant message carries the SAME per-message
-      // `tokens` totals the synchronous POST resolves with (send()'s #2355 report), but on a long
+      // the SSE echo of a finalized assistant message carries the SAME per-message
+      // `tokens` totals the synchronous POST resolves with (send's report), but on a long
       // turn that POST can die client-side or stay in-flight forever, so usage reported ONLY from
-      // it never lands (#2427's blank context-window). Report from this door instead: it fires
+      // it never lands. Report from this door instead: it fires
       // DURING the turn regardless of POST survival, mirroring how Codex consumes its
       // `thread/tokenUsage/updated` push. Idempotent with the POST path — last write wins and both
       // doors feed the same openCodeContextState no-signal rules (0/unparsable → no-op), so neither
-      // can regress a good reading — and same-session-filtered like #2425's session.status door.
-      // #2459 round 1 (review C) — FAIL CLOSED: with the active session id known, a usage echo
+      // can regress a good reading — and same-session-filtered like the session.status door.
+      // round 1 (review C) — FAIL CLOSED: with the active session id known, a usage echo
       // WITHOUT a sessionID is rejected too (an unattributable reading must never overwrite the
       // active session's context state). Test-only process-less call sites keep the lenient path.
       const sessionID = stringValue(properties.sessionID);
@@ -1508,9 +1508,9 @@ export class OpenCodeAdapter implements ProviderAdapter {
         const model = stringValue(process.meta?.model);
         this.reportContextUsage(process, model, tokens);
       }
-      // #2484 — same door, reused for the spine report: model/createdAt prefer the message's
+      // same door, reused for the spine report: model/createdAt prefer the message's
       // own info (round 1 review F5/F6) over the session's configured model / receipt time.
-      // #3351 — outside the context guard so a finished message without counts reports unknown.
+      // outside the context guard so a finished message without counts reports unknown.
       if (process && role === "assistant" && id) captureOpenCodeApiUsage(this.apiBudgets.get(process), info, sessionID ?? activeSessionId, stringValue(process.meta?.model), id);
       if (process && role === "assistant" && id && !sessionUnattributable) {
         scheduleOpenCodeTokenUsage(this.tokenUsagePoster, {
@@ -1523,7 +1523,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
           finished: openCodeMessageFinished(info),
         });
       }
-      // #2459 round 1 (review D) — ARM the terminal-turn gate: a FIRST-SEEN user message on the
+      // round 1 (review D) — ARM the terminal-turn gate: a FIRST-SEEN user message on the
       // ACTIVE session observed outside send() is the event-source proof that a human typed into
       // the attached TUI. The next active-session busy is then admitted as terminal-origin even
       // after a headless close (whose own buffered echo carries no fresh user message — its user
@@ -1531,7 +1531,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
       // from arming). Fail-closed session-filtered like the usage read above, never armed while
       // send() is in flight (the chat delivery's own user echo must not open a terminal turn
       // behind send()'s back) nor while a terminal turn is already open.
-      // #2539 Phase B — soft-steer consumption door: an assistant message whose info.parentID
+      // Phase B — soft-steer consumption door: an assistant message whose info.parentID
       // equals a soft batch's user row id is positive proof the active loop CONSUMED that batch
       // (the loop reloads full messages each step and re-parents subsequent assistant steps to
       // the newest user row — live-verified on pinned 1.18.21). FIFO settle: the matched batch
@@ -1550,19 +1550,19 @@ export class OpenCodeAdapter implements ProviderAdapter {
         const firstSeen = !this.seenUserMessageIds.has(id);
         this.seenUserMessageIds.add(id);
         pruneToLimit(this.seenUserMessageIds, OPENCODE_EVENT_STATE_LIMIT);
-        // #2539 Phase B — relay's OWN soft-steer user rows never arm the terminal-origin gate:
+        // Phase B — relay's OWN soft-steer user rows never arm the terminal-origin gate:
         // they are first-seen user messages OUTSIDE send() (the whole point of the lane), and
         // arming here would misclassify the wake turn (or any user's next turn) as terminal.
         const terminalOrigin = firstSeen && !this.turnInFlight && !this.eventTurnId && !sessionUnattributable && !this.softSteer.isTrackedUserId(id);
         if (terminalOrigin) this.pendingTerminalPrompt = true;
-        if (terminalOrigin) adoptOpenCodeTerminalModel(process?.meta, info); // #2659 — keep a model picked in the TUI
+        if (terminalOrigin) adoptOpenCodeTerminalModel(process?.meta, info); // keep a model picked in the TUI
       }
       return;
     }
     if (event.type === "message.part.updated") {
       const part = isRecord(properties.part) ? properties.part : undefined;
       if (!part) return;
-      // #2534 — acceptance door: a persisted user text part whose text equals the armed
+      // acceptance door: a persisted user text part whose text equals the armed
       // context-carrying outbound prompt is positive proof OpenCode ACCEPTED it. Consuming here
       // marks the first-turn markers MID-TURN — seconds after dispatch — so a first turn that
       // later runs past the whole-turn deadline can never leave them false (the await-then-mark
@@ -1570,33 +1570,33 @@ export class OpenCodeAdapter implements ProviderAdapter {
       // text identity are fail-closed inside consumeOpenCodeContextAcceptance: a stale-session
       // echo or an operator-typed prompt never marks.
       consumeOpenCodeContextAcceptance(process, stringValue(properties.sessionID), stringValue(part.text));
-      // #2389 — ANY part on an assistant message is proof the model produced something, including
+      // ANY part on an assistant message is proof the model produced something, including
       // the tool parts this adapter does not mirror (their internal shape is not pinned, so they are
       // reported as bare activity rather than published as a half-understood trace step). Without
       // this a tools-only OpenCode turn emits no session events at all and reads as empty.
-      // #2397 round 3 review (HIGH-1r) — EXCEPT a bare step-start/step-finish bookkeeping part,
+      // round 3 review (HIGH-1r) — EXCEPT a bare step-start/step-finish bookkeeping part,
       // which the server emits on every turn regardless of outcome. `isOutputPart` is the same
       // predicate `completionProducedOutput` uses on the POST-body door (HIGH-1); this is the SSE
       // door, and both must agree or the issue's own incident (a step-start-only turn) still
-      // discharges #2389's escalation through whichever door fires first. `noteOutput()` is called
+      // discharges the escalation through whichever door fires first. `noteOutput` is called
       // with no event here (onTurnActivity takes no args), so MED-5's `diagnostic` filter cannot
       // see this path at all — it must be excluded at the source instead.
       if (isOutputPart(part) && this.messageRoles.get(stringValue(part.messageID) ?? "") === "assistant") this.turnActivityCb();
-      // #2459 round 2 (review D) — no-busy-seen fallback, bounded: when trace activity
+      // round 2 (review D) — no-busy-seen fallback, bounded: when trace activity
       // (tool/narration/reasoning) arrives while a terminal prompt is still buffered and no
       // terminal turn ever opened, flush the prompt FIRST under the same session pseudo-turn
       // the trace will use, keeping prompt→trace grouped instead of stranding the buffer.
       if (this.bufferedTerminalPrompt && !this.eventTurnId && !this.turnInFlight) {
         this.flushBufferedPrompt(stringValue(process?.meta?.sessionId) || undefined);
       }
-      // #2354 — surface tool calls in chat/timeline the way Codex does: decode the ToolPart and
+      // surface tool calls in chat/timeline the way Codex does: decode the ToolPart and
       // emit a running/completed/failed/cancelled session step (upserted in place by stepId). This
       // must run before the text-only early-return below, which used to drop every non-text part.
       if (stringValue(part.type) === "tool") {
         this.emitToolStep(part, process);
         return;
       }
-      // #2605 — surface the model's thinking as a `reasoning` trace row the way Codex/Claude do:
+      // surface the model's thinking as a `reasoning` trace row the way Codex/Claude do:
       // decode the ReasoningPart and emit it (upserted in place by stepId = stable part id). Runs
       // before the text-only early-return below, which is also what used to drop these parts.
       if (stringValue(part.type) === "reasoning") {
@@ -1609,11 +1609,11 @@ export class OpenCodeAdapter implements ProviderAdapter {
       const text = stringValue(part.text);
       const finalized = isRecord(part.time) && part.time.end !== undefined;
       if (!partId || !messageId || !text || !finalized) return;
-      // #2459 — a finalized role:user text part on the ACTIVE server session is a prompt typed
+      // a finalized role:user text part on the ACTIVE server session is a prompt typed
       // into an attached web-terminal TUI: mirror it into chat as a terminal-origin prompt.
       // RunnerCore's recordInjectedPrompt already consumes the echo of every Relay-injected
       // prompt (chat deliveries), so terminal prompts appear once while dashboard-injected
-      // prompts do not duplicate. #2459 round 1 (review C) — FAIL CLOSED: with the active
+      // prompts do not duplicate. Round 1 (review C) — FAIL CLOSED: with the active
       // session id known, a part WITHOUT a sessionID is rejected too — after a clearContext()
       // or retry re-roll an unattributable/old-session prompt belongs (at best) to a dead
       // conversation, and the generation boundary kills that stale TUI anyway.
@@ -1624,7 +1624,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
         if (this.emittedTextParts.has(partId)) return;
         this.emittedTextParts.add(partId);
         pruneToLimit(this.emittedTextParts, OPENCODE_EVENT_STATE_LIMIT);
-        // #2459 round 2 (review D) — turn-id ordering. While send() is in flight, emit
+        // round 2 (review D) — turn-id ordering. While send is in flight, emit
         // immediately under send()'s id (RunnerCore dedups the chat-injection echo). While a
         // terminal turn is open, emit under its minted id. Otherwise — the [user message →
         // user part → busy] wire ordering, where the TUI's POST creates the user message
@@ -1651,7 +1651,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
       if (this.emittedTextParts.has(partId)) return;
       this.emittedTextParts.add(partId);
       pruneToLimit(this.emittedTextParts, OPENCODE_EVENT_STATE_LIMIT);
-      // #2459 — while an event-driven terminal turn is open, its finalized assistant text also
+      // while an event-driven terminal turn is open, its finalized assistant text also
       // accumulates toward the turn-final response emitted by closeEventTurn().
       if (this.eventTurnId) this.eventTurnText.push(text.trim());
       const turnId = this.activeTurnId() ?? stringValue(process?.meta?.sessionId);
@@ -1660,7 +1660,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2605 — decode one ReasoningPart and emit its trace row, with in-place upsert semantics: a
+   * decode one ReasoningPart and emit its trace row, with in-place upsert semantics: a
    * reasoning part GROWS as the model thinks (SSE emits the part repeatedly, each frame carrying
    * the FULL text so far), so a frame for an already-emitted part id re-emits the current full
    * body — the server upserts it into the same row by stepId. Only assistant-message reasoning
@@ -1682,7 +1682,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     if (prev === step.body) return;
     this.emittedReasoningParts.set(step.stepId, step.body);
     pruneToLimit(this.emittedReasoningParts, OPENCODE_EVENT_STATE_LIMIT);
-    // #2605 — record the latest snapshot per part for the event-turn close below. Unconditional
+    // record the latest snapshot per part for the event-turn close below. Unconditional
     // (not just on emit): the close's reconcile must see the newest body even for frames that
     // were live-emitted, so it can compare per-part and emit nothing already traced.
     if (this.eventTurnId) this.eventTurnReasoning.set(step.stepId, step.body);
@@ -1691,14 +1691,14 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2354 — decode one ToolPart and emit its session step, with dedup + terminal-lock: a
+   * decode one ToolPart and emit its session step, with dedup + terminal-lock: a
    * duplicate frame or a reordered update (a late `running` after `completed`) is dropped rather
    * than regressing or double-appending the row. Only assistant-message tool parts are surfaced.
    * `stepId` = the stable part id, so the server upserts running→completed IN PLACE (one row),
    * exactly like Codex's app-server item-id upsert.
    */
   private emitToolStep(part: Record<string, unknown>, process?: ManagedProcess): void {
-    // #2354 review (LOW) — fail CLOSED: a tool part lacking a messageID (so its role can't be
+    // review (LOW) — fail CLOSED: a tool part lacking a messageID (so its role can't be
     // confirmed assistant) is dropped, not surfaced.
     const messageId = stringValue(part.messageID);
     if (!messageId || this.messageRoles.get(messageId) !== "assistant") return;
@@ -1712,18 +1712,18 @@ export class OpenCodeAdapter implements ProviderAdapter {
     if (step.params !== undefined) this.toolStepParams.set(step.stepId, step.params);
     const params = step.params !== undefined ? step.params : this.toolStepParams.get(step.stepId);
     pruneToLimit(this.toolStepParams, OPENCODE_EVENT_STATE_LIMIT);
-    // #2459 — tool steps attach to the live turn id (send()'s while a headless delivery runs,
+    // tool steps attach to the live turn id (send's while a headless delivery runs,
     // the event-driven terminal turn otherwise), never to a stale prior headless turn id.
     this.sessionEventCb(openCodeToolSessionEvent({ ...step, params }, this.activeTurnId() ?? stringValue(process?.meta?.sessionId)));
   }
 
   /**
-   * #2413 — mark the turn-final assistant text as a `response` (not `narration`), so the runner's
+   * mark the turn-final assistant text as a `response` (not `narration`), so the runner's
    * Final Response capture identifies it, auto-forwards an OpenCode child's report to its
    * coordinator, and the chat styles it apart from reasoning — parity with Claude/Codex, which
    * OpenCode lacked entirely (everything read as thinking, nothing auto-forwarded).
    *
-   * #2605 — also emits the turn-final `reasoning` rows from the SAME completed assistant message
+   * also emits the turn-final `reasoning` rows from the SAME completed assistant message
    * (`completion.reasoningSteps`, via `openCodeTurnFinalEvents` in opencode-tool-events.ts), so
    * the model's thinking survives in the trace even when the SSE reasoning frames were never
    * observed (a POST-only reader, a dropped subscription, a turn whose frames raced the close):
@@ -1734,7 +1734,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
    * emitted-body record the SSE door shares, scoped to part ids — never a global body pool.
    *
    * The text is read from the synchronous POST's completed assistant message (`completion.text`,
-   * ground truth per #2389) rather than reconstructed from SSE. `confidence:"definitive"` because
+   * ground truth) rather than reconstructed from SSE. `confidence:"definitive"` because
    * the POST returning IS the provider-native turn-end edge; `final:true` is what makes it a
    * turn-final capture downstream. The same text already streamed live as `narration` (per text
    * part); the dashboard's per-turn narration/response dedup (keyed on the shared `turnId`)
@@ -1747,7 +1747,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     for (const event of openCodeTurnFinalEvents(completion, turnId, emittedBodies)) this.emitReasoningFinal(event);
   }
 
-  /** #2605 — ledger write for a turn-final reasoning row, shared by both turn-close seams. */
+  /** ledger write for a turn-final reasoning row, shared by both turn-close seams. */
   private emitReasoningFinal(event: ProviderSessionEvent): void {
     if (event.stepId) {
       this.emittedReasoningParts.set(event.stepId, event.body);
@@ -1757,9 +1757,9 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2397 — turn-ending PROVIDER errors (e.g. an OpenRouter 429 on a throttled preview model)
+   * turn-ending PROVIDER errors (e.g. an OpenRouter 429 on a throttled preview model)
    * are read off THIS synchronous POST's response body (`completion.error`, via
-   * `openCodeCompletion`), not off a separate SSE listener. #2389 already established that this
+   * `openCodeCompletion`), not off a separate SSE listener. Already established that this
    * response is ground truth and deterministic (no dependency on an SSE frame's timing); reusing
    * that one seam here — instead of also inspecting `message.updated`'s `info.error` — keeps
    * OpenCode's turn-outcome detection in exactly one place, as the standing one-seam rule in this
@@ -1772,13 +1772,13 @@ export class OpenCodeAdapter implements ProviderAdapter {
    */
   /**
    * @returns `"ok"` when the turn ended in output (or a positively-parsed empty completion that
-   * is not itself a failure — #2389's normal empty-turn path), `"failed"` only when `failTurn` was
-   * called — i.e. the message provoked a terminal, unrecoverable failure — and `"held"` (#2619)
+   * is not itself a failure — the normal empty-turn path), `"failed"` only when `failTurn` was
+   * called — i.e. the message provoked a terminal, unrecoverable failure — and `"held"`
    * when the provider refused the turn and it ended in the rate-limit hold: not delivered, not
-   * failed. #2397 round 3 (MED-3): the caller uses this to decide whether the message may be
+   * failed. Round 3 (MED-3): the caller uses this to decide whether the message may be
    * marked delivered/read.
    *
-   * #2397 round 5 review (INFO) — this method is non-reentrant BY CONSTRUCTION, and the
+   * round 5 review (INFO) — this method is non-reentrant BY CONSTRUCTION, and the
    * `suppressProviderIdle`/`turnInFlight`/`turnClosed`/`turnAbandoned` instance fields it owns
    * assume that: every `adapter.deliver`/`deliverInitialPrompt` call site in runner-core runs inside
    * `providerInput.run`, which serializes them, so a second `send()` call never starts before the
@@ -1787,44 +1787,44 @@ export class OpenCodeAdapter implements ProviderAdapter {
    */
   private async send(process: ManagedProcess, text: string, inputObserver?: ProviderInputObserver): Promise<OpenCodeSendOutcome> {
     await this.apiBudgets.get(process)?.prepare();
-    // #2539 Phase B — retain the live process for the soft-steer wake hook (see its doc).
+    // Phase B — retain the live process for the soft-steer wake hook (see its doc).
     this.softSteerProcess = process;
     let attempt = 0;
     let rerolled = false;
     let lastFailureDetail: string | undefined;
     let lastFailureErrorType: string | undefined;
-    // #2397 round 4 review (F1/F2) — round 3 only raised this flag on a failed, retryable attempt,
+    // round 4 review (F1/F2) — round 3 only raised this flag on a failed, retryable attempt,
     // so it stayed false while ATTEMPT 1's own POST was in flight. On a fast (e.g. loopback) server
     // the FAILED-attempt idle SSE frame routinely beats that attempt's own POST response — the
     // issue's own captured incident shape, a 429 on the very first attempt — so an unsuppressed
-    // attempt-1 idle still closed the turn early and, via runner-core's #2389 seam, marked the
+    // attempt-1 idle still closed the turn early and, via runner-core's seam, marked the
     // linked Task done while the retry loop was still running. Raised for the WHOLE call (below,
     // past the readiness guard — round 5 LOW-2) so there is no "attempt 1 is unguarded" window.
     // Every return path must therefore close the turn itself — `closeSuppressedTurn` does that,
     // idempotently per call (`turnClosed`) — see the `finally`.
-    // #2459 — close a still-open event-driven terminal turn BEFORE the reset below: a chat
+    // close a still-open event-driven terminal turn BEFORE the reset below: a chat
     // delivery taking over the boundary must end the terminal turn first (its own SSE idle, if
     // it even arrived, would be swallowed under this call's suppression), and closeEventTurn
     // sets `turnClosed` — resetting it after the close keeps THIS call's deterministic close
     // live. Order: terminal idle clears the terminal turn id, then this call's busy mints its own.
     if (this.eventTurnId) this.closeEventTurn();
-    // #2459 round 1 (review D) — a chat delivery also consumes any armed terminal prompt: a
+    // round 1 (review D) — a chat delivery also consumes any armed terminal prompt: a
     // stale arm surviving this call would wrongly admit this call's own buffered busy echo
     // after the close. (This call's POST user echo is recorded in seenUserMessageIds live, so
     // its late duplicate can never re-arm — see the message.updated door.)
     this.pendingTerminalPrompt = false;
-    // #2459 round 2 (review D) — a buffered terminal prompt flushed under the session
+    // round 2 (review D) — a buffered terminal prompt flushed under the session
     // pseudo-turn BEFORE the delivery takes over: the operator typed first, and the buffer
     // must never leak across the headless turn boundary. Fallback id is the session
     // pseudo-turn — never this call's (or any prior headless) sendTurnId.
     this.flushBufferedPrompt(stringValue(process.meta?.sessionId) || undefined);
     this.turnClosed = false;
-    // #2425 — reset at the top of every call: a stray leftover event from a truly-abandoned
+    // reset at the top of every call: a stray leftover event from a truly-abandoned
     // PREVIOUS turn must not be allowed to affect THIS new call's turn boundary (see the field
     // comment).
     this.turnAbandoned = false;
     this.serverRetryWall = undefined;
-    // #2413 review (HIGH-1) — one fresh turn id per send() (stable across this call's retries/
+    // review (HIGH-1) — one fresh turn id per send (stable across this call's retries/
     // rerolls, which are ONE logical turn), so every send is distinct and the busy edge below hands
     // runner-core this exact id as its currentTurnId.
     this.sendTurnId = `opencode-turn-${crypto.randomUUID()}`;
@@ -1834,27 +1834,27 @@ export class OpenCodeAdapter implements ProviderAdapter {
         const sessionId = stringValue(process.meta?.sessionId);
         const model = stringValue(process.meta?.model);
         if (!client || !sessionId || !model) throw new Error("OpenCode session is not ready with a hub-resolved model");
-        // #2397 round 5 review (LOW-2) — raised only once we're actually about to run an attempt
+        // round 5 review (LOW-2) — raised only once we're actually about to run an attempt
         // (past the guard above), so a "session not ready" throw never emits a close for a turn
         // that never started (never emitted its own busy edge below).
         this.turnInFlight = true;
         this.suppressProviderIdle = true;
-        // #2459 round 1 (review D) — a headless turn now exists on this process: from here on,
+        // round 1 (review D) — a headless turn now exists on this process: from here on,
         // terminal-origin busies are admitted only through the armed fresh-prompt gate.
         this.headlessTurnSeen = true;
         const providerState = attempt > 0 || rerolled
           ? openCodeUpstreamRetryState({ attempt, rerolled, message: lastFailureDetail ?? "retrying", errorType: lastFailureErrorType })
           : undefined;
         this.statusCb({ status: "busy", reason: "provider-turn", ...(this.sendTurnId ? { id: this.sendTurnId } : {}), ...(providerState ? { providerState } : {}) });
-        // #2389 — this endpoint is synchronous: it returns the COMPLETED assistant message. That
+        // this endpoint is synchronous: it returns the COMPLETED assistant message. That
         // body is ground truth about whether the model produced anything, so it feeds the same
         // evidence funnel the cross-provider ledger reads, rather than being discarded as it was
         // during the incident. Only a positively-parsed non-empty completion counts; an
         // unrecognised body says nothing.
-        // #2418/#2532 — compose once outside this retry loop, but the durable first-turn markers
+        // compose once outside this retry loop, but the durable first-turn markers
         // are consumed by PROOF OF ACCEPTANCE, not by this await's return: `sendOpenCodeRelayTurn`
         // arms the SSE acceptance door before dispatch and reconciles against persisted session
-        // messages if the await itself fails, so an accepted-but-interrupted turn (e.g. the #2425
+        // messages if the await itself fails, so an accepted-but-interrupted turn (e.g. the
         // whole-turn abort) still retains the consumed flags instead of re-prepending the briefing
         // on every queued message. A readiness guard or rejected transport request has not reached
         // the provider, so RunnerCore's retry must still include the briefing. Retryable resolved
@@ -1869,7 +1869,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
           throw error;
         }
         if (this.holdOnServerRetryWall()) return "held";
-        // #2355 — every completion (success, a produced-output error, or a still-retrying error)
+        // every completion (success, a produced-output error, or a still-retrying error)
         // carries this turn's fresh token usage; report it to Relay's normal context telemetry path
         // the same way Codex's `codexTokenUsageContext` does, rather than only on the happy path.
         this.reportContextUsage(process, model, completion.tokens);
@@ -1879,14 +1879,14 @@ export class OpenCodeAdapter implements ProviderAdapter {
         if (completion.error && completion.error.name !== "MessageAbortedError") {
           const error = completion.error;
           const detail = `${error.name}${error.statusCode !== undefined ? ` ${error.statusCode}` : ""}: ${error.message}`;
-          // #2397 round 2 (F1/F2) — `completion.error` used to be checked independently of any
+          // round 2 (F1/F2) — `completion.error` used to be checked independently of any
           // output the turn already produced. A turn that ran tool steps (a commit, say) and THEN
           // hit a retryable error was resent into a brand-new session with no memory of that work
           // — re-executing it. And a non-retryable error on a turn that DID produce a reply (e.g.
           // MessageOutputLengthError after a long, otherwise-successful answer) took a healthy
           // agent offline. Retrying or failing must only ever happen when the turn produced
           // NOTHING; with output present, report the error and let the turn end normally.
-          // #2397 round 3 (HIGH-1) — `completionProducedOutput` excludes bare step-start/finish
+          // round 3 (HIGH-1) — `completionProducedOutput` excludes bare step-start/finish
           // bookkeeping parts. The issue's own captured incident (one bare step-start part, zero
           // tokens, a 429) used to satisfy the old parts>0 check and take THIS branch — no retry,
           // no error status, reported as a clean success. It must fall through to the retry path.
@@ -1897,10 +1897,10 @@ export class OpenCodeAdapter implements ProviderAdapter {
             this.emitTurnFinalResponse(process, completion);
             this.closeSuppressedTurn();
             this.turnActivityCb();
-            this.rerolledThisHoldEpisode = false; // #2619 — the provider took a turn: the hold episode is over
+            this.rerolledThisHoldEpisode = false; // the provider took a turn: the hold episode is over
             return "ok";
           }
-          // #2619 — an explicit account usage/quota wall: in-session retries and a re-roll cannot
+          // an explicit account usage/quota wall: in-session retries and a re-roll cannot
           // clear it (the re-roll would only drop the conversation). Hold now on the same session;
           // the relay resumes us. Checked BEFORE the non-retryable exit: a provider may send a
           // quota wall as a non-retryable 403 ("Quota exceeded; limit will reset tomorrow").
@@ -1908,7 +1908,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
             this.holdTurnOnProviderLimit(error, detail);
             return "held";
           }
-          // #2619 — throttle wording is retryable whatever the provider flagged (zai sends a
+          // throttle wording is retryable whatever the provider flagged (zai sends a
           // non-retryable 403 "Rate limit exceeded"): retry, then hold like any throttle. A real
           // auth/model refusal still fails here.
           if (!error.isRetryable && !isProviderThrottle(error)) {
@@ -1920,10 +1920,10 @@ export class OpenCodeAdapter implements ProviderAdapter {
             const delayMs = openCodeErrorRetryDelayMs(attempt);
             lastFailureDetail = detail;
             lastFailureErrorType = error.errorType;
-            // #2397 round 3 (MED-5) — `diagnostic: true`: this narrates the ADAPTER's own retry
+            // round 3 (MED-5) — `diagnostic: true`: this narrates the ADAPTER's own retry
             // mechanics, not anything the model produced. Left uncredited it would let
             // emptyTurns.noteOutput() (runner-core's onSessionEvent wiring) read a retry storm
-            // that ultimately fails as forward progress, cancelling #2389's input-armed escalation
+            // that ultimately fails as forward progress, cancelling the input-armed escalation
             // that is the only thing left to wake the spawn parent once failTurn takes the agent
             // offline below.
             this.sessionEventCb({ type: "narration", origin: "provider", diagnostic: true, body: `OpenCode turn failed (${detail}); retrying in ${Math.round(delayMs / 1000)}s (attempt ${attempt}/${OPENCODE_ERROR_RETRY_MAX_ATTEMPTS})…` });
@@ -1932,27 +1932,27 @@ export class OpenCodeAdapter implements ProviderAdapter {
             await this.sleepImpl(delayMs);
             continue;
           }
-          // #2619 — a provider overload (5xx) is provider-wide, not a broken session: a re-roll
+          // a provider overload (5xx) is provider-wide, not a broken session: a re-roll
           // would only drop the history before the same wall. Hold on the SAME session.
           if (isProviderOverload(error)) {
             this.holdTurnOnProviderLimit(error, `${detail} (after ${OPENCODE_ERROR_RETRY_MAX_ATTEMPTS} in-session retries)`);
             return "held";
           }
-          // Retry exhausted for the CURRENT session. Bimodal-per-session evidence (#2397 issue
+          // Retry exhausted for the CURRENT session. Bimodal-per-session evidence (issue
           // comment) says an ambiguous 429 can be a per-session failure — re-roll to a fresh one
-          // once. #2619 — at most ONCE PER HOLD EPISODE (until a turn goes through again), so a
+          // once. At most ONCE PER HOLD EPISODE (until a turn goes through again), so a
           // long wall re-rolls once and then holds: history loss stays bounded to one attempt.
           if (!rerolled && !this.rerolledThisHoldEpisode) {
             this.rerolledThisHoldEpisode = true;
-            // #2397 round 2 (F5) — say plainly that this drops the conversation: re-rolling
+            // round 2 (F5) — say plainly that this drops the conversation: re-rolling
             // mutates process.meta.sessionId to a brand-new, history-less session, which for a
             // long-lived agent throws away everything said so far.
             this.sessionEventCb({ type: "narration", origin: "provider", diagnostic: true, body: `OpenCode turn failed ${OPENCODE_ERROR_RETRY_MAX_ATTEMPTS} times in a row in this session (${detail}); re-rolling to a new OpenCode session (this drops the current conversation history) and retrying…` });
             let newSessionId: string;
             try {
-              newSessionId = await client.createSession(stringValue(process.meta?.sessionTitle) ?? "agent-relay");
+              newSessionId = await client.createSession(stringValue(process.meta?.sessionTitle) ?? "humwick");
             } catch (createError) {
-              // #2619 — the original session is still intact; a failed re-roll during a
+              // the original session is still intact; a failed re-roll during a
               // provider outage is no reason to end the agent. Hold like the exhausted path.
               this.holdTurnOnProviderLimit(error, `${detail} (session re-roll failed: ${errMessage(createError)})`);
               return "held";
@@ -1961,7 +1961,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
             // process.meta.sessionId, so mutating it in place re-routes the whole adapter to the
             // new session — no separate "which session is active" bookkeeping needed.
             if (process.meta) process.meta.sessionId = newSessionId;
-            // #2539 Phase B — soft-steer fencing on re-roll: same contract as the clear swap —
+            // Phase B — soft-steer fencing on re-roll: same contract as the clear swap —
             // accepted-but-unconsumed batches on the dead session reoffer to the normal queue
             // (the settlement callback fires inside sessionReplaced).
             const softSteerOrphans = await this.softSteer.sessionReplaced(newSessionId);
@@ -1975,7 +1975,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
             // suppressProviderIdle is already raised for the whole call — see entry.
             continue;
           }
-          // #2619 — retries and the re-roll are exhausted on a RETRYABLE error: the provider is
+          // retries and the re-roll are exhausted on a RETRYABLE error: the provider is
           // down or throttling, not the agent. This used to failTurn → terminal `error` → runner
           // exit, killing every zai session ~10 min into a quota wall. Hold and let the relay's
           // resume sweep back off and wake the agent, as it does for Claude.
@@ -1987,24 +1987,24 @@ export class OpenCodeAdapter implements ProviderAdapter {
           this.emitTurnFinalResponse(process, completion);
           this.closeSuppressedTurn();
           this.turnActivityCb();
-          this.rerolledThisHoldEpisode = false; // #2619 — the provider took a turn: the hold episode is over
+          this.rerolledThisHoldEpisode = false; // the provider took a turn: the hold episode is over
           return "ok";
         }
         // Either a non-empty completion with no positively-parsable output (an unrecognised body —
-        // says nothing either way), or a POSITIVELY parsed empty completion (#2389's normal
+        // says nothing either way), or a POSITIVELY parsed empty completion (the normal
         // empty-turn path, closed deterministically here rather than depending on a possibly late
         // or lost SSE idle frame). Either way this POST returning is itself proof the turn is over
         // — the endpoint is synchronous — so let the shared `finally` below perform the close
-        // instead of duplicating it at two near-identical return sites. #2397 round 4 review (F3):
+        // instead of duplicating it at two near-identical return sites. Round 4 review (F3):
         // that exact duplication was unadjudicated — deleting either explicit call left every
         // opencode test green, since `finally` already produces the identical close with no
         // observable ordering difference from here (nothing else runs between this `return` and
         // the `finally`).
-        this.rerolledThisHoldEpisode = false; // #2619 — the provider took a turn: the hold episode is over
+        this.rerolledThisHoldEpisode = false; // the provider took a turn: the hold episode is over
         return "ok";
       }
     } finally {
-      // #2397 round 4/5 review (F2) — the single deterministic close for this whole call. Some
+      // round 4/5 review (F2) — the single deterministic close for this whole call. Some
       // return paths above call `closeSuppressedTurn()` explicitly first (when something else in
       // that branch — `turnActivityCb`, most notably — must run AFTER the close, so ordering
       // matters); the rest fall straight through to here, since nothing runs between their
@@ -2012,7 +2012,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
       // (see F3 above). `failTurn`'s own unconditional close also marks `turnClosed`, so by the
       // time ANY return path reaches here this is a no-op — EXCEPT when NONE of those ran: a throw
       // from `client.sendMessage` (transport reset, socket drop) or the "session not ready" guard.
-      // #2397 round 6 review (MED-2r) — that guard throw must NOT fall through to
+      // round 6 review (MED-2r) — that guard throw must NOT fall through to
       // `closeSuppressedTurn()`. The old comment here claimed `suppressProviderIdle` "was also
       // never raised this call, so closeSuppressedTurn is a no-op there too" — true only on the
       // FIRST call. `suppressProviderIdle` is STICKY (round 5, MED-1): on any later call, if the
@@ -2029,9 +2029,9 @@ export class OpenCodeAdapter implements ProviderAdapter {
       // Closing here (when `turnStartedThisCall` is true — a genuine mid-attempt throw) trades a
       // turn the server might still be running for a turn that reliably ends; the adapter has no
       // other signal on a throw, and `failTurn` already makes that same trade unconditionally today.
-      // #2425 — `turnClosed` still being false at this point means NEITHER a success branch nor
+      // `turnClosed` still being false at this point means NEITHER a success branch nor
       // `failTurn` ran before we got here — the only way in is an uncaught throw (e.g. `sendMessage`
-      // aborting on the #2425 turn-timeout, or any other transport failure) whose actual server-side
+      // aborting on the turn-timeout, or any other transport failure) whose actual server-side
       // outcome is unknown. Mark the turn abandoned before force-closing it, so a genuine same-
       // session busy/idle that arrives later can still self-heal the status instead of being
       // swallowed forever by the otherwise-permanent `suppressProviderIdle` (see its field doc).
@@ -2043,20 +2043,20 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2355 — the runner's `latestProcessContext()` (runner-core.ts) reads `process.meta.context`
+   * the runner's `latestProcessContext` (runner-core.ts) reads `process.meta.context`
    * directly (the same fallback path Codex's `meta.context` sets from `thread/tokenUsage/updated`),
    * feeding Relay's normal telemetry (dashboard/API/timeline) and the context-pressure warning /
    * self-compaction advisory. A no-op whenever the turn carried no parsable token count or the
    * model's window is unknown — silence here, not a fabricated 0/0 reading.
    */
   private reportContextUsage(process: ManagedProcess, model: string | undefined, tokensUsed: number | undefined): void {
-    // #2599 — precedence payload-record > legacy #2595 window > manifest. The record's qualified
+    // precedence payload-record > legacy window > manifest. The record's qualified
     // name is ALSO threaded through: meta.model is re-pinned to the server-computed qualified name
     // when the record is present, so later reportContextUsage calls (which read meta.model) keep
     // resolving against the payload instead of re-deriving from a possibly-ambiguous alias.
     const config = process.meta?.config as RunnerSpawnConfig | undefined;
     const record = openCodeModelRecord(config?.modelRecord, this.provider);
-    // #2659 — the configured window belongs to the LAUNCH model, not a terminal-switched one.
+    // the configured window belongs to the LAUNCH model, not a terminal-switched one.
     const configWindow = openCodeOnLaunchModel(process.meta, model) ? record?.contextWindowTokens ?? config?.contextWindowTokens : undefined;
     const windowTokens = typeof configWindow === "number" && Number.isFinite(configWindow) && configWindow > 0
       ? configWindow
@@ -2066,7 +2066,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2397 round 2 (F6) — once a retry (or the post-reroll retry) actually produces output, the
+   * round 2 (F6) — once a retry (or the post-reroll retry) actually produces output, the
    * operator-visible "retrying…"/blocked hold must not linger on screen until whatever SSE idle
    * happens to arrive next — which `suppressProviderIdle` above can delay well past this turn.
    * Clear it explicitly and immediately; a no-op when no retry hold was ever shown.
@@ -2081,7 +2081,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2397 round 4/5 review (F1/F2/MED-1) — `suppressProviderIdle` is raised for the WHOLE `send()`
+   * round 4/5 review (F1/F2/MED-1) — `suppressProviderIdle` is raised for the WHOLE `send`
    * call, from just past the readiness guard (see the loop entry), so every path that ends the
    * turn — success, either failure, or the `finally`'s throw fallback — must close it
    * deterministically itself; the synchronous POST returning (or the throw itself) is ground truth
@@ -2095,20 +2095,20 @@ export class OpenCodeAdapter implements ProviderAdapter {
   private closeSuppressedTurn(hold?: ProviderState): void {
     if (this.turnClosed) return;
     this.turnClosed = true;
-    // #2484 round 1 review (F2/F3) — turn close: flush the debounced token-usage report now
+    // round 1 review (F2/F3) — turn close: flush the debounced token-usage report now
     // rather than wait out its timer. Not awaited — a live turn boundary, not teardown; flush()
     // already routes failures to reporter.reportFailure internally, so the `.catch(() => {})`
-    // here only satisfies the unguarded-async ratchet (#1665) — it never actually fires.
+    // here only satisfies the unguarded-async ratchet — it never actually fires.
     void this.tokenUsagePoster.flushAll().catch(() => {});
     this.statusCb({ status: "idle", reason: "provider-turn", clear: ["provider-turn"], ...(hold ? { providerState: hold } : {}) });
-    // #2539 Phase B — idle edge with unconsumed soft batches: arm the one bounded wake. Never
+    // Phase B — idle edge with unconsumed soft batches: arm the one bounded wake. Never
     // into a provider-limit hold: the wake would only hit the same wall; the relay's resume turn
     // ends in a normal idle that arms it then.
     if (!hold) this.maybeArmSoftSteerWake();
   }
 
   /**
-   * #2619 — end the turn in the shared rate-limit hold instead of a terminal failure: the turn
+   * end the turn in the shared rate-limit hold instead of a terminal failure: the turn
    * closes (idle + provider-turn) carrying the `blocked/rate_limit` providerState, which
    * runner-core keeps as its rateLimitHold until the relay's resume turn goes busy. The session
    * (and its history, including the refused user message) stays alive.
@@ -2120,7 +2120,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2775 — OpenCode's own retry of an in-flight send(): a transient one is shown as "retrying"; a wall
+   * OpenCode's own retry of an in-flight send: a transient one is shown as "retrying"; a wall
    * (usage/free-tier limit, far-off `next`, or an endless throttle) aborts the session so the POST
    * returns and send() ends the turn in the shared rate-limit hold instead of waiting silently.
    */
@@ -2146,11 +2146,11 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2459 — close the event-driven (terminal-origin) turn on its matching SSE idle: emit the
+   * close the event-driven (terminal-origin) turn on its matching SSE idle: emit the
    * turn-final response accumulated from the turn's finalized assistant text parts (the same
    * narration→final-response shape send()'s POST path produces, and the same turnId so the
    * dashboard's per-turn narration/response dedup applies), then the idle edge that closes
-   * runner-core's turn. Completes the #2425 abandonment self-heal (the server's own truth for
+   * runner-core's turn. Completes the abandonment self-heal (the server's own truth for
    * the abandoned turn has now arrived). Deliberately does NOT re-raise the sticky idle
    * suppression or stamp the echo window: an event turn's busy+idle arrive LIVE — they DRIVE
    * this state machine; there is no send()-POST await whose buffered chunk could replay them —
@@ -2160,7 +2160,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   private closeEventTurn(): void {
     const turnId = this.eventTurnId;
     const text = this.eventTurnText.join("\n\n").trim();
-    // #2605 — reconcile the turn's reasoning parts against what the live door already emitted,
+    // reconcile the turn's reasoning parts against what the live door already emitted,
     // per part id: a part whose latest snapshot EQUALS its last-emitted body needs no row (it is
     // already traced); a part that GREW after its last live emit — or was never live-emitted
     // (frames racing the close, a part observed only at close time) — gets one row under its OWN
@@ -2180,8 +2180,8 @@ export class OpenCodeAdapter implements ProviderAdapter {
     this.eventTurnReasoning = new Map();
     // Stray idles with no open event turn stay swallowed via the existing `turnClosed` guard.
     this.turnClosed = true;
-    // #2425 self-heal completion: this idle close was the server's own truth for the abandoned
-    // turn. Round 1 (review D) — re-latch the sticky suppression it had bypassed (the #2425
+    // self-heal completion: this idle close was the server's own truth for the abandoned
+    // turn. Round 1 (review D) — re-latch the sticky suppression it had bypassed (the
     // escape hatch exists only while the abandonment is unresolved), so post-heal strays stay
     // swallowed under the same permanent suppression as every other send()-closed turn.
     if (this.turnAbandoned) {
@@ -2192,17 +2192,17 @@ export class OpenCodeAdapter implements ProviderAdapter {
       for (const step of unseen) this.emitReasoningFinal(openCodeReasoningSessionEvent(step, turnId, false));
       for (const event of openCodeTurnFinalEvents({ text }, turnId)) this.sessionEventCb(event);
     }
-    // #2484 round 1 review (F2/F3) — same flush as closeSuppressedTurn's turn close; the
+    // round 1 review (F2/F3) — same flush as closeSuppressedTurn's turn close; the
     // `.catch(() => {})` is the same ratchet-only no-op (flush() already self-catches).
     void this.tokenUsagePoster.flushAll().catch(() => {});
     this.statusCb({ status: "idle", reason: "provider-turn", clear: ["provider-turn"] });
-    // #2539 Phase B — a terminal-origin turn's close is an idle edge too: unconsumed soft
+    // Phase B — a terminal-origin turn's close is an idle edge too: unconsumed soft
     // batches get the same single bounded wake.
     this.maybeArmSoftSteerWake();
   }
 
   /**
-   * #2459 round 2 (review D) — emit a buffered terminal prompt under `turnId` and clear the
+   * round 2 (review D) — emit a buffered terminal prompt under `turnId` and clear the
    * slot. `turnId` is the freshly minted terminal turn id (primary path — busy admission) or
    * the session pseudo-turn (bounded no-busy fallbacks); it is NEVER a stale headless
    * sendTurnId, which only exists while send() is in flight and is never passed here.
@@ -2215,7 +2215,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2459 — the turn id live session events should attach to: send()'s per-call id while a
+   * the turn id live session events should attach to: send's per-call id while a
    * headless delivery is in flight, otherwise the event-driven terminal turn minted on the
    * server's own busy edge. Deliberately NO fallback to a stale `sendTurnId` outside send() —
    * that inheritance is exactly the contamination this replaces; callers fall back to the
@@ -2226,10 +2226,10 @@ export class OpenCodeAdapter implements ProviderAdapter {
   }
 
   private failTurn(detail: string, terminalFailureReason: string): void {
-    // #2397 round 3 (MED-5) — diagnostic:true; see the retry-loop narration above for why.
+    // round 3 (MED-5) — diagnostic:true; see the retry-loop narration above for why.
     this.sessionEventCb({ type: "narration", origin: "provider", diagnostic: true, body: `OpenCode turn failed: ${detail}` });
-    // #2397 round 2 (F3) — an "error" status alone is never treated as a turn boundary by
-    // #2389's seam in runner-core (only `idle && provider-turn` clears `currentTurnId` and notes
+    // round 2 (F3) — an "error" status alone is never treated as a turn boundary by
+    // seam in runner-core (only `idle && provider-turn` clears `currentTurnId` and notes
     // the turn ended); without this, the next `busy` reuses the stale turn id and the empty-turn
     // detector is blinded for the rest of the agent's life. Close the turn through that same seam
     // first — exactly as the parsed-empty-completion path above already does — before marking the
@@ -2237,7 +2237,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
     // raised), so mark `turnClosed` here too — otherwise `send()`'s `finally` fallback would see it
     // still unset and emit a second, out-of-order idle after the error status below.
     this.turnClosed = true;
-    // #2484 round 1 review (F2/F3) — same flush as the other turn-close sites: a failed turn can
+    // round 1 review (F2/F3) — same flush as the other turn-close sites: a failed turn can
     // still carry real (partial) usage worth persisting; the `.catch(() => {})` is the same
     // ratchet-only no-op as the other two sites.
     void this.tokenUsagePoster.flushAll().catch(() => {});
@@ -2246,7 +2246,7 @@ export class OpenCodeAdapter implements ProviderAdapter {
       status: "error",
       reason: "provider-turn",
       clear: ["provider-turn"],
-      // #2443 — mirrors the Claude adapter's own "model-unavailable" stop-failure shape
+      // mirrors the Claude adapter's own "model-unavailable" stop-failure shape
       // (providerState + an embedded timeline event) instead of leaving this error silent beyond
       // the mirror log: a terminal failure used to reach runner-core with no timeline event and no
       // classification, so an exit driven by this status surfaced nothing to the operator beyond