@humwick/runner 0.130.5 → 0.130.6

package/src/runner-core.ts

@@ -37,7 +37,6 @@ import { resolveTestRunRootPid, TEST_RUN_DEDUP_SWEEP_MS, TestRunDedupSweep } fro
 import { cachedGateRunCommandsForCwd } from "./gate-run-config";
 import { AreaMemoryTracker } from "./area-memory";
 import { ClaimTracker } from "./claim-tracker";
-import { ProviderQuotaHarvest } from "./adapters/provider-quota-harvest";
 import { agentShellLaunchEnv } from "./adapters/project-shell";
 import { isNotificationOnlyInput } from "./inbox-carrier";
 import { readRunnerContextProbeState } from "./context-probe-state";
@@ -50,7 +49,7 @@ import { retryParkPost } from "./park-post";
 import { getManifest } from "@humwick/providers";
 import { hostSourcesFor } from "./host-asset-plan";
 import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint, resolveSharedMcpUrl } from "./relay-mcp";
-import { RelayMcpProxy, isolatedWorkspaceDescriptor } from "./relay-mcp-proxy";
+import { HumwickMcpProxy, isolatedWorkspaceDescriptor } from "./relay-mcp-proxy";
 import { runtimeMetadata } from "./version";
 import { logger } from "./logger";
 import { ensureSessionScratch, type SessionScratchLayout } from "./session-scratch";
@@ -107,21 +106,21 @@ type HeldSubmit = { messages: Map<number, Message>; resend?: () => Promise<unkno
 const emptyHeldSubmit = (): HeldSubmit => ({ messages: new Map() });
 type RunnerStatusFrame = { agentStatus: string; ready?: boolean; meta?: Record<string, unknown> };
 
-// #650: how often to reconcile pid-bearing busy work against actual process liveness.
+// how often to reconcile pid-bearing busy work against actual process liveness.
 const BUSY_LIVENESS_RECONCILE_MS = 5_000;
 const HTTP_LIVENESS_LOG_INTERVAL_MS = 5 * 60 * 1000;
 const UNEXPECTED_EXIT_WINDOW_MS = 2 * 60 * 1000;
 // Bound retries after a terminal provider failure.
 const TERMINAL_FAILURE_RETRY_BASE_MS = 2_000;
 const TERMINAL_FAILURE_RETRY_MAX_MS = 60_000;
-// #2539 live-fire — recency bound for ids this runner has positively SETTLED (acked + marked
+// live-fire — recency bound for ids this runner has positively SETTLED (acked + marked
 // read). A server list snapshot taken before the settle's markRead (the startup unread poll,
 // any future server-listed lane) can land its stale copy in enqueueMessage AFTER the delivery —
 // re-delivering an already-delivered message (immediately as a steer under the soft-steer
 // default, or at turn-end before it). Insertion-ordered, oldest evicted; the race window is
 // intra-process and short, so a recency cap is generous.
 const SETTLED_MESSAGE_IDS_CAP = 1024;
-// #2539 Phase B — bound on soft-steered ids held between persist and consumption. The adapter's
+// Phase B — bound on soft-steered ids held between persist and consumption. The adapter's
 // ledger cap backpressures first (it stops accepting new positive persists), so this is the
 // runner-side defense-in-depth ceiling, not the operating bound.
 const AWAITING_MID_TURN_DELIVERY_CAP = 256;
@@ -138,9 +137,9 @@ const PROMPT_ECHO_DEDUP_MS = 30_000;
 // `<task-notification>` is the harness wrapper for async monitor/task wake-ups
 // (which embed a `[relay message #…]` deeper inside, defeating a plain prefix
 // match) — it is emitted only by the harness, never typed by a human, so any
-// echo starting with it is a system injection, not a user prompt (#289).
-const RELAY_INJECTION_MARKERS = ["[relay message #", "[agent-relay", "<task-notification>"];
-// #1116: bounded settle-poll for provider pre-flush anchors. The adapter owns the
+// echo starting with it is a system injection, not a user prompt.
+const RELAY_INJECTION_MARKERS = ["[relay message #", "[humwick", "[agent-relay", "<task-notification>"];
+// bounded settle-poll for provider pre-flush anchors. The adapter owns the
 // source-specific read; the runner owns the shared timeout knobs.
 const SETTLE_POLL_INTERVAL_MS = 250;
 const SETTLE_POLL_TIMEOUT_MS = 4_000;
@@ -153,10 +152,10 @@ export class AgentRunner {
   private get bus() { return this.context.bus; }
   private readonly effortRuntime: Pick<RunnerOptions, "instanceId" | "adapter" | "effort">;
   private readonly claims = new ClaimTracker();
-  // Phase 2 (#196): the Stop hook reads reply obligations from this local snapshot, never
+  // Phase 2: the Stop hook reads reply obligations from this local snapshot, never
   // from the server — so a slow server can no longer wedge a turn (the crux fix).
   private readonly obligationCache: ReplyObligationCache;
-  // Phase 2 (#196): Runner→server append-log events (session turns, reasoning, prompts,
+  // Phase 2: Runner→server append-log events (session turns, reasoning, prompts,
   // insights, hook-fatal) go through this durable, disk-backed, timestamped queue instead of
   // direct fire-and-forget HTTP — so nothing is lost across a server/Runner restart.
   private readonly outbox: Outbox;
@@ -167,7 +166,7 @@ export class AgentRunner {
   private readonly lifecycleMilestones: LifecycleMilestones;
   private readonly promptCommands: PromptCommands;
   private readonly pendingPermissionStore: PendingPermissionStore;
-  // #1565 F1 — the one gate in front of the provider's single input channel. Every payload the
+  // F1 — the one gate in front of the provider's single input channel. Every payload the
   // runner delivers (message batch, injected prompt, self-resume continuation, memory preamble)
   // passes through it, so two payloads for one agent can never interleave at the wire. FIFO, with
   // the place in line taken synchronously at dispatch, so the payload the relay created first is
@@ -175,9 +174,9 @@ export class AgentRunner {
   private readonly providerInput = new ProviderInputQueue({
     onStuck: (heldMs) => logger.warn("delivery", `provider input stream held for ${heldMs}ms; force-releasing so delivery cannot wedge`),
   });
-  // #2984 — converges the provider on Relay's desired effort between turns; a bus notice only speeds it up.
+  // converges the provider on Relay's desired effort between turns; a bus notice only speeds it up.
   private readonly effort = new EffortReconciler({ http: () => this.http, agentId: () => this.agentId, runner: () => this.effortRuntime, process: () => this.process, publish: () => this.bus.flushHeartbeat(), hasProviderTurn: () => this.claims.activeWork().some((w) => w.kind === "provider-turn"), reserveInput: () => this.providerInput.reserve(), log: (message) => this.sessionLog(message) });
-  // #2389 — "did that turn actually do anything", and what to do when the answer is no. The ledger,
+  // "did that turn actually do anything", and what to do when the answer is no. The ledger,
   // its timers and the nudge/escalate ladder all live in empty-turn.ts; what stays here is the
   // wiring only AgentRunner can own — the adapter, the process handle and the input queue.
   private readonly emptyTurns = new EmptyTurnWatch({
@@ -192,16 +191,15 @@ export class AgentRunner {
   private deliveringEmptyTurnNudge = false;
   private readonly insights: RunnerInsights;
   private readonly busyReconciler: BusyReconciler;
-  private readonly providerQuotaHarvest: ProviderQuotaHarvest;
   private readonly credentials: Credentials;
   private control?: ControlServer;
   private registeredAt?: number;
-  // Stage 2 (#215): the local MCP endpoint the agent connects to, fronting the relay so the
-  // Runner owns reconnect/backoff + a durable buffer. Disabled via AGENT_RELAY_MCP_PROXY=0
+  // Stage 2: the local MCP endpoint the agent connects to, fronting the relay so the
+  // Runner owns reconnect/backoff + a durable buffer. Disabled via HUMWICK_MCP_PROXY=0
   // (then the agent connects to the relay directly, Stage-1 behaviour). The proxy secret is the
   // bearer the agent presents to the localhost proxy — it decouples the agent from the rotating
   // relay token (the proxy injects the live token relay-side).
-  private proxy?: RelayMcpProxy;
+  private proxy?: HumwickMcpProxy;
   private mcpProxyEndpoint?: string;
   private readonly mcpProxyEnabled: boolean;
   private readonly mcpProxySecret: string;
@@ -210,9 +208,9 @@ export class AgentRunner {
     suspendHeartbeat: () => this.bus.suspendHeartbeat(),
     stopStatusWatchers: () => this.options.adapter.stopStatusWatchers?.(),
   });
-  // #633 — set when the provider terminally exits but the runner stays alive (native
+  // set when the provider terminally exits but the runner stays alive (native
   // auto-compaction / manual-resume hold). Rides on the offline status frame so the server fires a
-  // terminal `agent.exited` event with a #636 diagnosis instead of the death going silent. Cleared
+  // terminal `agent.exited` event with a diagnosis instead of the death going silent. Cleared
   // on any genuine restart back to busy/idle.
   private terminalProviderExit?: Record<string, unknown>;
   private nativeSelfResume = new NativeSelfResumeTracker();
@@ -226,12 +224,12 @@ export class AgentRunner {
   private readonly testRunDedupSweep: TestRunDedupSweep;
   private processStartedAt = 0;
   private providerSessionId = crypto.randomUUID();
-  // Last transcript path seen this session — used by end-of-session Insights (#184)
+  // Last transcript path seen this session — used by end-of-session Insights
   // when the SessionEnd hook payload omits it.
   private lastTranscriptPath?: string;
   private readonly unexpectedExitTimes: number[] = [];
   private readonly pendingMessages = new Map<number, Message>();
-  // Hold inbox input through clear+inject and the bounded late-commit grace (#2477/#2849).
+  // Hold inbox input through clear+inject and the bounded late-commit grace.
   private readonly continuationFence = new ClearInjectInboxFence(() => { if (this.pendingMessages.size > 0) this.scheduleDrain(); });
   private readonly lateClearRecovery = new LateClearRecovery((commandId) => this.finishLateClearGrace(commandId));
   private readonly deliverySettlements = new DeliverySettlements();
@@ -265,51 +263,52 @@ export class AgentRunner {
   // Display-only startup modal evidence. It never touches work claims or turn state.
   private startupPaneDialog?: ProviderState;
   private deliverySubmitHold?: ProviderState;
-  /** #2664 — what the hold withheld: the unconfirmed item for the operator's resend, and later prompts parked in order behind it. */
+  /** what the hold withheld: the unconfirmed item for the operator's resend, and later prompts parked in order behind it. */
   private heldSubmit: HeldSubmit = emptyHeldSubmit();
   private readonly submitDeliveryAttempts = new Map<number, number>();
   private submitRecoveryInFlight = false;
   private submitRecoveryTurnStarted = false;
   private submitRecoveryRequested = false;
-  // #2664 — a held submit that did land often leaves no later event to re-run the recovery probe.
+  // a held submit that did land often leaves no later event to re-run the recovery probe.
   private submitRecoveryTimer?: ReturnType<typeof setInterval>;
   private submitRecoveryPollMs = 10_000;
   private submitRecoveryPollWindowMs = 5 * 60_000;
-  // #2664 — the operator's resend of the held prompt runs ahead of every parked inbox row.
+  // the operator's resend of the held prompt runs ahead of every parked inbox row.
   private submitResendInFlight = false;
-  // #2664 — set INSIDE the FIFO slot of an unconfirmed submit, so the next queued prompt sees the fence
+  // set INSIDE the FIFO slot of an unconfirmed submit, so the next queued prompt sees the fence
   // before the failing caller has published the hold; cleared with the hold.
   private submitFenceRaised = false;
-  // #2664 — park posts (and their retries) run in the input order, their place taken at the parking decision.
+  // park posts (and their retries) run in the input order, their place taken at the parking decision.
   private readonly parkPosts = new ProviderInputQueue({ onStuck: (heldMs) => logger.warn("delivery", `parked prompt post held ${heldMs}ms; releasing the next`) });
   private terminalFailure?: { reason: string; message: string; providerState?: ProviderState };
-  // #286: a usage/rate-limit hold. The turn truly ended (idle), but the agent is
+  // a usage/rate-limit hold. The turn truly ended (idle), but the agent is
   // held until the limit resets, so this can't ride an active-work claim like the
   // permission-blocked state does. publishStatus surfaces it as the agent's
   // providerState; it clears when a new turn starts (the relay's resume message
   // wakes one) so the blocked badge lifts on its own.
   private rateLimitHold?: ProviderState;
   private pendingRateLimitHold?: ProviderState;
-  // #1173: like rateLimitHold — a deny-then-hold "questions" (AskUserQuestion) prompt's own
+  // like rateLimitHold — a deny-then-hold "questions" (AskUserQuestion) prompt's own
   // turn genuinely ends (the provider reacts to the denial and stops normally) before the human
   // answers, so the pendingApproval can't ride the provider-turn active-work claim (it would
   // vanish the instant that claim clears on the real idle). Persists across idles and new turns
-  // (#2913); cleared once the answer is injected (or the prompt is dismissed/times out).
+  // cleared once the answer is injected (or the prompt is dismissed/times out).
   private pendingQuestionHold?: ProviderState;
-  // #2919 — the turn-end capture saw accepted input queued behind this turn: its idle opens the next turn.
+  // the turn-end capture saw accepted input queued behind this turn: its idle opens the next turn.
   private queuedTurnFollows = false;
-  // Settle-poll cadence for the pre-flush anchor (#1116) — instance fields (not just the
+  // Settle-poll cadence for the pre-flush anchor — instance fields (not just the
   // module constants) so tests can shrink them without waiting out the real bound.
   private settlePollIntervalMs = SETTLE_POLL_INTERVAL_MS;
   private settlePollTimeoutMs = SETTLE_POLL_TIMEOUT_MS;
   private scratch?: SessionScratchLayout;
-  // #417: tracks how many times each spawner obligation has been re-injected so a
+  private readonly registrationMeta: Record<string, unknown>;
+  // tracks how many times each spawner obligation has been re-injected so a
   // non-responsive provider can't spin in a re-injection loop.
   private readonly pendingObligationInjections = new Map<number, number>();
-  // #2539 live-fire — ids positively settled (acked + marked read) by THIS process; enqueueMessage
+  // live-fire — ids positively settled (acked + marked read) by THIS process; enqueueMessage
   // drops stale re-enqueues of them. Bounded recency (see SETTLED_MESSAGE_IDS_CAP).
   private readonly settledMessageIds = new Set<number>();
-  // #2550 — defense-in-depth backstop under the server-side decideDelivery rule: content hashes of
+  // defense-in-depth backstop under the server-side decideDelivery rule: content hashes of
   // the system-owned context payloads (memory/identity/charter/startup-context/self-resume
   // continuation) already delivered to the CURRENT provider context generation. A byte-identical
   // re-inject within one generation is skipped (a future double-emitting path must not paste the
@@ -320,23 +319,23 @@ export class AgentRunner {
   // repeat. This is a safety net, not the primary fix: the server's history classification of the
   // recovery artifact is what removes the cause.
   private readonly injectedContextHashes = new Set<string>();
-  // #3411 — which path areas this context generation entered; reset with injectedContextHashes.
+  // which path areas this context generation entered; reset with injectedContextHashes.
   private readonly areaMemory = new AreaMemoryTracker({ agentId: () => this.agentId, cwd: () => this.options.cwd, providerSessionId: () => this.providerSessionId, http: () => this.http, log: (message) => this.sessionLog(message) });
-  // #2539 Phase B — soft-steered batches accepted by the provider but NOT yet consumed: the
+  // Phase B — soft-steered batches accepted by the provider but NOT yet consumed: the
   // persisted-but-unconsumed window. The runner keeps the offered Message so the adapter's ledger
   // can settle by id alone ({@link settleSoftSteerConsumption} marks read;
   // {@link reofferSoftSteerIds} requeues the ORIGINAL message into the normal lane). Bounded —
   // past the cap settle falls back to the un-acked requeue path (the adapter's own ledger cap
   // backpressures before this, so the fallback is defense-in-depth).
   private readonly awaitingMidTurnDelivery = new Map<number, Message>();
-  // #2619 — the hold/resume state machine: hold episodes + the ONE parked queue of refused input
+  // the hold/resume state machine: hold episodes + the ONE parked queue of refused input
   // (unread, claim released, never re-drained into the wall). See provider-hold.ts.
   private readonly hold = new ProviderHoldEpisodes();
   private readonly refusedPrompts: RefusedPromptStore;
-  // #2619 — refused context injections parked as prompts (by heldPromptKey): what their ACCEPTANCE
-  // must still do that the refused injectContext did not (the #2550 hash, the clear fence release).
+  // refused context injections parked as prompts (by heldPromptKey): what their ACCEPTANCE
+  // must still do that the refused injectContext did not (the hash, the clear fence release).
   private readonly parkedContextInjections = new Map<string, { contentHash: string; afterClearCommandId?: string }>();
-  // #2397 round 3 review (MED-3r): same ladder, for a message an adapter reports via
+  // round 3 review (MED-3r): same ladder, for a message an adapter reports via
   // DeliverResult.terminalFailureIds — without this, a re-queued message whose provider just
   // exhausted a terminal-failure retry budget (e.g. OpenCode against a rate-limited upstream) was
   // re-attempted on the very next tick, forever, with no backoff. Cleared once it is acknowledged.
@@ -401,12 +400,12 @@ export class AgentRunner {
       updateCommand: (id, input) => this.bus.updateCommand(id, input), fetchCommand: (id) => this.http.request("GET", `/api/commands/${encodeURIComponent(id)}`), destructiveInputUnsettled: (id) => this.contextResets.unsettled(id), checkAcknowledgement: (ack, status) => this.nativeSelfResume.checkAcknowledgement(ack, status),
     });
     this.attachmentCacheSweep = new AttachmentCacheSweep(this.agentId, (message) => this.logRunnerDiagnostic(message));
-    // #2142 — "latest wins" test-run dedup, scoped to THIS session's command-owning provider
+    // "latest wins" test-run dedup, scoped to THIS session's command-owning provider
     // process tree. Interactive Codex exposes a visible TUI pid separately from its App Server;
     // commands descend from the latter, so resolveTestRunRootPid prefers the runner-owned child.
     // No pid ⇒ no scope ⇒ no signalling: a sweep that cannot prove ownership must never act.
     const sessionProviderPid = () => resolveTestRunRootPid(this.process, (managedProcess) => this.options.adapter.resolveBusyPid?.(managedProcess));
-    // #2461 — ancestry alone made this sweep a no-op for `relay_run` gate runs (a disjoint tree
+    // ancestry alone made this sweep a no-op for `humwick_run` gate runs (a disjoint tree
     // under the orchestrator). It now also owns anything env-tagged with this agent's id, classifies
     // against the repo's CONFIGURED gate commands, and reads live leases during each sweep. The
     // config read is cached for the session — it is a repo file, so re-reading it every 15s for the
@@ -427,8 +426,8 @@ export class AgentRunner {
         this.bus.setToken(token);
         // The proxy reads the token live via getToken(), so forwarding already uses the new one.
         // A re-mint can change scope (e.g. a profile change), so refresh the relay tool list and
-        // emit tools/list_changed if the visible set changed (#215 — token-scope transition).
-        // #2973 — a re-register follows a relay restart (a deploy): re-list so changed tools reach the agent.
+        // emit tools/list_changed if the visible set changed.
+        // a re-register follows a relay restart (a deploy): re-list so changed tools reach the agent.
     void this.proxy?.refreshTools().catch(() => {});
       },
       resumeLivenessAndPublishRotation: (status, jti) => {
@@ -436,7 +435,7 @@ export class AgentRunner {
         // An earlier auth failure may have stopped the liveness loop; restart it so the
         // agent reports live again on the fresh token. startLiveness clears any
         // existing timer first, so this is safe on the normal (proactive) renew path too.
-        this.startLiveness();
+        this.liveness.start();
         this.pendingTimelineEvent = { status, id: jti, timestamp: Date.now() };
         this.bus.reconnectTransport(status === "runtime-token-reminted" ? "runtime token re-minted" : "runtime token renewed");
         this.publishStatus();
@@ -459,22 +458,13 @@ export class AgentRunner {
       report: (record) => this.tokenUsageCoverage.report(record, (r) => this.http.reportTokenUsage(this.agentId, r)),
       capture: (key, read, pending) => this.tokenUsageCoverage.capture(key, read, pending),
       debug: (message) => this.sessionDebug(message),
-      // Capture/POST failures must be visible at INFO alongside empty passes (#2491).
+      // Capture/POST failures must be visible at INFO alongside empty passes.
       reportFailure: (error) => this.sessionLog(`token-usage capture failed: ${errMessage(error)}`),
     });
-    this.providerQuotaHarvest = new ProviderQuotaHarvest({
-      agentId: this.agentId,
-      provider: options.provider,
-      // #2514 — the per-provider config env carries a dedicated-home provider's (claude-b's) own
-      // credential, which the quota harvest needs to key its reports under the B subscription.
-      providerConfigEnv: () => this.options.providerConfig.env,
-    });
     this.liveness = new LivenessExchange({
       http: this.http, bus: () => this.bus, agentId: this.agentId, instanceId: options.instanceId, logIntervalMs: HTTP_LIVENESS_LOG_INTERVAL_MS,
       isStopped: () => this.lifecycle.stopped, isTerminalStatusLatched: () => this.lifecycle.terminalStatusLatched,
       currentStatus: () => this.claims.currentStatus(),
-      sampleQuota: () => this.providerQuotaHarvest.sample(),
-      acceptQuota: (report, result) => this.providerQuotaHarvest.accept(report, result),
       enqueueMessage: (message) => this.enqueueMessage(message), triggerEffort: () => this.effort.trigger(),
       recoverRuntimeTokenAfterAuthFailure: (source) => this.credentials.recoverRuntimeTokenAfterAuthFailure(source),
       logRunnerDiagnostic: (message) => this.logRunnerDiagnostic(message),
@@ -590,7 +580,7 @@ export class AgentRunner {
         ]),
       ],
       tags: [...new Set([options.provider, ...csvTags(tagsFromEnv()), ...options.tags, ...options.providerConfig.defaultTags, ...(options.headless ? ["headless"] : [])])],
-      meta: runnerIdentityMeta(this.options, { runtime, agentId: this.agentId, tmuxSession: providerTerminalSession(this.process), tmuxSocket: providerTerminalSocket(this.process), auth: { profileId: this.credentials.profileId, jti: this.credentials.jti, expiresAt: this.credentials.expiresAt } }, "registration"),
+      meta: this.registrationMeta = runnerIdentityMeta(this.options, { runtime, agentId: this.agentId, tmuxSession: providerTerminalSession(this.process), tmuxSocket: providerTerminalSocket(this.process), auth: { profileId: this.credentials.profileId, jti: this.credentials.jti, expiresAt: this.credentials.expiresAt } }, "registration"),
       heartbeatMeta: () => this.heartbeatRuntimeMeta(),
       heartbeatIntervalMs: 30_000,
       initialStatus: "idle",
@@ -602,25 +592,25 @@ export class AgentRunner {
   }
 
   private registerProviderSessionRoutes(): void {
-    // (#1617) — neither publisher has a try/catch of its own, and both bottom out in
+    // neither publisher has a try/catch of its own, and both bottom out in
     // sessionOutbox.enqueue: a synchronous bun:sqlite INSERT that throws outright once the outbox
     // is closed (teardown ordering in stop(): the adapter keeps emitting after close) or the
     // database errors. This is the highest-frequency fire-and-forget site in the runner — every
     // provider session event passes through it — so leaving it unguarded is the likeliest way a
-    // live agent silently stops existing (Bun exits(1) on an unhandled rejection, #1614).
-    // #2389 — turn-output evidence is counted HERE, at the registration seam, not inside the
+    // live agent silently stops existing (Bun exits(1) on an unhandled rejection).
+    // turn-output evidence is counted HERE, at the registration seam, not inside the
     // publish functions: `publishProviderSessionEvents` delegates to the single-event path only for
     // `prompt`/`response` and handles every other type itself, and Claude's reasoning tail emits
     // ALL of its tool/reasoning steps through that batch. Counting downstream missed them, so a
     // Claude turn that ran a dozen tools and produced no extractable closing text counted zero.
     this.options.adapter.onSessionEvent?.((event) => { this.emptyTurns.noteOutput(event); this.areaMemory.noteToolPaths([event]); if (event.type === "prompt") this.nativeSelfResume.notePrompt(event.body, event.occurredAt); void this.sessionMirror.publishProviderSessionEvent(event).catch((error) => this.reportBackgroundRejection("provider session event publish", "session.publish_failed", "Provider session event not mirrored", error)); });
     this.options.adapter.onSessionEvents?.((events) => { this.areaMemory.noteToolPaths(events); for (const event of events) { this.emptyTurns.noteOutput(event); if (event.type === "prompt") this.nativeSelfResume.notePrompt(event.body, event.occurredAt); } void this.sessionMirror.publishProviderSessionEvents(events).catch((error) => this.reportBackgroundRejection("provider session event batch publish", "session.publish_failed", "Provider session events not mirrored", error)); });
-    // #2389 — output a provider can observe but cannot mirror (an OpenCode tool part, whose wire
+    // output a provider can observe but cannot mirror (an OpenCode tool part, whose wire
     // shape we deliberately do not guess at). Evidence only; nothing is published.
     this.options.adapter.onTurnActivity?.(() => this.emptyTurns.noteOutput());
   }
 
-  // The adapter's status seam, split out of run() (#1617) so the guarded restart call below is
+  // The adapter's status seam, split out of run so the guarded restart call below is
   // reachable without booting a whole runner — the crash it guards against is exactly the one a
   // test has to be able to drive.
   /** Pane evidence can change only the displayed startup dialog and timeline, never work claims. */
@@ -640,7 +630,7 @@ export class AgentRunner {
   }
 
   private handleAdapterStatusChange(status: ProviderStatusUpdate): void {
-    // #2505 — stop() publishes the runner's terminal edge directly. Once it has started, an
+    // stop publishes the runner's terminal edge directly. Once it has started, an
     // adapter callback can only be stale: an input already inside ProviderInputQueue may finish
     // after stopStatusWatchers() and arm a fresh provider watcher, while an older watcher may
     // still be returning from an async probe. Neither is allowed to reopen terminal status.
@@ -649,18 +639,18 @@ export class AgentRunner {
     const semanticStatus = typeof status === "string" ? status : status.status;
     if ((semanticStatus === "busy" || semanticStatus === "offline" || semanticStatus === "error") && this.startupPaneDialog) this.startupPaneDialog = undefined;
     if (this.shouldRestartUnexpectedProviderExit(semanticStatus)) {
-      // (#1617) — restartUnexpectedProviderExit is an outer try/finally with NO catch wrapped
+      // restartUnexpectedProviderExit is an outer try/finally with NO catch wrapped
       // around awaited work that can still throw (recoverNativeSelfResumeExit, the undetermined-
       // exit confirmation read, the timeline/status publishes). A reject here used to kill the
       // runner outright: the crash path for the exact situation this method exists to recover
-      // from, on a runner nothing respawns (#1618).
+      // from, on a runner nothing respawns.
       void this.restartUnexpectedProviderExit(semanticStatus).catch((error) => this.reportBackgroundRejection("unexpected provider exit restart", "provider.restart_failed", "Provider restart after unexpected exit failed", error));
       return;
     }
     this.setProviderStatus(status);
     if (runnerShouldResolveProviderExit(semanticStatus, this.lifecycle.exitCommandInProgress)) {
       const exitCode = semanticStatus === "offline" ? 0 : 1;
-      // #2443 — a provider-reported terminal failure (model retired/404, auth error, exhausted
+      // a provider-reported terminal failure (model retired/404, auth error, exhausted
       // retries, ...) used to resolve straight to `onProviderExit` with nothing surfaced beyond
       // the mirror log: the orchestrator's own exit diagnostics tail the process's stdout/stderr
       // capture, which held only the provider's OWN startup output, not this. Log it here —
@@ -677,12 +667,12 @@ export class AgentRunner {
     this.control = startControlServer({
       onStatus: (status) => { if (!this.options.adapter.reportsContextResets) this.contextResets.observeStatus(status); this.setProviderStatus(status); },
       onTerminalAttachSpec: () => this.terminalAttachSpec(),
-      // #2459 — the current non-secret attachment generation, resolved from the live process
+      // the current non-secret attachment generation, resolved from the live process
       // the same way terminalAttachSpec reads it. Only wired when the adapter declares one;
       // absent ⇒ the endpoint reports no generation and the orchestrator skips the check.
       onTerminalGeneration: () => Promise.resolve(this.process ? this.options.adapter.terminalAttachGeneration?.(this.process) : undefined),
       // Hot-path-safe: answered instantly from the local snapshot, never a server
-      // round-trip. The snapshot is kept warm by the background refresh below (#196).
+      // round-trip. The snapshot is kept warm by the background refresh below.
       onReplyObligations: () => this.obligationCache.freshForNag(),
       onSubagentUsage: this.options.adapter.captureSubagentTokenUsage?.bind(this.options.adapter),
       onSessionTurn: (input) => this.turnReport.publishSessionTurn(input), onPermissionResolved: (input) => this.sessionMirror.publishSessionEvent({ from: this.agentId, to: "user", body: input.body, occurredAt: input.occurredAt, session: { type: "prompt-resolution", origin: "provider", label: input.decisionLabel, ...(this.currentTurnId ? { turnId: this.currentTurnId } : {}), stepId: `prompt-resolution:${input.approvalId}`, promptResolution: input } }),
@@ -720,6 +710,7 @@ export class AgentRunner {
       if (isEffortNotice(eventType, data)) this.effort.trigger();
     });
     this.bus.on("error", (code, message) => this.handleBusError(String(code), String(message)));
+    this.ensureScratch();
     await registerWithinDeadline(this.bus, registrationTimeoutMsFromEnv(), this.options.relayUrl, (reason) => logger.fatal("register", reason));
     await this.bus.subscribe(["command.*"]);
     this.registeredAt = Date.now();
@@ -728,9 +719,8 @@ export class AgentRunner {
     this.obligationCache.start();
     this.outbox.start();
     this.sessionMirror.start();
-    this.ensureScratch();
     void sweepRunnerStaleScratch({ listAgents: () => this.http.listAgents(), agentId: this.agentId, cwd: this.options.cwd, fallbackBaseDir: orchestratorBaseDirFromEnv(), log: (message) => this.logRunnerDiagnostic(message) });
-    this.scheduleAttachmentCacheSweep();
+    this.attachmentCacheSweep.start();
     await attemptProviderStartup(async () => {
       this.adoptProcess(await this.spawnProvider());
       this.registration.writeRunnerInfoFile();
@@ -740,7 +730,7 @@ export class AgentRunner {
     }, (status) => this.setProviderStatus(status));
     await this.bootstrapUnreadMessages();
     this.taskClaims.start();
-    this.startLiveness();
+    this.liveness.start();
     this.testRunDedupSweep.start();
     this.credentials.scheduleRuntimeTokenRenewal();
     this.scheduleDrain();
@@ -758,15 +748,15 @@ export class AgentRunner {
     await this.lifecycleMilestones.onStop("closed");
   }
 
-  // Start the local MCP proxy the agent connects to (Stage 2, #215). Forwards tool calls to the
+  // Start the local MCP proxy the agent connects to. Forwards tool calls to the
   // relay with the runner's LIVE token, buffers bufferable writes durably during a relay outage,
   // and narrows the tool list to this agent's workspace context. Best-effort: if it can't bind,
   // we fall back to a direct relay MCP connection (the agent env still works, no resilience).
-  // #1450 — the on-demand relay set to hide from a lean worker's DIRECT relay client (so only the
+  // the on-demand relay set to hide from a lean worker's DIRECT relay client (so only the
   // eager hot-path set boots), or undefined for any agent that keeps its full relay surface. The
   // gate MIRRORS the callmux relay-downstream gate (launch-assembly) EXACTLY — worker profile,
   // runner-managed deferral, sharedMcp on (the metaOnly callmux that fronts these exists), relay mcp
-  // on, no web tool off (#3024) — so the direct client is narrowed only when callmux fronts the set.
+  // on, no web tool off — so the direct client is narrowed only when callmux fronts the set.
   // ("proxy active" is implicit: only a constructed proxy consults this, and the relay downstream is
   // added only when the proxy is active — the two are on/off together, never a half state.)
   private startMcpProxy(): void {
@@ -777,7 +767,7 @@ export class AgentRunner {
         () => ({ agentId: this.agentId, provider: this.options.provider, model: this.options.model ?? this.latestProbeMetrics()?.model ?? null, effort: this.effortRuntime.effort ?? this.latestProbeMetrics()?.effort ?? null }),
         call => this.http.request("POST", "/api/web-tool-calls", call), process.env, runnerWebSearch(this.http)),
       redactToolResponse: this.options.adapter.mcpToolResponseRedactor?.(this.options.cwd),
-      relayMcpEndpoint: relayMcpEndpoint(this.options.relayUrl, this.context.mcpToolGeneration),
+      relayMcpEndpoint: relayMcpEndpoint(this.options.relayUrl),
       getToken: () => this.credentials.current(),
       authSecret: this.mcpProxySecret,
       enqueueBuffered: call => this.outbox.enqueue({ kind: "mcp-tool-call", payload: { tool: call.tool, arguments: call.arguments }, idempotencyKey: call.idempotencyKey }),
@@ -791,7 +781,7 @@ export class AgentRunner {
   private handleBusRegistered(): void {
     if (this.process) this.publishStatus();
     void this.nativeSelfResume.reconcile((id) => this.http.request("GET", `/api/commands/${encodeURIComponent(id)}`)).catch((error) => this.sessionLog(`compact settlement reconcile: ${errMessage(error)}`));
-    // #2973 — a re-register follows a relay restart (a deploy): re-list so changed tools reach the agent.
+    // a re-register follows a relay restart (a deploy): re-list so changed tools reach the agent.
     void this.proxy?.refreshTools().catch(() => {}); this.effort.trigger();
   }
 
@@ -800,7 +790,7 @@ export class AgentRunner {
     return mode === "isolated";
   }
 
-  // #2966 — publish the new incarnation's capabilities (effortSwitch) before its first turn: the
+  // publish the new incarnation's capabilities (effortSwitch) before its first turn: the
   // heartbeat spawnProvider resumes still describes the previous process, and the next is ~30s away.
   private adoptProcess(process: ManagedProcess): void {
     this.process = process;
@@ -815,42 +805,42 @@ export class AgentRunner {
     this.turnReport.clearPreDestroyRun();
     this.lifecycle.reopenProviderStatus();
     this.lastTranscriptPath = undefined;
-    // #2550 — a new provider process is a new context generation: its (empty) context may
+    // a new provider process is a new context generation: its (empty) context may
     // legitimately receive the same charter/memory bytes again, so the dedupe table resets.
     this.resetContextGeneration();
     const providerEnv = selectProviderConfigEnv(this.options.providerConfig.env, hostSourcesFor(this.options).settings);
+    // Runner ownership belongs to this process; provider tools must never overwrite it.
     const env = writeChildEnv({}, {
       ...resolveEnvLayers([process.env, providerEnv]),
-      ...(this.context.mcpToolGeneration === "humwick" ? { AGENT_RELAY_MCP_TOOLS: this.context.mcpToolGeneration } : {}),
-      AGENT_RELAY_RUNNER_PORT: String(this.control!.port),
-      AGENT_RELAY_RUNNER_ID: this.options.runnerId,
-      AGENT_RELAY_PROVIDER_SESSION_ID: this.providerSessionId,
-      AGENT_RELAY_ID: this.agentId,
+      HUMWICK_RUNNER_PORT: String(this.control!.port),
+      HUMWICK_RUNNER_ID: this.options.runnerId,
+      HUMWICK_PROVIDER_SESSION_ID: this.providerSessionId,
+      HUMWICK_ID: this.agentId,
       // The repo-name project id the runner uses for insight observations. Exposed so
       // agent-side signals (e.g. /introspect) tag the SAME project and aggregate together,
       // instead of the agent's worktree cwd splitting one repo into many "projects".
-      AGENT_RELAY_PROJECT: this.insightProject(),
-      ...(this.scratch ? { AGENT_RELAY_SCRATCH_DIR: this.scratch.tmpDir } : {}),
+      HUMWICK_PROJECT: this.insightProject(),
+      ...(this.scratch ? { HUMWICK_SCRATCH_DIR: this.scratch.tmpDir } : {}),
       ...await agentShellLaunchEnv(this.agentId, providerEnv),
-      AGENT_RELAY_URL: this.options.relayUrl,
-      AGENT_RELAY_APPROVAL: this.options.approvalMode,
-      ...(this.credentials.current() ? { AGENT_RELAY_TOKEN: this.credentials.current()! } : {}),
+      HUMWICK_URL: this.options.relayUrl,
+      HUMWICK_APPROVAL: this.options.approvalMode,
+      ...(this.credentials.current() ? { HUMWICK_TOKEN: this.credentials.current()! } : {}),
       // Dedicated, un-clobberable credential for the injected MCP endpoint. A rig's
-      // settings.json `env.AGENT_RELAY_TOKEN` would override the scoped token above at
-      // MCP-parse time → server-actor auth, no identity (#233). The MCP config references
-      // ${AGENT_RELAY_SESSION_TOKEN}, which rigs never set. See runner/src/relay-mcp.ts.
+      // settings.json `env.HUMWICK_TOKEN` would override the scoped token above at
+      // MCP-parse time → server-actor auth, no identity. The MCP config references
+      // ${HUMWICK_SESSION_TOKEN}, which rigs never set. See runner/src/relay-mcp.ts.
       //
-      // Stage 2 (#215): when the proxy is active the agent connects to the LOCAL proxy, so this
+      // Stage 2: when the proxy is active the agent connects to the LOCAL proxy, so this
       // holds the per-session PROXY SECRET (not the relay token). The proxy injects the live
       // relay token itself — the agent never holds it, and token rotation is invisible. With the
       // proxy disabled this stays the scoped relay token (Stage-1 direct connection).
       ...(this.proxy
         ? { [RELAY_MCP_TOKEN_ENV]: this.mcpProxySecret }
         : (this.credentials.current() ? { [RELAY_MCP_TOKEN_ENV]: this.credentials.current()! } : {})),
-      ...(this.credentials.jti ? { AGENT_RELAY_TOKEN_JTI: this.credentials.jti } : {}),
-      ...(this.credentials.profileId ? { AGENT_RELAY_TOKEN_PROFILE: this.credentials.profileId } : {}),
-      ...(this.credentials.expiresAt ? { AGENT_RELAY_TOKEN_EXPIRES_AT: String(this.credentials.expiresAt) } : {}),
-    });
+      ...(this.credentials.jti ? { HUMWICK_TOKEN_JTI: this.credentials.jti } : {}),
+      ...(this.credentials.profileId ? { HUMWICK_TOKEN_PROFILE: this.credentials.profileId } : {}),
+      ...(this.credentials.expiresAt ? { HUMWICK_TOKEN_EXPIRES_AT: String(this.credentials.expiresAt) } : {}),
+    }, ["HUMWICK_RUNNER_INFO_FILE"]);
     const config = buildRunnerSpawnConfig({ ...this.options, effort: this.effortRuntime.effort }, {
       getRelayToken: () => this.credentials.current(),
       agentId: this.agentId,
@@ -859,14 +849,14 @@ export class AgentRunner {
       ...(opts.resumeId ? { resumeId: opts.resumeId } : {}),
       ...(opts.suppressPrompt ? { suppressPrompt: true } : {}),
       ...(opts.systemPromptAppend ? { systemPromptAppend: opts.systemPromptAppend } : {}),
-      // Stage 2 (#215): the MCP endpoint the agent's client should target — the runner-local
+      // Stage 2: the MCP endpoint the agent's client should target — the runner-local
       // proxy when active, undefined when disabled (adapters fall back to the direct relay URL).
       ...(this.mcpProxyEndpoint ? { relayMcpEndpoint: this.mcpProxyEndpoint } : {}),
-      // #1450: the proxy secret, exposed to the assembler ONLY when the proxy is active, so the
+      // the proxy secret, exposed to the assembler ONLY when the proxy is active, so the
       // Codex per-agent metaOnly callmux can reach the relay endpoint on-demand THROUGH the proxy
-      // (live-token-injected — never the relay token on disk, #215).
+      // (live-token-injected — never the relay token on disk).
       ...(this.mcpProxyEndpoint ? { mcpProxySecret: this.mcpProxySecret } : {}),
-      // #672: the shared host-listener URL the `callmux bridge` connects to (env → default).
+      // the shared host-listener URL the `callmux bridge` connects to (env → default).
       // Always resolved; the assembler only emits the bridge when `agentProfile.sharedMcp` is on.
       sharedMcpUrl: this.proxy?.webToolsUrl ?? resolveSharedMcpUrl(),
       monitor: {
@@ -878,7 +868,7 @@ export class AgentRunner {
     // of the runner core. Assembly sees only the resulting snapshot.
     const { hydratedConfig, managedProcess } = await (async () => {
       try {
-        return await spawnWithServiceAccess(this.http, config, this.options.adapter, this.providerSessionId, Boolean(this.options.profile && this.options.spawnRequestId));
+        return await spawnWithServiceAccess(this.http, { ...config, onLaunchWarning: (event) => this.publishRunnerTimelineEvent(event) }, this.options.adapter, this.providerSessionId, Boolean(this.options.profile && this.options.spawnRequestId));
       } finally {
         // A failed replacement remains observable through the runner's status projection. Do not
         // also strand the reusable bus with heartbeats, quota/context metadata, and its ack
@@ -902,22 +892,22 @@ export class AgentRunner {
 
   private enqueueMessage(message: Message): void {
     if (!this.matchesMessage(message)) return;
-    // #2539 live-fire — a message this runner is ALREADY delivering (in this snapshot's drain,
+    // live-fire — a message this runner is ALREADY delivering (in this snapshot's drain,
     // so a stale server-list copy racing the offer) or has already SETTLED (acked + marked read)
     // is DONE: neither may re-enter the queue and be re-delivered (as a soft-steer into the very
     // turn that consumed it, or at turn-end). The in-flight check clears in the drain's finally,
     // so every legitimate requeue path (unacked, claim failure) re-enqueues fine.
     if (this.drainingMessageIds?.has(message.id) || this.heldSubmit.messages.has(message.id)) return;
     if (this.settledMessageIds.has(message.id)) return;
-    // #2539 Phase B — an id handed to the soft-steer lane (persisted, awaiting consumption) is in
+    // Phase B — an id handed to the soft-steer lane (persisted, awaiting consumption) is in
     // the adapter's ledger custody: a stale snapshot re-enqueue would double-POST the same body
     // into the live turn. Same class as the settled guard above; the reoffer seam is the only way
     // an awaiting id returns to this queue.
     if (this.awaitingMidTurnDelivery.has(message.id)) return;
-    // #2619 — a provider-refused id is parked until the provider takes a turn again; a poll
+    // a provider-refused id is parked until the provider takes a turn again; a poll
     // snapshot re-enqueueing it would re-POST it into the wall.
     if (this.hold.isParked(message.id)) return;
-    // #2619 — the relay's push of a refused prompt's own inbox row: it binds the pending park (the
+    // the relay's push of a refused prompt's own inbox row: it binds the pending park (the
     // push can beat the self-post's response), or — its caller already failed — is settled.
     const heldPromptKey = message.payload?.heldPromptKey;
     if (typeof heldPromptKey === "string" && this.hold.isPending(heldPromptKey)) {
@@ -929,7 +919,7 @@ export class AgentRunner {
       void this.settleSilently(message).catch(() => {}); // markRead failures are already swallowed inside
       return;
     }
-    // #2029 — the wake:false / kind:session suppression is now decided ONCE server-side (decideDelivery)
+    // the wake:false / kind:session suppression is now decided ONCE server-side (decideDelivery)
     // and the server no longer emits a turn frame for it, so no client-side `payload.wake` / `kind`
     // policy branch survives here. What remains is a belt-and-braces structural check, shared with the
     // SDK provider tail (frameSuppressedFromTurn) so the two clients cannot drift: obey a non-`turn`
@@ -966,7 +956,7 @@ export class AgentRunner {
     this.publishStatus();
   }
 
-  /** #2664 — the operator's escape hatch: clear the hold and the adapter fence, optionally resend what was held. */
+  /** the operator's escape hatch: clear the hold and the adapter fence, optionally resend what was held. */
   private async releaseSubmitHold(resend: boolean): Promise<Record<string, unknown>> {
     const held = this.heldSubmit;
     const released = this.deliverySubmitHold !== undefined;
@@ -991,7 +981,7 @@ export class AgentRunner {
   }
 
   /**
-   * #2664 — a dashboard prompt that meets the submit hold (at entry, or in its FIFO slot behind the
+   * a dashboard prompt that meets the submit hold (at entry, or in its FIFO slot behind the
    * submit that raised it) parks as a durable self-addressed inbox row: it drains in order once the
    * hold clears and survives a runner restart like any unread message. Not durable: the command fails.
    */
@@ -1050,7 +1040,7 @@ export class AgentRunner {
     });
   }
 
-  // =====================================================================  // #2539 Phase A — the ONE provider-input offer/settle seam.
+  // =====================================================================  // Phase A — the ONE provider-input offer/settle seam.
   //
   // Everything that puts content in front of the provider's single input channel OFFERS through
   // {@link offerProviderInput} (arm the empty-turn watch BEFORE the delivery is awaited — see
@@ -1064,7 +1054,7 @@ export class AgentRunner {
   /**
    * Offer one payload to the provider: arm the empty-turn watch for work-bearing input, run
    * delivery through the FIFO input queue, and disarm the arm if the offer throws. On success
-   * the arm stays because the delivery obliges the agent to produce work (#2389). A notice-only
+   * the arm stays because the delivery obliges the agent to produce work. A notice-only
    * batch is delivered without an arm because it owes no answer.
    */
   private async offerProviderInput<T>(run: (inputObserver?: ProviderInputObserver) => Promise<T>, offeredNothing?: (result: T) => boolean, armEmptyTurn = true): Promise<T> {
@@ -1080,7 +1070,7 @@ export class AgentRunner {
     }
   }
 
-  // #2619 — the ONLY two places runner code hands input to the provider (runner-input-seam.guard.test.ts
+  // the ONLY two places runner code hands input to the provider (runner-input-seam.guard.test.ts
   // enforces it). A provider may REFUSE input under a quota wall or throttle, so `onHeld` is a required
   // parameter: no caller can drop a refusal and report the input delivered. Both run in the caller's
   // FIFO slot (`ticket`), so the refusal outcome is judged in the serialized input order.
@@ -1091,12 +1081,12 @@ export class AgentRunner {
     return this.providerInput.run(async () => {
       await this.lateClearRecovery.ready();
       if (this.lifecycle.stopped) throw new Error("runner stopped before provider prompt offer");
-      // #2664 — decided in the slot: a prompt queued before the preceding submit raised the hold never reaches the fence.
+      // decided in the slot: a prompt queued before the preceding submit raised the hold never reaches the fence.
       if (onSubmitHeld && (this.deliverySubmitHold || this.submitFenceRaised)) {
         onSubmitHeld();
         return "submit-held" as const;
       }
-      if (!this.currentTurnId) this.turnReport.armTurnOpener([]); // #2840 — a prompt-opened turn answers no relay message
+      if (!this.currentTurnId) this.turnReport.armTurnOpener([]); // a prompt-opened turn answers no relay message
       if (await this.noteSubmitFence(() => this.options.adapter.deliverInitialPrompt!(this.process!, prompt, options)) !== "held") return "accepted" as const;
       onHeld();
       return "held" as const;
@@ -1135,7 +1125,7 @@ export class AgentRunner {
       offered = select();
       this.hold.noteOffered(offered);
       if (options.settlement && offered.length > 0) this.deliverySettlements.track(options.settlement);
-      // #2840 — armed BEFORE the offer: a synchronous provider starts, or runs, the turn inside deliver.
+      // armed BEFORE the offer: a synchronous provider starts, or runs, the turn inside deliver.
       const opening = this.turnReport.openTurnOpener(offered, !this.currentTurnId, options.ctx);
       const delivered = offered.length > 0 ? await this.noteSubmitFence(() => this.options.adapter.deliver(this.process!, offered, { ...opening.ctx, recordSubmittedPrompt: (text, images) => this.recordInjectedPrompt(text, images) })).catch((error) => { opening.settle(false); throw error; }) : [];
       const normalized = normalizeDeliverResult(delivered, offered);
@@ -1149,7 +1139,7 @@ export class AgentRunner {
   }
 
   /**
-   * Settle an offered message batch (#2539 Phase A): the ONE place that records delivery
+   * Settle an offered message batch: the ONE place that records delivery
    * attempts, marks acked messages read, releases their claims, and requeues everything the
    * adapter did not accept (partial acks are the soft-steer contract — the un-acked subset
    * re-offers toward turn-end). Returns the backoff (ms) to pace the next drain by: 0 for an
@@ -1165,7 +1155,7 @@ export class AgentRunner {
     }
     const acknowledgedIds = new Set(normalized.acknowledgedIds);
     const terminalFailureIds = new Set(normalized.terminalFailureIds);
-    // #2539 Phase B — soft-steer accepted-but-unconsumed ids: persistence is NOT delivery, so they
+    // Phase B — soft-steer accepted-but-unconsumed ids: persistence is NOT delivery, so they
     // are neither acked (no mark read / claim release / settled-id poison) nor un-acked (no requeue —
     // the provider row exists and must never be re-POSTed). Their settlement completes through
     // {@link settleSoftSteerConsumption} / {@link reofferSoftSteerIds} when the adapter's ledger
@@ -1205,7 +1195,7 @@ export class AgentRunner {
       this.rememberSettled(message.id);
       this.parkedContextAccepted(message);
     }
-    // #2397 round 3 review (MED-3r) — an un-acknowledged id the adapter attributes to a
+    // round 3 review (MED-3r) — an un-acknowledged id the adapter attributes to a
     // TERMINAL provider failure (as opposed to an ordinary mid-turn/busy defer) paces its own
     // re-drain with bounded exponential backoff.
     // Without this, a message whose provider just exhausted its own retry budget against an
@@ -1252,7 +1242,7 @@ export class AgentRunner {
     this.rememberSettled(message.id);
   }
 
-  /** #2619 — resume wakes, decided by the hold state machine (provider-hold.ts planWakes). */
+  /** resume wakes, decided by the hold state machine (provider-hold.ts planWakes). */
   private async resolveResumeWakes(messages: Message[]): Promise<Message[]> {
     const plan = this.hold.planWakes(messages);
     for (const wake of plan.settle) await this.settleSilently(wake);
@@ -1260,7 +1250,7 @@ export class AgentRunner {
     return plan.batch;
   }
 
-  /** #2619 — park a refused prompt PENDING, synchronously (call inside the FIFO slot). Returns its
+  /** park a refused prompt PENDING, synchronously (call inside the FIFO slot). Returns its
    *  heldPromptKey; {@link persistParkedPrompt} then makes it durable. */
   private parkRefusedPrompt(prompt: string, payload: Record<string, unknown> = {}): string {
     const heldPromptKey = crypto.randomUUID();
@@ -1270,7 +1260,7 @@ export class AgentRunner {
   }
 
   /**
-   * #2619 — post a pending parked prompt to this agent's own inbox so a restart re-reads it like any
+   * post a pending parked prompt to this agent's own inbox so a restart re-reads it like any
    * unread message. The relay idempotency key IS the heldPromptKey, so retries and an ambiguous
    * (committed, response lost) post converge on ONE row. False: it could not be made durable — the
    * park is dropped and the caller must report failure (never success).
@@ -1297,7 +1287,7 @@ export class AgentRunner {
     if (messages.length > 0) this.scheduleDrain();
   }
 
-  /** #2619 — a parked context injection was accepted: finish what its refused injectContext skipped. */
+  /** a parked context injection was accepted: finish what its refused injectContext skipped. */
   private parkedContextAccepted(message: Message): void {
     const key = message.payload?.heldPromptKey;
     const parked = typeof key === "string" ? this.parkedContextInjections.get(key) : undefined;
@@ -1307,7 +1297,7 @@ export class AgentRunner {
     if (parked.afterClearCommandId) this.releaseSelfResumeClearFence(parked.afterClearCommandId);
   }
 
-  // #2539 Phase B — stash a soft-steered Message for id-keyed settlement later. False ⇒ over the
+  // Phase B — stash a soft-steered Message for id-keyed settlement later. False ⇒ over the
   // cap (caller falls back to the un-acked requeue path).
   private trackAwaitingMidTurnDelivery(message: Message): boolean {
     if (this.awaitingMidTurnDelivery.size >= AWAITING_MID_TURN_DELIVERY_CAP) return false;
@@ -1316,7 +1306,7 @@ export class AgentRunner {
   }
 
   /**
-   * #2539 Phase B — the runner-owned CONSUMED settlement for soft-steered ids, handed to the
+   * Phase B — the runner-owned CONSUMED settlement for soft-steered ids, handed to the
    * adapter through ProviderDeliverContext.settleMidTurnConsumed. Mirrors the acked tail of
    * {@link settleMessageDelivery} exactly (mark read → release the claim → poison the intake
    * guard) plus one belt: a pendingMessages entry is dropped, so a requeue racing the consumption
@@ -1334,7 +1324,7 @@ export class AgentRunner {
   }
 
   /**
-   * #2539 Phase B — the runner-owned REOFFER for soft-steered ids whose persisted row can no
+   * Phase B — the runner-owned REOFFER for soft-steered ids whose persisted row can no
    * longer be consumed (session clear/compact/reroll swap, shutdown, reconcile-absent). Same
    * destination as settle's un-acked path (normal queue, turn-end delivery), driven by the
    * adapter's ledger. Ids no longer tracked (never stashed, or already settled/reoffered) are
@@ -1420,20 +1410,20 @@ export class AgentRunner {
       if (deliverable.length === 0) return;
       const deliverableIds = new Set(deliverable.map((message) => message.id));
       prepared = prepared.filter((message) => deliverableIds.has(message.id));
-      // #1565 F1 — behind the same gate as injected payloads: a message batch and a boundary
+      // F1 — behind the same gate as injected payloads: a message batch and a boundary
       // inject arriving together must not paste into each other.
       // Preserve arrival-time evidence across the input queue; adapters decide whether delivery actually deferred.
       const deliverCtx: ProviderDeliverContext = {
         isRecipientMidTurn: () => this.claims.reasons().includes("provider-turn"),
-        // #2539 Phase B — the deferred-settlement handoff: the adapter's soft-steer ledger settles
+        // Phase B — the deferred-settlement handoff: the adapter's soft-steer ledger settles
         // its persisted-but-unconsumed batches through these runner-owned seams (never its own
         // settlement implementation).
         settleMidTurnConsumed: (relayIds) => this.deliverySettlements.track(this.settleSoftSteerConsumption(relayIds)),
         reofferMidTurnIds: (relayIds) => this.reofferSoftSteerIds(relayIds),
       };
       // OFFER — arm the empty-turn watch only for work-bearing input, serialize through the FIFO
-      // input queue, disarm on rejection. (#2389 — armed at hand-off, not on resolution.)
-      // #2619 — a resume wake's continue was decided at planning time, before the claim/attachment
+      // input queue, disarm on rejection. (armed at hand-off, not on resolution.)
+      // a resume wake's continue was decided at planning time, before the claim/attachment
       // awaits above; the episode may have ended (or a new one parked input) since. Re-validated in
       // the FIFO slot at the offer instant: a continue that no longer holds is dropped and settled
       // silently. Refused input parks inside the slot (below).
@@ -1443,7 +1433,7 @@ export class AgentRunner {
         staleWakes.push(message);
         return false;
       }), { releaseClaims: true }), (heldIds) => {
-        // #2619 — park refused input NOW, inside the slot: no accepted offer may end the episode first.
+        // park refused input NOW, inside the slot: no accepted offer may end the episode first.
         const held = new Set(heldIds);
         for (const message of deliverable) {
           if (!held.has(message.id) || isResumeWake(message)) continue;
@@ -1496,7 +1486,7 @@ export class AgentRunner {
       this.drainingMessageIds = undefined;
       this.delivering = false;
       this.publishStatus();
-      // Unaccepted input during a live turn waits for turnCleared, rather than reoffering on every tick (#3315).
+      // Unaccepted input during a live turn waits for turnCleared, rather than reoffering on every tick.
       if (this.pendingMessages.size > 0 && (failed || drainBackoffMs > 0 || !this.currentTurnId)) this.scheduleDrain(failed ? Math.max(1000, drainBackoffMs) : drainBackoffMs);
     }
   }
@@ -1514,7 +1504,7 @@ export class AgentRunner {
     if (!this.options.adapter.clearContext || !this.process) throw new Error("provider does not support clearContext");
     if (ticket) await ticket.turn;
     await this.awaitContextCommandTurnClear("agent.clearContext");
-    // #2550 — same new-generation reset as the compact arm above: cleared before the
+    // same new-generation reset as the compact arm above: cleared before the
     // destructive step so any failure path still fails open toward re-delivery.
     this.resetContextGeneration();
     this.lateClearRecovery.begin(commandId, params, this.options.adapter.couplesClearInjectContinuation);
@@ -1522,15 +1512,15 @@ export class AgentRunner {
     try { providerResult = await this.options.adapter.clearContext(this.process); }
     finally { this.lateClearRecovery.finish(commandId, Boolean(providerResult && providerResult.clearConfirmed === true)); }
     if (providerResult && providerResult.clearConfirmed === true) this.contextResets.confirmed("clear", commandId);
-    // #2043 F2 — commit barrier for the self-resume clear-inject path: a `/clear` whose commit
+    // F2 — commit barrier for the self-resume clear-inject path: a `/clear` whose commit
     // could not be POSITIVELY confirmed is a possible no-op, so surface it as a FAILED command
-    // (mirroring native's timeout->FAILED) instead of the pre-#2043 silent success. Throw
+    // (mirroring native's timeout->FAILED) instead of the previous silent success. Throw
     // BEFORE the coupled in-process deliver so we never inject a continuation into a context
     // that may not have been cleared; the relay's continuation re-injection backstop (now also
     // armed for a FAILED clear-inject) is then the single recovery path — a false-negative
     // clear detection recovers rather than wiping working state.
     this.assertClearInjectCommitted(params, providerResult || undefined);
-    // The cleared context goes to the card now; the ~30s beat would leave the old usage visible meanwhile (#2771).
+    // The cleared context goes to the card now; the ~30s beat would leave the old usage visible meanwhile.
     this.bus.flushHeartbeat();
     // Before the continuation, so the next generation's first turn already sees the re-derived tools.
     providerResult = { ...(providerResult || {}), tokenRemint: await this.remintRuntimeTokenAtBoundary("clear") };
@@ -1553,17 +1543,17 @@ export class AgentRunner {
   // Fence the predecessor provider turn before a destructive compact/clearContext runs, so the
   // successor generation never overlaps it. Two provider shapes need two different fences:
   //
-  // #2043 F1 — a blind context-command submit (Claude's tmux `/compact` // `/clear`) must land on
+  // F1 — a blind context-command submit (Claude's tmux `/compact` // `/clear`) must land on
   // an IDLE prompt to parse as a slash command. Submitted while a turn is live it queues behind the
-  // turn and dequeues as literal chat, so the compaction silently evaporates — the #2043 runaway.
+  // turn and dequeues as literal chat, so the compaction silently evaporates — the runaway.
   // For those adapters we WAIT for the live turn to clear on its own; a wait that times out THROWS,
   // so the command fails loudly (F2/F4) rather than blind-submitting into a live turn and no-oping.
   //
-  // #2569 — an app-server adapter (Codex) whose clearContext starts a FRESH thread / whose compact
+  // an app-server adapter (Codex) whose clearContext starts a FRESH thread / whose compact
   // rewrites the current one via an awaited handshake. The await confirms the NEW generation is
-  // ready but does NOT settle the OLD turn: relay_compact_and_resume runs from within the model's
+  // ready but does NOT settle the OLD turn: humwick_compact_and_resume runs from within the model's
   // own live turn, so that turn keeps writing the worktree on the previous thread while the
-  // successor is armed on the new one — two generations revert each other (the #2569 silent
+  // successor is armed on the new one — two generations revert each other (the silent
   // overlap). A plain wait would time out on the still-live in-turn compaction, so we INTERRUPT the
   // predecessor turn, then wait for it to reach a terminal state (interrupt-then-settle, mirroring
   // the redirect path at the agent.interrupt arm) before the destructive step. A settle timeout
@@ -1581,7 +1571,7 @@ export class AgentRunner {
     if (adapter.interruptsTurnBeforeContextCommand) {
       const hasProviderTurn = this.claims.activeWork().some((work) => work.kind === "provider-turn");
       if (!hasProviderTurn || !adapter.interrupt || !this.process) return;
-      // #2389 — an interrupted turn ends with no output; that state has its own notice
+      // an interrupted turn ends with no output; that state has its own notice
       // (agent.turn_interrupted) and must not also draw an empty-turn strike.
       this.emptyTurns.reset();
       try {
@@ -1600,21 +1590,21 @@ export class AgentRunner {
     }
   }
 
-  // #2043 F2 — the clear-inject commit barrier. A self-resume `/clear` whose commit the adapter's
+  // F2 — the clear-inject commit barrier. A self-resume `/clear` whose commit the adapter's
   // clear-aware barrier could not POSITIVELY confirm (clearConfirmed !== true) is treated as a
-  // possible no-op and surfaced as a FAILED command, never the pre-#2043 silent success. Scoped to
+  // possible no-op and surfaced as a FAILED command, never the previous silent success. Scoped to
   // the coupled clear-inject path (couplesClearInjectContinuation) carrying a real continuation —
   // a manual `/clear` with no self-resume payload keeps its existing best-effort semantics.
   private assertClearInjectCommitted(params: Record<string, unknown>, clearResult: Record<string, unknown> | undefined): void {
     assertClearInjectCommitted(this.options.adapter.couplesClearInjectContinuation, params, clearResult, (message) => this.sessionLog(message));
   }
 
-  // #1588 — couple the self-resume continuation delivery into the SAME clearContext command that
+  // couple the self-resume continuation delivery into the SAME clearContext command that
   // wipes the context, so the two can never race across separate commands/transports again. The
   // relay embeds the fully-built (identity-augmented) continuation in the clear command's
   // `selfResume.continuation`; we deliver it in-process, strictly AFTER adapter.clearContext has
   // returned. `continuationDelivered` tells the relay whether it can skip the redundant reactive
-  // inject or must still fire its #1023 backstop — and it MUST be truthful, because the relay skips
+  // inject or must still fire its backstop — and it MUST be truthful, because the relay skips
   // BOTH backstops on continuationDelivered===true, so a false-positive true is a silent-wipe risk
   // with no recovery. So `true` requires TWO things: (1) the adapter's clear-aware barrier
   // POSITIVELY confirmed the TUI clear committed (clearResult.clearConfirmed === true — the strong
@@ -1637,7 +1627,7 @@ export class AgentRunner {
     // truthful continuationDelivered:true. Absent/false (older runner, or a settle timeout) → false.
     const clearConfirmed = clearResult?.clearConfirmed === true;
     try {
-      // #1607 N3 — reuse the outer clearContext ticket instead of letting injectContext reserve a
+      // N3 — reuse the outer clearContext ticket instead of letting injectContext reserve a
       // fresh one, which would queue behind (and thus deadlock on) the still-held outer ticket.
       await this.injectContext({ content: continuation, reason: "self-resume-continuation", selfResume }, ticket);
       if (!clearConfirmed) {
@@ -1668,14 +1658,14 @@ export class AgentRunner {
     const fullContextMessageId = typeof selfResume?.fullContextMessageId === "number"
       ? selfResume.fullContextMessageId
       : undefined;
-    // #2550 — the one content-hash backstop for system-owned context injections. injectContext is
+    // the one content-hash backstop for system-owned context injections. injectContext is
     // the SINGLE chokepoint every such payload flows through (continuation, identity, memory
     // preamble, startup context — all arrive as agent.injectContext commands), so one check here
     // covers every path. Byte-identical match only, per current generation. Prompts and messages
     // use injectPrompt/drainMessages and are never deduped here.
     const contentHash = createHash("sha256").update(content, "utf8").digest("hex");
     if (this.injectedContextHashes.has(contentHash)) {
-      this.sessionLog(`context injection (${reason ?? "no reason"}) skipped: byte-identical content already delivered this generation (#2550 backstop)`);
+      this.sessionLog(`context injection (${reason ?? "no reason"}) skipped: byte-identical content already delivered this generation (backstop)`);
       this.areaMemory.noteInjected(params, memoryIds);
       return {
         memoryIds,
@@ -1683,7 +1673,7 @@ export class AgentRunner {
         duplicateInjectSkipped: true,
         // Truthful settle evidence: the hash table IS the proof the payload reached this
         // provider context, so a skipped continuation still reports ingested (the relay's
-        // #2545 fence and transport settle then close the boundary instead of re-arming).
+        // fence and transport settle then close the boundary instead of re-arming).
         ...(isSelfResumeContinuation ? { continuationIngested: true, ...(fullContextMessageId !== undefined ? { fullContextMessageId } : {}) } : {}),
       } as Record<string, unknown>;
     }
@@ -1692,7 +1682,7 @@ export class AgentRunner {
       from: "system",
       to: this.agentId,
       kind: "system",
-      subject: isSelfResumeContinuation ? "Agent Relay self-resume continuation" : "Agent Relay memory context",
+      subject: isSelfResumeContinuation ? "Humwick self-resume continuation" : "Humwick memory context",
       body: content,
       payload: {
         memoryInjection: true,
@@ -1704,14 +1694,14 @@ export class AgentRunner {
       readBy: [],
       createdAt: Date.now(),
     };
-    // #1565 F1 — one payload at a time, in dispatch order (see dispatchCommand). The ticket, when
+    // F1 — one payload at a time, in dispatch order (see dispatchCommand). The ticket, when
     // present, is the place in line this command took the moment it arrived.
-    // #2389 — armed WATCH-ONLY. The turn after a memory block or a self-resume continuation
+    // armed WATCH-ONLY. The turn after a memory block or a self-resume continuation
     // legitimately produces nothing (a compaction, a silent acknowledgment), so it must take no
     // strike and provoke no nudge — but a continuation that genuinely strands still has to wake
     // someone, and the strike ladder can never see that. The timed backstop is what covers it.
     const contextArm = this.emptyTurns.armInput(Date.now(), "watch-only", true);
-    // #2619 — a context payload the provider REFUSED (a quota wall, a throttle) did not land. It
+    // a context payload the provider REFUSED (a quota wall, a throttle) did not land. It
     // parks in the hold machine like every other refused input (inbox-persisted, replayed by the
     // resume wake — never a generic continue, which would run it from the provider's history AND
     // again on replay). No hash, no `continuationIngested`, no fence release until the parked copy
@@ -1720,7 +1710,7 @@ export class AgentRunner {
     // replays it (src/self-resume.ts). A parked continuation names its recovery artifact so the relay
     // promotes it to ingested when the parked copy is delivered.
     let parkedKey: string | undefined;
-    // #3411 — decided inside the provider-input slot on every attempt: a reset queued ahead of this payload runs first.
+    // decided inside the provider-input slot on every attempt: a reset queued ahead of this payload runs first.
     let staleArea = false;
     const deliver = (slot?: ProviderInputTicket) => this.offerMessagesToProvider(() => (staleArea = this.areaMemory.isStaleInjection(params)) ? [] : [payload], () => {
       parkedKey = this.parkRefusedPrompt(content, isSelfResumeContinuation && fullContextMessageId !== undefined ? { selfResumeFullContextMessageId: fullContextMessageId } : {});
@@ -1730,7 +1720,7 @@ export class AgentRunner {
       await deliver(ticket);
     } catch (error) {
       // Codex has no input buffer: a payload offered during a live turn is rejected rather than
-      // queued (#1339). Serializing the boundary pair means the SECOND payload now meets the turn
+      // queued. Serializing the boundary pair means the SECOND payload now meets the turn
       // the first one started, so re-offer it once the turn ends instead of failing the command —
       // the same queue-behind-the-turn semantics Claude's transports get for free from the CLI's
       // own buffer. A timeout waiting for the turn re-throws: the command fails, the memory
@@ -1792,7 +1782,7 @@ export class AgentRunner {
     return allowed;
   }
 
-  /** #2550/#3411 — a new provider context generation: charter/memory may land again, every path area is unentered. */
+  /** a new provider context generation: charter/memory may land again, every path area is unentered. */
   private resetContextGeneration(): void { this.injectedContextHashes.clear(); this.areaMemory.resetGeneration(); }
 
   private recoverLateClear(input: { source?: string; providerSessionId?: string }): string | undefined {
@@ -1835,7 +1825,7 @@ export class AgentRunner {
         }
       }
       this.lifecycleMilestones.onRestart("work-cleared");
-      // #2414 — also honor a shutdown that began mid-restart (signal-driven, before stop() itself
+      // also honor a shutdown that began mid-restart (signal-driven, before stop itself
       // has run); this.lifecycle.stopped alone lags stop()'s own entry.
       if (this.lifecycle.stopped || this.lifecycle.shuttingDown) return;
       this.adoptProcess(await this.spawnProvider(opts));
@@ -1859,7 +1849,7 @@ export class AgentRunner {
   private shouldRestartUnexpectedProviderExit(status: SemanticStatus): boolean {
     return runnerShouldRestartUnexpectedProviderExit(status, {
       exitCommandInProgress: this.lifecycle.exitCommandInProgress,
-      // #2414 — this is the actual restart-suppression race: `shuttingDown` (armed synchronously
+      // this is the actual restart-suppression race: `shuttingDown` (armed synchronously
       // from the signal handler) must win it even before stop() itself has run and set `stopped`.
       stopped: this.lifecycle.stopped || this.lifecycle.shuttingDown,
       restartInProgress: this.lifecycle.restartInProgress,
@@ -1874,7 +1864,7 @@ export class AgentRunner {
     if (this.lifecycle.restartPending) return;
     this.lifecycle.beginUnexpectedExitRestart();
     try {
-      // Best-effort Insights capture for the segment that just ended in a crash (#183). This
+      // Best-effort Insights capture for the segment that just ended in a crash. This
       // path has no controlled teardown, so without it crashed sessions silently drop their
       // context-ratio datapoint. The process handle is still set (cleared later), so the
       // provider capture source is readable; the runner stays alive here (restart or offline), so the
@@ -1947,7 +1937,7 @@ export class AgentRunner {
         if (!hasResumeId && this.shouldRestartRecoverableProviderExit(diagnostics)) {
           logger.warn("lifecycle", `${this.options.provider} exit signal is early/recoverable; allowing fresh restart`);
         } else if (resumeId && this.shouldResumeWithContextProviderExit(diagnostics, recent.length)) {
-          // #1258 (L2): a long-lived agent killed via tmux-session-ended (external SIGTERM, reboot,
+          // (L2): a long-lived agent killed via tmux-session-ended (external SIGTERM, reboot,
           // OOM, admin cleanup) used to be stranded permanently offline even though the provider CLI printed
           // a resumable session id. Now, when Layer 3 captured a valid resume id, auto-resume WITH
           // context instead of surfacing manual recovery. Crash-loop protection reuses the existing
@@ -1974,10 +1964,10 @@ export class AgentRunner {
             },
           });
           this.process = undefined;
-          // #633: the runner stays alive (manual-resume hold), so neither the orchestrator tmux-gone
+          // the runner stays alive (manual-resume hold), so neither the orchestrator tmux-gone
           // path nor the heartbeat reaper will ever fire. Stamp the terminal marker so the SAME offline
           // status frame (published by setProviderStatus below) carries it; the server's bus status
-          // handler turns that edge into a terminal `agent.exited` event with a #636 diagnosis.
+          // handler turns that edge into a terminal `agent.exited` event with a diagnosis.
           this.terminalProviderExit = {
             providerSessionId: this.providerSessionId,
             reason: providerManualRecoveryReason(diagnostics),
@@ -2042,7 +2032,7 @@ export class AgentRunner {
       await Bun.sleep(delayMs);
       if (this.lifecycle.stopped || this.lifecycle.exitCommandInProgress) return;
       try {
-        // #1368/#harden — a resume relaunch always carries a resumeId here, so passing
+        // /#harden — a resume relaunch always carries a resumeId here, so passing
         // suppressPrompt would be a no-op (it's only consumed under !resumeId, see spawnProvider).
         // What actually keeps a skip-permissions resume off the interactive "Bypass Permissions
         // mode" gate: the config-seed re-heal in profile-home.ts, which idempotently re-applies
@@ -2073,7 +2063,7 @@ export class AgentRunner {
       && diagnostics.runtimeMs < RAPID_EXIT_MS;
   }
 
-  // #1258 (L2): auto-resume-with-context gate for a tmux-session-ended death at any point in an
+  // (L2): auto-resume-with-context gate for a tmux-session-ended death at any point in an
   // agent's life (not just the <30s early-flake window). Requires a captured resume id (the caller
   // only reaches this when one exists) and bounds crash loops via the shared unexpected-exit window:
   // once `recent` exceeds MAX_RAPID_UNEXPECTED_EXITS the agent is left offline for manual recovery.
@@ -2099,11 +2089,11 @@ export class AgentRunner {
 
   private async shutdownProvider(hard: boolean, timeoutMs = this.options.providerConfig.headless.shutdownTimeoutMs): Promise<ShutdownOutcome> {
     // Close provider-owned status sources before the graceful await, while keeping the runner's
-    // own transitional projection live until the adapter confirms the outcome (#2505).
+    // own transitional projection live until the adapter confirms the outcome.
     this.lifecycle.armTerminal();
     this.lifecycle.setLifecycleAction(hard ? "killing" : "shutting-down");
     this.publishStatus();
-    // #1746 — no process to kill is vacuously terminal. Otherwise the adapter now returns a
+    // no process to kill is vacuously terminal. Otherwise the adapter now returns a
     // VERIFIED terminal outcome (it re-observes liveness, it does not trust the kill call);
     // a legacy adapter that returns void is treated as `killed` for back-compat.
     let outcome: ShutdownOutcome = "killed";
@@ -2169,7 +2159,7 @@ export class AgentRunner {
       };
     }
     let deferredRateLimitHold = false, openQueuedTurn = false;
-    // #2619 — a turn the provider REFUSED (it ends in a rate-limit hold) did not run: it is neither
+    // a turn the provider REFUSED (it ends in a rate-limit hold) did not run: it is neither
     // an empty turn to nudge (the nudge would hit the same wall) nor a completion of claimed work.
     // The relay's resume turn is the one that gets judged/credited.
     const providerRefusedTurn = status === "idle" && typeof update !== "string" && update.providerState?.state === "blocked" && update.providerState.reason === "rate_limit";
@@ -2196,7 +2186,7 @@ export class AgentRunner {
           if (fresh) this.publishRateLimitNotice(update.providerState);
         }
       } else if (ps.state === "blocked" && ps.reason === "pendingQuestion") {
-        // #1173: set directly (never deferred) — unlike the rate-limit hold, this always
+        // set directly (never deferred) — unlike the rate-limit hold, this always
         // arrives while the turn that asked is still busy, well before the real idle it must
         // survive. Any other providerState (a fresh question, a plain approval, etc.) still
         // supersedes it via the `else` branch below.
@@ -2242,7 +2232,7 @@ export class AgentRunner {
     if (timelineStatus === "compacting") {
       this.compactionMidTurn = this.currentTurnId !== undefined;
     } else if (timelineStatus === "compacted") {
-      // #3411 — a native compaction drops what area memory delivered, not what the dedupe table proves.
+      // a native compaction drops what area memory delivered, not what the dedupe table proves.
       this.areaMemory.resetGeneration();
       this.nativeSelfResume.noteCompacted(typeof update !== "string" && typeof update.timeline?.timestamp === "number" ? update.timeline.timestamp : Date.now());
       this.publishCompactionNotice();
@@ -2255,7 +2245,7 @@ export class AgentRunner {
       }
     }
     if (status === "busy" && reason === "provider-turn") {
-      // #2482 — a launch-seeded, monitorless Claude turn can discover its transcript only after
+      // a launch-seeded, monitorless Claude turn can discover its transcript only after
       // the initial synthetic busy edge: Claude writes sessions/<pid>.json asynchronously after
       // its launcher gate opens. Accept a path on every busy edge, not just the edge that mints
       // the turn, so the terminal drain still knows where to settle the one/last turn's usage.
@@ -2271,8 +2261,8 @@ export class AgentRunner {
         this.emptyTurns.noteTurnStarted(this.currentTurnId, this.currentTurnStartedAt);
         this.turnReport.noteTurnStarted(this.currentTurnId);
         this.sessionLog(`turn started (turn ${this.currentTurnId})`);
-        // #2913: never clear pendingQuestionHold here — the busy edge that sets it can mint a turn.
-        // #1235 — a hookless (monitorless) adapter turn carries its live transcript path on the
+        // never clear pendingQuestionHold here — the busy edge that sets it can mint a turn.
+        // a hookless (monitorless) adapter turn carries its live transcript path on the
         // busy edge. Drive the reasoning tail natively so lean/isolated Claude workers, which
         // never install the Stop/UserPromptSubmit hooks, still stream chat. Hook-driven agents
         // never set transcriptPath here, so their hook-triggered capture is untouched.
@@ -2297,7 +2287,7 @@ export class AgentRunner {
       if (this.currentTurnId) {
         this.completedProviderTurns += 1;
         this.sessionLog(`turn ended via provider idle (turn ${this.currentTurnId})`);
-        // #2389 — "the provider says idle" is NOT the same as "the turn did something". Take the
+        // "the provider says idle" is NOT the same as "the turn did something". Take the
         // verdict after a settle delay, because several capture paths publish the closing response
         // asynchronously, after this edge.
         //
@@ -2308,7 +2298,7 @@ export class AgentRunner {
         if (timelineStatus === "compacted" || timelineStatus === "context-cleared" || this.compactionMidTurn || providerRefusedTurn) this.emptyTurns.noteTurnDiscarded(this.currentTurnId);
         else this.emptyTurns.noteTurnEnded(this.currentTurnId, Date.now());
       }
-      // #1235 — for a native (hookless) turn, capture the final assistant response from the
+      // for a native (hookless) turn, capture the final assistant response from the
       // transcript BEFORE tearing down the tail. Snapshot the ctx while currentTurnId is still
       // set so the closing response is tagged with the correct turn.
       const nativeFinish = this.sessionMirror.nativeCaptureActive() || Boolean(lateNativeTranscriptPath);
@@ -2326,17 +2316,17 @@ export class AgentRunner {
       }
       // Providers with append-system-prompt policy use lifecycle hooks for obligation handling;
       // others need the runner to re-inject pending obligations on idle.
-      // (#1614) — this delivery can suspend on the FIFO (#1607 N1) and, once resumed, reject if
+      // this delivery can suspend on the FIFO and, once resumed, reject if
       // the process died out from under it or the adapter is mid-turn; reported the same way
       // attemptInitialPromptDelivery reports its own adapter.deliver failures, so it can never
       // reach the top as an unhandled rejection (Bun exits(1) on those) and never vanish silently.
-      // (#1617) folded onto the shared reportBackgroundRejection shape — same channel, same
+      // folded onto the shared reportBackgroundRejection shape — same channel, same
       // status/title/body, one less hand-rolled copy of the reporting block.
       if (getManifest(this.options.provider)?.launch?.managedPolicyPrompt?.alwaysOn !== "append-system-prompt") {
         void this.reInjectPendingObligation().catch((error) => this.reportBackgroundRejection("re-inject pending obligation", "obligation.reinject_failed", "Pending reply obligation not re-injected", error));
       }
     }
-    // #2389 — work of any other kind starting inside a live turn (a background script, tracked
+    // work of any other kind starting inside a live turn (a background script, tracked
     // subprocess work) is independent proof the model acted, even if nothing was ever mirrored.
     if (status === "busy" && reason !== "provider-turn" && this.currentTurnId) this.emptyTurns.noteOutput();
     // A genuine restart back to forward progress clears the terminal-exit marker so a later offline
@@ -2344,13 +2334,13 @@ export class AgentRunner {
     if (status === "busy" || status === "idle") this.terminalProviderExit = undefined;
     if (status === "busy") {
       this.claims.clearTerminalStatus();
-      // #650: liveness-track the pids a reporter explicitly supplied; otherwise, for a
+      // liveness-track the pids a reporter explicitly supplied; otherwise, for a
       // provider-turn, fall back to the managed provider process itself. If that process
       // dies out-of-band with no exit event reaching the runner (crash/orphan/external
       // kill), the reconcile clears the stuck turn → idle. A dead pid means the turn is
-      // definitively over, so this can never falsely clear a live turn (#653's hazard).
+      // definitively over, so this can never falsely clear a live turn.
       const reportedPids = typeof update === "string" ? undefined : update.pids;
-      // #1138: process.pid is undefined for tmux-launched providers (Claude) — only
+      // process.pid is undefined for tmux-launched providers (Claude) — only
       // the adapter can resolve a real pid from the tmux session/socket. Without this,
       // an ordinary hook-driven turn tracks no pid at all, so the stale-turn backstop
       // below has nothing but elapsed time to go on.
@@ -2368,7 +2358,7 @@ export class AgentRunner {
         metadata: {
           ...(update.metadata ?? {}),
           ...(update.providerState ? { providerState: update.providerState } : {}),
-          // #2034 (#2031 L3): stamp/preserve each background task's startedAt — the hook
+          // stamp/preserve each background task's startedAt — the hook
           // can only ever report the current snapshot, so age has to be tracked here,
           // against the prior background-script work record. Pure merge lives in
           // background-script-reconcile.ts beside this record's other reconcile logic.
@@ -2378,7 +2368,7 @@ export class AgentRunner {
         },
       });
       // A busy report with liveness-trackable pids arms the periodic reconcile (self-disarms
-      // once no pid-bearing work remains, so idle/untracked agents pay nothing). #1856 — a
+      // once no pid-bearing work remains, so idle/untracked agents pay nothing). — a
       // `background-script` busy also arms it, even with no pids: it is the ONLY signal that ever
       // runs the no-pid stale backstop that unwedges a leftover background-script (Claude's hook
       // can never supply pids for CC background tasks).
@@ -2392,7 +2382,7 @@ export class AgentRunner {
       else this.claims.finishWork(reason, id);
       if (reason === "provider-turn" && !providerRefusedTurn) {
         this.taskClaims.completeObservedTaskClaims().catch((error) => logger.error("task", `completion enqueue failed: ${error}`));
-        // #2619 — the provider took a turn: the hold episode ends, parked input goes out. Not while
+        // the provider took a turn: the hold episode ends, parked input goes out. Not while
         // a hold is still standing or pending (a pane-detected wall can land before its turn's idle):
         // the published hold names this episode and its wake must still act.
         if (!this.rateLimitHold && !this.pendingRateLimitHold) {
@@ -2407,7 +2397,7 @@ export class AgentRunner {
       for (const kind of update.clear ?? []) this.claims.clearWorkKind(kind);
     }
     if (!this.claims.activeWork().some((work) => work.kind === "provider-turn")) this.busyReconciler.providerTurnCleared();
-    // #329: the provider just went idle (ready). If a first initial-prompt delivery timed out on
+    // the provider just went idle (ready). If a first initial-prompt delivery timed out on
     // a cold-start TUI, re-attempt now — the ready wait should resolve almost immediately.
     if (status === "idle") this.promptCommands.retryInitialPrompt();
     if (status === "idle" && this.pendingRateLimitHold && !this.claims.activeWork().some((work) => work.kind === "provider-turn")) {
@@ -2418,7 +2408,7 @@ export class AgentRunner {
       this.rateLimitHold = { ...hold, holdEpisodeId: this.hold.refused() };
       if (fresh) this.publishRateLimitNotice(hold);
     }
-    // #1146: native self-resume is invoked by the agent itself mid-turn (a tool call from
+    // native self-resume is invoked by the agent itself mid-turn (a tool call from
     // within its own active response), so the very next idle is almost always the CALLING
     // turn's own natural end — long before Claude Code even starts processing the queued
     // `/compact <continuation>`. Resolving on any idle here raced that unrelated end against
@@ -2433,9 +2423,9 @@ export class AgentRunner {
     this.publishStatus();
   }
 
-  // #2919 — Claude runs a prompt it queued during the turn's end without a UserPromptSubmit of its own.
+  // Claude runs a prompt it queued during the turn's end without a UserPromptSubmit of its own.
   // The ended turn is settled above; mint the queued turn now. Its tail starts with no turn id so its
-  // steps carry Claude's fresh prompt id, the id its final gets from the Stop (#1086).
+  // steps carry Claude's fresh prompt id, the id its final gets from the Stop.
   private openQueuedTurn(): void {
     this.sessionLog("prompt queued behind the turn end — opening its turn");
     this.setProviderStatus({ status: "busy", reason: "provider-turn" });
@@ -2460,22 +2450,22 @@ export class AgentRunner {
     return true;
   }
 
-  // #417: when a provider finishes a turn with a pending spawner obligation still
+  // when a provider finishes a turn with a pending spawner obligation still
   // unresolved, re-inject the obligation as a synthetic message so providerMessageText
   // surfaces the specific `humwick /reply <id>` command.
   private async reInjectPendingObligation(): Promise<void> {
     // Filter to spawner obligations only — user obligations go through the existing
-    // prompt-capture path (publishProviderSessionEvent) and the session mirror (#418), never
+    // prompt-capture path (publishProviderSessionEvent) and the session mirror, never
       // an explicit /reply. Shared predicate so this rule stays in lockstep with
       // the stop-hook nag exemption (control-server.replyObligationStopDecision).
     const obligations = (await this.obligationCache.freshForNag()).filter(obligationNagEligible);
     if (!this.process) return;
-    // #2619 — no re-injection into a provider hold: it would only be refused.
+    // no re-injection into a provider hold: it would only be refused.
     if (this.rateLimitHold || this.hold.activeEpisode) return;
     if (!obligations.length) return;
     const MAX_REINJECTIONS = 3;
     for (const obligation of obligations) {
-      // #2029 — the obligation carries the server's delivery decision. A non-`turn` obligation (wake:false
+      // the obligation carries the server's delivery decision. A non-`turn` obligation (wake:false
       // / session) must never be re-surfaced as a turn nudge: this re-injection path builds a synthetic
       // frame and calls `adapter.deliver` directly, BYPASSING the fanout seam, so the decision that would
       // otherwise be lost to the `payload: {}` reconstruction is honored explicitly here instead.
@@ -2504,8 +2494,8 @@ export class AgentRunner {
       // by the RELAY_INJECTION_MARKERS prefix check, but record it explicitly as
       // defense-in-depth for adapters that might echo only the unformatted body text.
       this.recordInjectedPrompt(providerMessageText([replayMessage]));
-      // #1607 N1 — route through the FIFO like every other deliver/deliverInitialPrompt call site.
-      // #2389 — a re-injected obligation is the runner asking for work the agent still owes, so it
+      // N1 — route through the FIFO like every other deliver/deliverInitialPrompt call site.
+      // a re-injected obligation is the runner asking for work the agent still owes, so it
       // arms — but as a RETRY, not a fresh ladder arm. This fires up to MAX_REINJECTIONS times per
       // message; opening a new strike budget each time would let one message earn four nudges and
       // keep consecutiveEmpty below the escalation threshold indefinitely, on exactly the agents
@@ -2513,7 +2503,7 @@ export class AgentRunner {
       const arm = this.emptyTurns.armInput(Date.now(), "retry", true);
       let held = false;
       try {
-        // #2619 — a refused re-injection spends no attempt and leaves the obligation standing.
+        // a refused re-injection spends no attempt and leaves the obligation standing.
         await this.offerMessagesToProvider(() => [replayMessage], () => {
           held = true;
           this.pendingObligationInjections.set(obligation.messageId, count);
@@ -2536,9 +2526,9 @@ export class AgentRunner {
     }
   }
 
-  // A hook reported an unhandled failure (#198 seam). Already logged FATAL by the control
+  // A hook reported an unhandled failure. Already logged FATAL by the control
   // server; here we additionally surface it durably to the server as a generic insight so
-  // it shows up in observability rather than only in the per-agent log (#196).
+  // it shows up in observability rather than only in the per-agent log.
   private reportHookFatal(report: { hook: string; error: string }): void {
     try {
       this.insights.queueHookFatal(report);
@@ -2592,7 +2582,7 @@ export class AgentRunner {
     const work = this.claims.activeWork().find((w) => w.kind === "provider-turn");
     if (!work) return;
     this.sessionLog(`force-clearing stuck provider-turn (${reason})`);
-    // #2389 — the OTHER producer of `agent.turn_interrupted`, and the same reason the interrupt
+    // the OTHER producer of `agent.turn_interrupted`, and the same reason the interrupt
     // command resets: a force-cleared turn ended with no output through no fault of the model, and
     // that state already has its own notice. Resetting also drops the turn record this path would
     // otherwise leave open forever, which would wedge the timed backstop.
@@ -2603,12 +2593,12 @@ export class AgentRunner {
     this.busyReconciler.providerTurnCleared();
     this.currentTurnId = undefined;
     this.compactionMidTurn = false;
-    // #1621: the clear is EMITTED, not silently applied — publishRunnerTimelineEvent publishes
+    // the clear is EMITTED, not silently applied — publishRunnerTimelineEvent publishes
     // the status too, so the idle edge and its explanation travel in the same frame.
     this.publishRunnerTimelineEvent(event);
   }
 
-  // #2389 — the recovery. NOT a re-send: the instruction is already in the provider's session
+  // the recovery. NOT a re-send: the instruction is already in the provider's session
   // history (which is why the stranded agent ran its original spawn prompt the moment a human typed
   // "hello" at it hours later), so this carries no copy of it. Delivered with origin "runner" so it
   // does NOT arm the ledger — a nudge that armed a fresh nudge budget would loop without bound
@@ -2633,7 +2623,7 @@ export class AgentRunner {
     }
   }
 
-  // #1980 U2 — the busy backstop has HELD a live provider turn past its prolonged-hold threshold
+  // U2 — the busy backstop has HELD a live provider turn past its prolonged-hold threshold
   // instead of cancelling it (a frozen-active `shell` gate, or a pane-scrape-only long tool the
   // runner cannot positively prove idle). Emit a NOTIFY-ONLY watchdog: the turn is untouched (the
   // card stays busy, no work-kind is cleared, currentTurnId is preserved) — this only tells a
@@ -2650,13 +2640,13 @@ export class AgentRunner {
     }));
   }
 
-  // #650: reconcile pid-bearing busy work against actual process liveness. A tracked
+  // reconcile pid-bearing busy work against actual process liveness. A tracked
   // command/shell that dies out-of-band (killed by the operator, crashes, orphaned)
   // sends no exit event, so its busy marker would otherwise never clear and the agent
   // shows `busy` forever — blocking transient auto-reap and holding provider quota.
-  // #1856 — this timer ALSO runs the no-pid `background-script` backstop: Claude's Stop
+  // this timer ALSO runs the no-pid `background-script` backstop: Claude's Stop
   // hook can only post a pid-less `background-script` busy (its `background_tasks[]` payload
-  // exposes no OS pid), which #650's pid reconcile can never touch. So the timer is armed for
+  // exposes no OS pid), which the pid reconcile can never touch. So the timer is armed for
   // ANY background-script busy too, and stays armed while one exists. It self-disarms once
   // neither pid-bearing work nor a background-script busy remains, so idle agents pay nothing.
   private armBusyLivenessReconcile(): void {
@@ -2690,7 +2680,7 @@ export class AgentRunner {
         this.busyReconciler.providerTurnCleared();
       }
     }
-    // #1856 — the no-pid backstop: a leftover `background-script` busy that outlived its work
+    // the no-pid backstop: a leftover `background-script` busy that outlived its work
     // (background task finished or was killed manually) leaves the agent wedged busy forever,
     // because it carries no pid to reconcile and only the next turn's Stop hook would clear it.
     // Once the busy state is background-script ALONE (the provider turn already ended) and has
@@ -2736,7 +2726,7 @@ export class AgentRunner {
     });
   }
 
-  // #286: a discreet, durable chat marker when a usage/rate-limit hold begins, via
+  // a discreet, durable chat marker when a usage/rate-limit hold begins, via
   // the same session-mirror lane as the compaction notice. Outbound session event
   // (NOT an inbound message) so it shows in the dashboard chat WITHOUT waking a turn
   // — waking a still-limited agent would just re-fail. The relay sends the waking
@@ -2761,10 +2751,10 @@ export class AgentRunner {
     if (activeWork.length === 0 || activeWork.some((work) => work.kind !== "provider-turn")) return false;
     if (busyReasons.some((reason) => reason !== "provider-turn")) return false;
     if (liveness.hasLiveWork || !liveness.lastProgressAt) return false;
-    // #1138: a turn whose tracked pid is still alive is definitively still running — a
+    // a turn whose tracked pid is still alive is definitively still running — a
     // silent single Claude turn (no subagents, no compaction event) must not be
     // force-healed to idle purely because it's been quiet past the threshold. Only fall
-    // back to the elapsed-time heuristic when there's no pid evidence to check; the #650
+    // back to the elapsed-time heuristic when there's no pid evidence to check; the
     // reconcile independently clears a confirmed-dead pid's work the instant it dies, so
     // this can never mask a genuine leak.
     if (activeWork.some((work) => work.pids?.some((pid) => isPidAlive(pid)))) return false;
@@ -2779,16 +2769,16 @@ export class AgentRunner {
     const activeSubagents = activeWork.filter((item) => item.kind === "subagent");
     const terminalFailure = this.terminalFailure;
     const timelineEvent = this.pendingTimelineEvent;
-    // §4.1 Runner↔provider liveness contract (#725 / #746): fold the raw transport/timeline/
+    // §4.1 Runner↔provider liveness contract: fold the raw transport/timeline/
     // token/work-kind signals into ONE normalized verdict the server reads instead of six raw
-    // `meta` fields. The adapter owns what counts as progress for its provider (#713/#724);
+    // `meta` fields. The adapter owns what counts as progress for its provider;
     // mock adapters fall back to the shared fold.
     const livenessInputs: LivenessInputs = {
       transport: this.bus.transportState,
       ...(this.lastProviderEventAt !== undefined ? { lastProviderEventAt: this.lastProviderEventAt } : {}),
       ...(timelineEvent ? { timelineEvent } : {}),
       activeWork,
-      // #1980 U3 — feed the runner's coarse status + provider-hold flag so the fold can derive
+      // U3 — feed the runner's coarse status + provider-hold flag so the fold can derive
       // busyPhase (active/passive/blocked) beside hasLiveWork, provider-agnostically.
       providerStatus: status,
       providerBlocked: this.providerBlocked || this.startupPaneDialog !== undefined || this.deliverySubmitHold !== undefined,
@@ -2808,7 +2798,7 @@ export class AgentRunner {
     const agentStatus = teardownLifecycle && effectiveStatus !== "offline" && effectiveStatus !== "error"
       ? "idle"
       : runnerAgentStatus(effectiveStatus);
-    // #2389 — `emptyTurnState` is the LAST fallback: a live hold, a pending question or real active
+    // `emptyTurnState` is the LAST fallback: a live hold, a pending question or real active
     // work all describe the agent better than "the previous turn was empty", and any of them means
     // it is no longer sitting idle having produced nothing.
     const providerState = this.deliverySubmitHold ?? terminalFailure?.providerState ?? this.startupPaneDialog ?? this.rateLimitHold ?? this.pendingQuestionHold
@@ -2827,30 +2817,30 @@ export class AgentRunner {
           terminalFailureReason: terminalFailure.reason,
           terminalFailureMessage: terminalFailure.message,
         } : {}),
-        // #633 — terminal provider-exit marker (runner alive, provider gone). Drives the server's
-        // silent-death terminal event + #636 post-mortem.
+        // terminal provider-exit marker (runner alive, provider gone). Drives the server's
+        // silent-death terminal event + post-mortem.
         ...(this.terminalProviderExit ? {
           terminalProviderExit: this.terminalProviderExit,
           lastError: providerExitLastError(this.options.provider, this.terminalProviderExit),
         } : {}),
         busyReasons: staleProviderTurnBusy ? busyReasons.filter((reason) => reason !== "provider-turn") : busyReasons,
         completedProviderTurns: this.completedProviderTurns,
-        // #2389 — machine-readable beside the displayed providerState, so a coordinator polling the
+        // machine-readable beside the displayed providerState, so a coordinator polling the
         // roster can tell "idle having produced nothing" from "idle having finished work" without
         // reading the timeline. 0 once any turn produces output again.
         consecutiveEmptyTurns: this.emptyTurns.consecutiveEmptyTurns(),
-        unreportedTokenUsage: this.tokenUsageCoverage.unreported, // #3351
+        unreportedTokenUsage: this.tokenUsageCoverage.unreported,
         activeWork,
         activeSubagents,
         activeSubagentCount: activeSubagents.length,
         ...(this.lastProviderEventAt !== undefined ? { lastProviderEventAt: this.lastProviderEventAt } : {}),
         providerState,
-        // #2365 — this is a one-shot marker. An explicit null lets Relay's merge-patch status
+        // this is a one-shot marker. An explicit null lets Relay's merge-patch status
         // ingress delete the previously consumed event on the next frame instead of auditing the
         // same latched watchdog transition for every subsequent provider update.
         timelineEvent: timelineEvent ?? null,
         transport: this.bus.transportState,
-        // #746 — normalized liveness verdict; the server reads ONLY this for stuck-busy.
+        // normalized liveness verdict; the server reads ONLY this for stuck-busy.
         // The raw fields above stay for other consumers (timeline rendering, diagnostics).
         liveness,
       },
@@ -2860,8 +2850,6 @@ export class AgentRunner {
     if (published && this.pendingTimelineEvent === timelineEvent) this.pendingTimelineEvent = undefined;
   }
 
-  private startLiveness(): void { this.liveness.start(); }
-
   private logRunnerDiagnostic(message: string): void { this.context.logRunnerDiagnostic(message); }
   private sessionLog(message: string): void { this.context.sessionLog(message); }
   private sessionDebug(message: string): void { this.context.sessionDebug(message); }
@@ -2873,14 +2861,13 @@ export class AgentRunner {
         cwd: this.options.cwd,
         fallbackBaseDir: orchestratorBaseDirFromEnv(),
       });
+      this.registrationMeta.scratchDir = this.scratch.tmpDir;
     } catch (error) {
       this.logRunnerDiagnostic(`session scratch setup failed: ${errMessage(error)}`);
     }
   }
 
-  private scheduleAttachmentCacheSweep(): void { this.attachmentCacheSweep.start(); }
-
-  // #1245 — a newly allowed tool group or scope reaches the next generation without a restart.
+  // a newly allowed tool group or scope reaches the next generation without a restart.
   private remintRuntimeTokenAtBoundary(reason: "clear" | "compact"): Promise<Record<string, unknown>> {
     return this.credentials.remintRuntimeTokenAtBoundary(reason);
   }
@@ -2890,7 +2877,7 @@ export class AgentRunner {
     const probeMetrics = this.latestProbeMetrics();
     const probeContext = probeMetrics ? contextStateFromProbeMetrics(probeMetrics) : undefined;
     let context = processContext ?? probeContext;
-    // #1512: when a provider has no event-stream context of its own, fall back to
+    // when a provider has no event-stream context of its own, fall back to
     // the transcript so context.lastUpdatedAt keeps advancing after an in-process
     // compact/clear/native-resume freezes the status-line probe. Freshest wins, so
     // a live probe still takes precedence (source stays "statusline").
@@ -2900,7 +2887,7 @@ export class AgentRunner {
         context = derived;
       }
     }
-    // #2095 test rig — override the reported context with the forced synthetic while the one-shot
+    // test rig — override the reported context with the forced synthetic while the one-shot
     // latch is armed. Applied AFTER the real context is resolved (so tokensMax/window carry over) and
     // BEFORE providerCapabilities + meta.context are built from it, so the server ingests the forced
     // utilization and its REAL lifecycle tick drives the REAL advisory + forced clear-inject.