@humwick/runner 0.130.4 → 0.130.6

package/src/adapters/claude.ts

@@ -43,7 +43,7 @@ type MonitorlessTurnWatchDeps = {
 };
 
 export class ClaudeAdapter implements ProviderAdapter {
-  // #2513 — provider-id-dynamic (the id-parameterized OpenCodeAdapter pattern): the
+  // provider-id-dynamic (the id-parameterized OpenCodeAdapter pattern): the
   // claude-b provider reuses this adapter whole, launching the same binary through the
   // same wiring under its own id/home/credential. Everything that identified "claude"
   // flows from this id; the launch assemblies/profile homes key off it the same way.
@@ -54,37 +54,37 @@ export class ClaudeAdapter implements ProviderAdapter {
   readonly permissionPromptHandler = claudePermissionPromptHandler;
   readonly compactSupportsInstructions = false;
   readonly compactReportsSubmission = true;
-  // #1588 — Claude's clearContext is a fire-and-forget tmux `/clear` keystroke with no structured
+  // Claude's clearContext is a fire-and-forget tmux `/clear` keystroke with no structured
   // completion barrier, so the self-resume continuation MUST be delivered in-process coupled to the
   // clear command (after waitForClaudeInputReady settles it) instead of via a separate inject that
   // would race the still-processing async clear. Codex omits this (atomic awaited threadStart).
   readonly couplesClearInjectContinuation = true;
-  // #2043 F1 — Claude's /compact and /clear are blind tmux keystrokes with no delivery handshake:
+  // F1 — Claude's /compact and /clear are blind tmux keystrokes with no delivery handshake:
   // submitted mid-turn they queue behind the live turn and dequeue as literal chat (never parsed as
   // slash commands), so the compaction silently no-ops. The runner gates the submit on the live
   // provider turn clearing so the keystrokes always land on an idle prompt. Codex omits this
   // (awaited app-server handshake — the await is the barrier).
   readonly awaitsIdleBeforeContextCommand = true;
-  // #352: initial prompt is seeded as Claude's positional launch arg (buildSpawnArgs) — reliable,
+  // initial prompt is seeded as Claude's positional launch arg (buildSpawnArgs) — reliable,
   // no send-keys/onboarding race; tells the runner to skip the redundant post-launch delivery.
   readonly seedsInitialPromptAtLaunch = true;
   private readonly monitorlessTurnWatch: MonitorlessTurnWatchDeps;
   private statusCb: (status: ProviderStatusUpdate) => void = () => {};
-  // #1651 — the pane watcher's ONLY outbound channel for anything it inferred from pane text.
+  // the pane watcher's ONLY outbound channel for anything it inferred from pane text.
   // Pane observations cannot end work or send input. A startup modal may carry only
   // a display gate, which the runner publishes as a badge and timeline event.
   private paneObservationCb: (observation: PaneObservation) => void = () => {};
   private tmuxWatcher?: Timer; private turnWatcher?: Timer;
   private turnWatchResume?: { process: ManagedProcess; sessionName: string; socketName?: string };
   private statusWatchersStopped = false;
-  // #1838 review HIGH-1 — monotonic turn-watch generation. Captured when a monitorless
+  // review HIGH-1 — monotonic turn-watch generation. Captured when a monitorless
   // turn-watch is armed and bumped by stopTurnWatch(); the async setup and every in-flight
   // tick re-check it after each await and before any state mutation / status emit, so a
   // shutdown or a replacement invalidates a predecessor's setup AND its outstanding ticks. The
   // pane watcher fences on Timer identity (`this.tmuxWatcher !== watcher`) instead — the same
   // guarantee, checked after every await there.
   private turnWatchGen = 0;
-  // #1838 review MED — the pane pid resolved OFF the loop once per spawn and cached, so the
+  // review MED — the pane pid resolved OFF the loop once per spawn and cached, so the
   // synchronous resolveBusyPid() (called inline from the runner core on every provider-turn
   // busy edge) can answer without a blocking tmux display-message spawn. undefined until the
   // async resolve lands (graceful: the runner falls back to its other liveness signals).
@@ -94,13 +94,13 @@ export class ClaudeAdapter implements ProviderAdapter {
   private startupReadyObserved = false;
   private startupBypassDialogActive = false;
   private startupOpenApproval = false;
-  // #1621 — when relay LAST typed a turn-cancelling keystroke into the managed pane itself. A
+  // when relay LAST typed a turn-cancelling keystroke into the managed pane itself. A
   // probe whose last write predates this cannot be describing the state after the cancellation,
-  // so its busy verdict stops being authoritative at once. #1651 removed the prompt gate's
+  // so its busy verdict stops being authoritative at once. Removed the prompt gate's
   // auto-Escape, so the sole remaining writer is the explicit `interrupt()` command — a
   // deliberate, operator/runner-initiated cancel, not something inferred from pane text.
   private paneInterruptAt?: number;
-  // #1647 — provider epoch: bumped on every spawn, stamped into the ManagedProcess and
+  // provider epoch: bumped on every spawn, stamped into the ManagedProcess and
   // into any shutdown intent minted for it. A shutdown request that outlives a restart
   // therefore cannot authorize typing `/exit` into the replacement session.
   private providerEpoch = 0;
@@ -124,7 +124,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   private readonly sessionCapture = new ClaudeSessionCapture();
   private tokenUsageCapture?: ClaudeTranscriptTokenUsageCapture;
   private tokenUsageReporter?: ProviderTokenUsageReporter;
-  // #2491 — dedupes the empty-pass INFO log to once per turn: a turn's own capture pass (and
+  // dedupes the empty-pass INFO log to once per turn: a turn's own capture pass (and
   // any mid-turn permission pre-flush pass) can otherwise post 0 entries repeatedly for the
   // same turn while its JSONL flush is still in flight.
   private lastEmptyTokenUsageLogTurnKey?: string;
@@ -152,7 +152,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       const transcriptPath = input.transcriptPath;
       const turnKey = ctx.turnId ?? input.promptId ?? transcriptPath;
       void this.tokenUsageCapture.capture(transcriptPath).then((postedCount) => {
-        // #2491 — an empty pass previously logged nothing at all; a turn's own one-shot
+        // an empty pass previously logged nothing at all; a turn's own one-shot
         // capture racing the JSONL flush is exactly the condition this fix addresses, so it
         // must be visible at INFO without flipping log level (see also the reportFailure
         // wiring in runner-core.ts, moved off DEBUG for the same reason).
@@ -173,7 +173,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   }
 
   async captureFinalTokenUsage(transcriptPath: string | undefined, ctx: ProviderSessionTurnContext): Promise<void> {
-    // #2484 round 2 review (MED-1) — this adapter owns the transcript-presence bail now
+    // round 2 review (MED-1) — this adapter owns the transcript-presence bail now
     // (previously lived in the shared runner-core seam, which made it Claude-shaped for every
     // adapter): Claude's capture tails a JSONL transcript file, so it has nothing to settle
     // without a real path.
@@ -192,7 +192,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     this.paneObservationCb = cb;
   }
 
-  // §4.1 contract verdict (#746). Claude reference (#713): Claude is token-silent during
+  // §4.1 contract verdict. Claude reference: Claude is token-silent during
   // native compaction, but the runner publishes a `compacting` timeline transition while it
   // runs — so `timelineEvent.timestamp` (folded into lastProgressAt) keeps a compacting Opus
   // turn reading as progressing instead of wedged. Transport frames/acks + the server's
@@ -211,7 +211,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     return hydrateClaudeHostConfig(config, this.provider);
   }
 
-  async spawn(config: RunnerSpawnConfig): Promise<ManagedProcess> {
+  async spawn(config: RunnerSpawnConfig, preparedArgs?: SpawnArgs): Promise<ManagedProcess> {
     // A provider spawn is the adapter incarnation boundary on both tmux/headless and direct
     // interactive paths. Invalidate predecessor watchers before reopening the new incarnation,
     // but retain the stopped predecessor's resume descriptor if spawn itself throws: runner-core
@@ -223,7 +223,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     this.statusWatchersStopped = false;
     try {
       await verifyClaudeSubagentVersion(config);
-      const hydratedConfig = await this.hydrateSpawnConfig(config); const args = this.buildSpawnArgs(hydratedConfig, hydratedConfig.providerConfig as ProviderConfig);
+      const hydratedConfig = preparedArgs ? config : await this.hydrateSpawnConfig(config); const args = preparedArgs ?? this.buildSpawnArgs(hydratedConfig, hydratedConfig.providerConfig as ProviderConfig);
       if (hydratedConfig.headless) return this.spawnHeadless(hydratedConfig, args);
 
       const proc = Bun.spawn([args.command, ...args.args], {
@@ -261,25 +261,25 @@ export class ClaudeAdapter implements ProviderAdapter {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
     if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for clear");
-    // #1588 — snapshot the pane BEFORE submitting `/clear` so the clear-aware barrier can detect
+    // snapshot the pane BEFORE submitting `/clear` so the clear-aware barrier can detect
     // the loaded conversation body disappearing (positive clear-commit evidence), not just the
     // ever-present footer. Best-effort: a capture failure just yields no anchor → clearConfirmed
     // falls to false → backstop covers.
-    // #2261 — VISIBLE screen only. The old `-S -80` capture snapshotted 80 lines of tmux
+    // VISIBLE screen only. The old `-S -80` capture snapshotted 80 lines of tmux
     // scrollback too, and `/clear` repaints only the visible screen (it never emits the `ESC[3J`
     // that would drop history), so the anchor picked out of scrollback was still there after the
-    // clear committed and the barrier below could never confirm it (the #2261 false negative).
+    // clear committed and the barrier below could never confirm it.
     let preClearPane = "";
     let preClearCaptured = false;
     try { preClearPane = await CLAUDE_CLEAR_COMMIT_CAPTURE(session, socket); preClearCaptured = true; } catch {}
-    // #2261 — the PRIMARY, machine-readable clear-commit signal: Claude mints a new session
+    // the PRIMARY, machine-readable clear-commit signal: Claude mints a new session
     // (new sessionId, new transcript file) the moment `/clear` commits. Snapshot the current one
     // first, pid-pinned, so the barrier can watch for the rotation. Best-effort: an unavailable
     // probe (pre-2.1.119, unresolvable config home) just leaves the barrier on its pane heuristic.
     const readSession = await bindClaudeClearSessionReader(process, session, socket);
     const preClearSession = readSession ? await readSession() : null;
     await submitClaudeContextCommand(session, "/clear", socket);
-    // #1588 — `/clear` is async in the Claude TUI: submitTextToTmux returns as soon as the keys
+    // `/clear` is async in the Claude TUI: submitTextToTmux returns as soon as the keys
     // are typed, before the conversation is actually cleared. The self-resume continuation used to
     // race this still-processing clear (a separate command, ~8ms later, on a different transport)
     // and get swallowed — a silent mind-wipe. The OLD barrier (waitForClaudeInputReady) accepted
@@ -287,13 +287,13 @@ export class ClaudeAdapter implements ProviderAdapter {
     // could return before the clear committed. Use the CLEAR-AWARE barrier instead: it requires
     // positive evidence the clear committed (pane idle + input-ready + the pre-clear conversation
     // anchor gone). `clearConfirmed` is surfaced to the coupled deliver: only a genuine confirmation
-    // permits continuationDelivered:true; a timeout/uncertain settle → false → the relay's #1023
+    // permits continuationDelivered:true; a timeout/uncertain settle → false → the relay's
     // backstop re-injects. Never throws (the clear already ran); uncertainty resolves to false.
     const clearConfirmed = await waitForClaudeClearCommitted(session, preClearPane, CLAUDE_TMUX_READY_TIMEOUT_MS, socket, { preClearSession, readSession, preClearCaptured });
     return { method: "tmux-inject", command: "/clear", clearConfirmed };
   }
 
-  // #1512: Claude reports context only through its out-of-band status-line probe,
+  // Claude reports context only through its out-of-band status-line probe,
   // which freezes after an in-process compact/clear/native-resume. The transcript
   // (handed to the runner every turn by the Stop hook) carries the same per-turn
   // token usage, so the runner reads it here as a probe-independent fallback that
@@ -305,9 +305,9 @@ export class ClaudeAdapter implements ProviderAdapter {
     const socket = process.meta?.tmuxSocket as string | undefined;
     if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session to interrupt");
     // The same ESC the web terminal's aux key sends: cancels the in-flight turn
-    // and drops Claude back to its input box without ending the session. #1621: mark the probe's
+    // and drops Claude back to its input box without ending the session. Mark the probe's
     // pre-cancel busy verdict non-authoritative so the runner's post-interrupt reconcile can see
-    // the idle pane when the cancel writes no probe transition (a `shell` rewrite is idle, #2202).
+    // the idle pane when the cancel writes no probe transition (a `shell` rewrite is idle).
     this.paneInterruptAt = Date.now();
     const result = spawnSyncBounded(tmuxCommand(socket, "send-keys", "-t", session, "Escape"), {
       stdin: "ignore", stdout: "ignore", stderr: "pipe",
@@ -322,25 +322,25 @@ export class ClaudeAdapter implements ProviderAdapter {
   async probeActivity(process: ManagedProcess): Promise<"busy" | "idle" | "unknown"> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
-    // #1838 row 14 — the busy reconciler drives this every 4s while busy; its has-session
+    // row 14 — the busy reconciler drives this every 4s while busy; its has-session
     // + probe read + pane fallback now run off the event loop. A non-`present` presence
     // (absent OR an unreadable wedged read) yields "unknown", the safe hold value — the
-    // reconciler treats unknown as non-idle and never clears a live turn on it (#1838 HIGH-2).
+    // reconciler treats unknown as non-idle and never clears a live turn on it.
     if (!session || (await tmuxSessionPresence(session, socket)) !== "present") return "unknown";
-    // #1980 U2 — the busy BACKSTOP consumer: when the intrinsic probe is unavailable, a bare
+    // U2 — the busy BACKSTOP consumer: when the intrinsic probe is unavailable, a bare
     // input-ready pane is NOT proof the turn ended (a long foreground tool renders the same box),
     // so it must read as `unknown` (hold), never `idle` (force-cancel). paneFallbackIsIdle:false
     // opts this path out of the legacy pane-scrape idle the turn-watch below still relies on.
     return this.activityFromProbeOrPane(process, session, socket, { paneFallbackIsIdle: false });
   }
 
-  // #1138: a tmux-launched Claude session's ManagedProcess carries no direct OS pid
-  // (process.pid is undefined — only the tmux session/socket), so the runner's #650
+  // a tmux-launched Claude session's ManagedProcess carries no direct OS pid
+  // (process.pid is undefined — only the tmux session/socket), so the runner's
   // pid-liveness fallback had nothing to check for an ordinary hook-driven turn. Resolve
   // the tmux pane's real pid so a long, quiet (no subagents, no compaction) busy turn can
   // prove it is still alive instead of being force-healed to idle by the runner's
   // stale-progress backstop purely because 10 minutes passed with no interim signal.
-  // #1838 review MED — this is a SYNCHRONOUS adapter-interface method the runner core calls
+  // review MED — this is a SYNCHRONOUS adapter-interface method the runner core calls
   // inline on every provider-turn `busy` edge, so it must never spawn: the old
   // resolveClaudePid() shelled out to `tmux display-message` (up to a 10s block on a wedged
   // socket) on that hot edge. It now returns the direct OS pid when there is one, else the pane
@@ -353,19 +353,19 @@ export class ClaudeAdapter implements ProviderAdapter {
     return this.tmuxPanePid;
   }
 
-  // Shared probe-primary / pane-fallback activity read (#766/#768), used by both the
+  // Shared probe-primary / pane-fallback activity read, used by both the
   // reconciler-facing probeActivity and the monitorless turn-watch. Primary: Claude
   // Code's intrinsic session probe (busy→busy — the idle-while-working gap the
   // pane-scrape misread; idle/shell→idle; waiting→unknown, a parked turn the backstop must
   // not force-clear). Legacy fallback: scrape the tmux pane (pre-2.1.119 / probe missing).
   private async activityFromProbeOrPane(process: ManagedProcess, session: string, socket?: string, opts: { paneFallbackIsIdle?: boolean } = {}): Promise<ClaudeProbeActivity> {
-    // #1838 rows 14/15 — every subprocess/fs read on this path (pane-pid resolve, probe JSON
+    // rows 14/15 — every subprocess/fs read on this path (pane-pid resolve, probe JSON
     // read, /proc liveness read, transcript stat, and the pane-scrape fallback) runs off the
     // event loop now. The verdict logic itself (claudeProbeVerdict / claudeActivityFromProbeAndPane)
     // is pure and unchanged.
     const managed = await readManagedClaudeStatusAsync(claudeProbeArgsFor(process, session, socket));
-    // #1621/#3026: a busy probe holds the turn unless relay's own interrupt postdates it; the
-    // transcript mtime (#1642) is only read then, to tell whether that cancel took.
+    // a busy probe holds the turn unless relay's own interrupt postdates it; the
+    // transcript mtime is only read then, to tell whether that cancel took.
     const paneInterruptAt = this.paneInterruptAt;
     const lastActivityAt = paneInterruptAt === undefined ? undefined : await claudeTranscriptMtimeMsAsync(managed?.reading, managed?.configHome);
     const { activity: probe, busyStale } = claudeProbeVerdict(managed?.reading, { paneInterruptAt, lastActivityAt });
@@ -375,22 +375,22 @@ export class ClaudeAdapter implements ProviderAdapter {
     return claudeActivityFromProbeAndPane(probe, pane, { probeBusyStale: busyStale, paneFallbackIsIdle: opts.paneFallbackIsIdle ?? true });
   }
 
-  // #769 P1-A: an independent pane-busy read consumed by the busy backstop — a probe-`idle`
+  // P1-A: an independent pane-busy read consumed by the busy backstop — a probe-`idle`
   // must never clear a live turn while the pane spinner still reads busy (a connection-retry/529
-  // can write status:idle mid-turn without tripping the rate-limit pane detector — the #769 gap).
+  // can write status:idle mid-turn without tripping the rate-limit pane detector — the gap).
   // probeActivity stays probe-primary; this is a corroboration channel only.
   //
-  // #1656: this used to answer `false` for all three of "captured, no spinner", "no tmux session"
+  // this used to answer `false` for all three of "captured, no spinner", "no tmux session"
   // and "capture threw", and the backstop read that single `false` as permission to clear a live
   // turn. A read that failed is a fact about the read, not about the provider — it is reported as
   // such now, and the backstop refuses to act on it.
   async probePaneBusy(process: ManagedProcess): Promise<PaneBusyReading> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
-    // #1838 row 14 — the reconciler's independent pane-busy corroboration read, off the loop.
+    // row 14 — the reconciler's independent pane-busy corroboration read, off the loop.
     // A wedged-but-live server (presence "unreadable") reports "unreadable" — which the
     // reconciler already treats as no-evidence and HOLDS on — rather than the false "no-session"
-    // a boolean has-session would have produced (#1838 HIGH-2).
+    // a boolean has-session would have produced.
     if (!session) return "no-session";
     const presence = await tmuxSessionPresence(session, socket);
     if (presence === "absent") return "no-session";
@@ -409,20 +409,20 @@ export class ClaudeAdapter implements ProviderAdapter {
     // connected" forever); we inject via tmux instead. For monitored profiles we keep the monitor
     // path (and its retry on transient startup races) to avoid double-delivering against a late monitor.
     if (process.meta?.monitorless === true || !monitor?.deliver) return this.deliverAsUserTurn(process, messages, ctx);
-    // #3415 — human chat goes in as a tmux user turn; without a tmux pane everything stays on Monitor.
+    // human chat goes in as a tmux user turn; without a tmux pane everything stays on Monitor.
     const userTurn = process.meta?.tmuxSession ? (batch: Message[]) => this.deliverAsUserTurn(process, batch, ctx) : undefined;
     return deliverClaudeByLane(messages, { userTurn, narrowTurnOpener: ctx?.narrowTurnOpener, monitor: (batch, reportsOffer) => this.deliverViaMonitor(process, monitor.deliver!.bind(monitor), batch, reportsOffer ? ctx : { ...ctx, inputObserver: undefined }) });
   }
 
   private async deliverViaMonitor(process: ManagedProcess, deliver: (messages: Message[]) => Promise<number[]>, messages: Message[], ctx?: ProviderDeliverContext): Promise<DeliverResult> {
-    // #1588 F2 edge 2 — for self-resume continuation deliveries, wait for the TUI to be input-ready
+    // F2 edge 2 — for self-resume continuation deliveries, wait for the TUI to be input-ready
     // first so the continuation never lands into a not-yet-settled post-clear context. The coupled
     // clearContext clear-aware barrier is the authoritative clear-commit gate; this belt-and-
     // suspenders settle also protects the SEPARATE relay-backstop inject. Best-effort: a settle
     // timeout must not fail the delivery — the backstop path already IS the recovery.
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
-    // #1838 review — only skip the settle when the session is positively `absent`.
+    // review — only skip the settle when the session is positively `absent`.
     if (session && messagesAreSelfResumeContinuation(messages) && (await tmuxSessionPresence(session, socket)) !== "absent") {
       await waitForClaudeInputReady(session, CLAUDE_TMUX_READY_TIMEOUT_MS, socket).catch(() => {});
     }
@@ -434,7 +434,7 @@ export class ClaudeAdapter implements ProviderAdapter {
 
   // Type the batch into the interactive tmux session as a real user turn — the transport
   // deliverInitialPrompt uses. Keeps the agent on interactive Claude (the user's Max quota), never
-  // `claude -p`/API; carries human chat (#3415) and every message of a monitorless profile.
+  // `claude -p`/API; carries human chat and every message of a monitorless profile.
   private async deliverAsUserTurn(process: ManagedProcess, messages: Message[], ctx?: ProviderDeliverContext): Promise<DeliverResult> {
     const monitorless = process.meta?.monitorless === true;
     const { session, socket } = await this.paneReadyForInput(process);
@@ -442,8 +442,8 @@ export class ClaudeAdapter implements ProviderAdapter {
     // scaffolding (reply reminder, claim-task instruction) — the agent has no way to /reply or /claim.
     const text = claudeProviderMessageText(messages, { relaySurface: !monitorless }), imagePaths = providerAttachmentLocalPaths(messages);
     ctx?.recordSubmittedPrompt?.(text, imagePaths);
-    // #1838 Wave 2a — any tmux failure throws and deliver() propagates it unclassified; a tmux
-    // exit 0 is not proof of submission (#1844), which the #2664 submit confirmation settles.
+    // Wave 2a — any tmux failure throws and deliver propagates it unclassified; a tmux
+    // exit 0 is not proof of submission, which the submit confirmation settles.
     await this.submitUserPromptToTmux(process, session, text, socket, imagePaths, ctx?.inputObserver);
     // Monitorless = no Stop/UserPromptSubmit hooks, so the runner gets no turn
     // lifecycle and never marks the claimed task done (the way Codex's app-server
@@ -465,22 +465,22 @@ export class ClaudeAdapter implements ProviderAdapter {
     if (this.statusWatchersStopped) return;
     this.stopTurnWatch();
     this.turnWatchResume = { process, sessionName, ...(socketName ? { socketName } : {}) };
-    // #1838 review HIGH-1 — the generation this watch owns. stopTurnWatch() just bumped it; a
+    // review HIGH-1 — the generation this watch owns. stopTurnWatch just bumped it; a
     // later stop/replace bumps it again, so every await below re-checks `gen === this.turnWatchGen`
     // before touching shared state or emitting a status. A shutdown DURING the async setup, or an
     // in-flight predecessor tick finishing after a successor is armed, is thereby fenced out.
     const gen = this.turnWatchGen;
-    // #769 P2-C: feed the resolved claude pid into the provider-turn liveness pids
-    // so #650's pid-liveness reconcile arms for headless/monitorless turns too (the
+    // P2-C: feed the resolved claude pid into the provider-turn liveness pids
+    // so the pid-liveness reconcile arms for headless/monitorless turns too (the
     // process itself isn't tracked here — pid is undefined for tmux-managed claude).
     // A dead pid means the turn is definitively over, so this can't falsely clear.
-    // #1838 row 15 — the per-turn-start pane-pid resolve + probe read run off the loop.
+    // row 15 — the per-turn-start pane-pid resolve + probe read run off the loop.
     const livenessPid = await this.monitorlessTurnWatch.resolvePanePid(process.pid, sessionName, socketName);
     // A numeric pid is not a process identity: an unrelated Claude can reuse it after this pane
     // exits. Pin /proc's start-time incarnation before accepting the asynchronous session probe.
     const paneIncarnation = livenessPid === undefined ? undefined : await this.monitorlessTurnWatch.processIncarnation(livenessPid);
     if (gen !== this.turnWatchGen) return;
-    // #1235 — monitorless workers have no Stop/UserPromptSubmit hooks, so the transcript
+    // monitorless workers have no Stop/UserPromptSubmit hooks, so the transcript
     // reasoning tail is never hook-triggered and chat stays empty. Resolve the live transcript
     // path from the intrinsic session probe (sessionId + cwd) and hand it to the runner on the
     // turn edges so it can drive the SAME reasoning tail natively. undefined on an old/absent
@@ -518,7 +518,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     let ticks = 0;
     let idleStreak = 0;
     let sawBusy = false;
-    // #1838 row 15 (shares row 14's fix) — the tick's activity read is now off-loop, so the
+    // row 15 (shares row 14's fix) — the tick's activity read is now off-loop, so the
     // body is an async IIFE. `inFlight` keeps a slow (now off-loop) probe from stacking a
     // second concurrent tick on the 1.5s timer.
     let inFlight = false;
@@ -529,7 +529,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         ticks += 1;
         const presence = await this.monitorlessTurnWatch.sessionPresence(sessionName, socketName);
         if (gen !== this.turnWatchGen) return; // superseded during the await — do not touch state
-        // #1838 HIGH-2: only a positive `absent` (or the safety cap) ends the watch. An
+        // HIGH-2: only a positive `absent` (or the safety cap) ends the watch. An
         // `unreadable` read (wedged-but-live server) HOLDS — never abandon a live turn on it.
         if (presence === "unreadable") return;
         if (presence === "absent" || ticks > CLAUDE_TURN_MAX_TICKS) {
@@ -563,9 +563,9 @@ export class ClaudeAdapter implements ProviderAdapter {
             this.statusCb({ status: "busy", reason: "provider-turn", id: CLAUDE_TURN_WATCH_ID, ...(livenessPid ? { pids: [livenessPid] } : {}), transcriptPath });
           }
         }
-        // #768: drive turn boundaries off the intrinsic probe (busy→busy, idle/shell→idle),
+        // drive turn boundaries off the intrinsic probe (busy→busy, idle/shell→idle),
         // falling back to the pane-scrape when the probe is unavailable. A foreground Bash
-        // gate reads busy; `shell` is a finished turn with a background task alive (#2202).
+        // gate reads busy; `shell` is a finished turn with a background task alive.
         const activity = await this.monitorlessTurnWatch.activity(process, sessionName, socketName);
         if (gen !== this.turnWatchGen) return; // superseded during the probe await
         if (activity === "busy") { sawBusy = true; idleStreak = 0; return; }
@@ -576,7 +576,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         const turnObserved = sawBusy || ticks >= CLAUDE_TURN_QUICK_GRACE_TICKS;
         if (confirmedIdle && turnObserved) {
           this.stopTurnWatch();
-          // Carry the transcript path on the idle edge too (#1235) so the runner can capture the
+          // Carry the transcript path on the idle edge too so the runner can capture the
           // turn's final assistant response natively before it tears down the reasoning tail.
           this.statusCb({ status: "idle", reason: "provider-turn", id: CLAUDE_TURN_WATCH_ID, ...(transcriptPath ? { transcriptPath } : {}) });
         }
@@ -585,7 +585,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   }
 
   private stopTurnWatch(): void {
-    // #1838 review HIGH-1 — bump the generation FIRST so any predecessor setup still awaiting,
+    // review HIGH-1 — bump the generation FIRST so any predecessor setup still awaiting,
     // or an in-flight tick, sees itself invalidated after its next await and neither emits a
     // status nor tears down a successor. Unconditional (not gated on this.turnWatcher) so a
     // stop DURING setup (before the interval exists) still invalidates that setup.
@@ -602,7 +602,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     await this.submitUserPromptToTmux(process, session, prompt, socket, options?.imagePaths, options?.inputObserver);
   }
 
-  // #1838 review — off-loop presence: only a positive `absent` proves there is no session; on
+  // review — off-loop presence: only a positive `absent` proves there is no session; on
   // `unreadable` the deadline-bounded waitForClaudeInputReady sorts it out rather than failing spuriously.
   private async paneReadyForInput(process: ManagedProcess, readyTimeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS): Promise<{ session: string; socket?: string }> {
     const session = process.meta?.tmuxSession as string | undefined;
@@ -622,17 +622,17 @@ export class ClaudeAdapter implements ProviderAdapter {
 
   private async submitUserPromptToTmux(process: ManagedProcess, session: string, text: string, socket?: string, imagePaths: string[] = [], inputObserver?: ProviderDeliverContext["inputObserver"]): Promise<void> {
     const resolveTranscriptPath = () => resolveManagedClaudeTranscriptPathAsync(claudeProbeArgsFor(process, session, socket));
-    // #2664 — the UserPromptSubmit hook confirms the submit; monitorless launches have no hooks.
+    // the UserPromptSubmit hook confirms the submit; monitorless launches have no hooks.
     await submitTextToTmux(session, text, socket, { confirmSubmit: true, transcriptPath: await resolveTranscriptPath().catch(() => undefined), resolveTranscriptPath, imagePaths, inputObserver, ...(process.meta?.monitorless === true ? {} : { promptHooks: this.sessionCapture.promptHooks }) });
   }
 
   buildSpawnArgs(config: RunnerSpawnConfig, providerConfig: ProviderConfig): SpawnArgs {
     // Create + bootstrap + auth-link the isolated config home (host base has none) so the
     // assembler's materialize step has somewhere to write the provisioned skills/plugins.
-    // #2254 — this also seeds folder trust into whichever config file THIS launch reads,
+    // this also seeds folder trust into whichever config file THIS launch reads,
     // including the shared host config on a host-base/profile-less spawn.
     prepareClaudeProfileHome(config, this.provider);
-    // #557 — ONE assembler owns the provisioning/vanilla/instruction launch surface
+    // ONE assembler owns the provisioning/vanilla/instruction launch surface
     // (--setting-sources, --plugin-dir, --mcp-config, status-line, --append-system-prompt);
     // profile-projection describes the SAME assembled result, so report == launch. The
     // adapter only adds the bits the assembler does not own: launch command resolution,
@@ -645,10 +645,10 @@ export class ClaudeAdapter implements ProviderAdapter {
     const providerArgs = claudeCallerAppends(config.headless
       ? claudeLaunchArgs(defaultArgs, config.providerArgs, config.approvalMode)
       : [...defaultArgs, ...config.providerArgs]).args;
-    // #1096 — when the assembler merged the caller's own `--settings` into relay's (so the
+    // when the assembler merged the caller's own `--settings` into relay's (so the
     // baseline hooks/projectSettings/statusLine survive), drop the caller's now-redundant
     // `--settings` here so exactly ONE reaches the launch (relay's merged copy in assembled.args).
-    // #2453 — the coding/review profiles' --disallowedTools trim unions in at this single
+    // the coding/review profiles' --disallowedTools trim unions in at this single
     // claude-family launch seam (helpers + per-profile config in ./claude-tool-policy).
     const args = claudeProfileDisallowedToolsArgs([
       ...assembled.args,
@@ -656,12 +656,12 @@ export class ClaudeAdapter implements ProviderAdapter {
     ], config);
     if (config.model) args.push("--model", config.model);
     const effortLaunch = claudeEffortLaunch(config.effort, config.env); args.push(...effortLaunch.args);
-    // #352: seed the first turn at launch for ALL sessions; a transient headless oversized brief
+    // seed the first turn at launch for ALL sessions; a transient headless oversized brief
     // runs in Claude print mode and enters as stdin, not a racy tmux paste or system prompt.
-    const oneShot = config.prompt ? seedClaudeInitialPrompt(args, sanitizeLaunchText(String(config.prompt), "initial prompt"), { headless: config.headless, lifecycle: config.lifecycle, scratchDir: relayEnv(config.env, "AGENT_RELAY_SCRATCH_DIR") }) : undefined;
+    const oneShot = config.prompt ? seedClaudeInitialPrompt(args, sanitizeLaunchText(String(config.prompt), "initial prompt"), { headless: config.headless, lifecycle: config.lifecycle, scratchDir: relayEnv(config.env, "HUMWICK_SCRATCH_DIR") }) : undefined;
     const env: Record<string, string> = writeChildEnv({}, {
       ...config.env,
-      // #557 — the assembler owns the isolated config-home env (CLAUDE_CONFIG_DIR).
+      // the assembler owns the isolated config-home env (CLAUDE_CONFIG_DIR).
       ...assembled.env,
       // Bare `claude` runs its own CLAUDE_CONFIG_DIR and so never inherits the host's long-lived
       // CLAUDE_CODE_OAUTH_TOKEN; without it claude falls back to the (often stale) file-based
@@ -677,20 +677,20 @@ export class ClaudeAdapter implements ProviderAdapter {
       // carries a copy of the runner process env) wins, so an operator can still unset.
       CLAUDE_CODE_DISABLE_BG_SHELL_PRESSURE_REAP:
         config.env?.CLAUDE_CODE_DISABLE_BG_SHELL_PRESSURE_REAP ?? process.env.CLAUDE_CODE_DISABLE_BG_SHELL_PRESSURE_REAP ?? "1",
-      // Same treatment (T3182 scope expansion): CLAUDE_CODE_SEND_FEEDBACK=0 is the
+      // Same treatment: CLAUDE_CODE_SEND_FEEDBACK=0 is the
       // documented removal of the SendFeedback tool — autonomous agents keep misfiling
       // humwick bugs to Anthropic with no human to approve the draft. The managed
       // settings.json additionally carries a permissions.deny belt (launch-assembly).
       CLAUDE_CODE_SEND_FEEDBACK: config.env?.CLAUDE_CODE_SEND_FEEDBACK ?? process.env.CLAUDE_CODE_SEND_FEEDBACK ?? "0",
-      // #1546 — a mid-fleet CC auto-update re-rendered startup gates on every restart; managed
+      // a mid-fleet CC auto-update re-rendered startup gates on every restart; managed
       // launches keep the installed version until an operator bump.
       DISABLE_AUTOUPDATER: config.env?.DISABLE_AUTOUPDATER ?? process.env.DISABLE_AUTOUPDATER ?? "1",
-      // #2615 — prompt suggestions ship conversation context to the provider to generate
+      // prompt suggestions ship conversation context to the provider to generate
       // follow-up suggestions no Relay-agent human ever sees (pure quota burn). The bundle
       // gate reads this env first; false outranks settings.json promptSuggestionEnabled.
       CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION:
         config.env?.CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION ?? process.env.CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION ?? "false",
-      // #2616 — remote recap forks the FULL cached conversation through an extra model call at
+      // remote recap forks the FULL cached conversation through an extra model call at
       // turn end to produce a recap pushed to a claude.ai remote UI (`notifyMetadataChanged({
       // recap})`); no Relay agent ever renders it. The bundle gate reads
       // CLAUDE_CODE_ENABLE_REMOTE_RECAP first (env outranks settings/statsig): "false" pins it
@@ -698,7 +698,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       // CCR surface; "true" still lets an operator force it on.
       CLAUDE_CODE_ENABLE_REMOTE_RECAP:
         config.env?.CLAUDE_CODE_ENABLE_REMOTE_RECAP ?? process.env.CLAUDE_CODE_ENABLE_REMOTE_RECAP ?? "false",
-      // #2616 — CLI away summary fires the same recap generator when a pane regains terminal
+      // CLI away summary fires the same recap generator when a pane regains terminal
       // focus after ≥5min blur and injects the result into the live transcript. Relay panes
       // routinely sit unfocused far longer than that, so every firing is a model call whose
       // output no agent reads. The bundle gate reads CLAUDE_CODE_ENABLE_AWAY_SUMMARY before the
@@ -706,20 +706,20 @@ export class ClaudeAdapter implements ProviderAdapter {
       // "true" forces it on.
       CLAUDE_CODE_ENABLE_AWAY_SUMMARY:
         config.env?.CLAUDE_CODE_ENABLE_AWAY_SUMMARY ?? process.env.CLAUDE_CODE_ENABLE_AWAY_SUMMARY ?? "false",
-      // #1222 — a spawned session may not find the humwick CLI in the host login
+      // a spawned session may not find the humwick CLI in the host login
       // shell's PATH, so Relay's own bins lead (layout-agnostic for npm and git-checkout
-      // installs, #1305) while the inherited PATH keeps its own order behind them: leading
-      // Homebrew's dirs (#1413) put Homebrew's node ahead of the operator's own on macOS,
-      // and Claude's shell snapshot keeps this PATH, so no rc file restores it (#2705).
-      // #3171 — the profile's harness trim (Artifact, Workflow, bundled skills, Explore/Plan) outranks inherited env.
+      // installs) while the inherited PATH keeps its own order behind them: leading
+      // Homebrew's dirs put Homebrew's node ahead of the operator's own on macOS,
+      // and Claude's shell snapshot keeps this PATH, so no rc file restores it.
+      // the profile's harness trim (Artifact, Workflow, bundled skills, Explore/Plan) outranks inherited env.
       ...claudeHarnessTrim(config).env,
       ...claudeSubagentEnv(config),
       PATH: launchPath(config.env?.PATH ?? process.env.PATH),
-      AGENT_RELAY_PROVIDER: this.provider,
+      HUMWICK_PROVIDER: this.provider,
       ...effortLaunch.env,
       ...claudeProjectShellEnv(config.env),
-    });
-    // #2513 review HIGH-2 — credential isolation. config.env carries a copy of the whole
+    }, []);
+    // review HIGH-2 — credential isolation. config.env carries a copy of the whole
     // runner process env, so ambient credentials of the PRIMARY subscription reach every
     // launch — and each of these env vars OUTRANKS the file credential, so a
     // second-subscription claude-family provider would silently authenticate as the
@@ -730,7 +730,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     // provider's own values can still ride its per-provider config env (threaded
     // explicitly here, since runner-core only merges providerConfig.env into host-globals
     // profiles). Primary subscription tokens survive; a host paid-key file does not. The key set is the SINGLE shared
-    // constant from @humwick/providers (#2513 round-3 MF3) — the orchestrator's auth
+    // constant from @humwick/providers — the orchestrator's auth
     // preflight scrubs the same list, and a local re-listing is blocked by the
     // duplication ratchet.
     const envUnset: string[] = [...effortLaunch.unset, ...(claudeSubagentPolicy(config) ? ["CLAUDE_CODE_AUTO_COMPACT_WINDOW", "DISABLE_AUTO_COMPACT"] : [])];
@@ -762,20 +762,20 @@ export class ClaudeAdapter implements ProviderAdapter {
     this.startupOpenApproval = config.approvalMode === "open";
 
     // Create the gate FIFO *before* the session exists — the launcher script blocks
-    // on reading it, so no output can be produced until we release it below (#1317).
+    // on reading it, so no output can be produced until we release it below.
     if (gateFifo) createLauncherGate(gateFifo);
 
     await createTmuxSessionWithEnv(sessionName, socketName, tmuxArgs, launcherScript, spawnArgs.env, config.providerConfig.env, gateFifo, this.provider);
 
     const exitCodeFile = spawnArgs.exitCodeFile ?? `${launcherScript}.exit-code`;
     this.watchTmuxSession(sessionName, socketName, exitCodeFile, printMode);
-    // #1838 review MED — resolve the pane pid OFF the loop now that the session exists and cache
+    // review MED — resolve the pane pid OFF the loop now that the session exists and cache
     // it, so the synchronous resolveBusyPid() never has to shell out on a hot busy edge. Fenced
     // on providerEpoch so a resolve that lands after a restart can't stamp a stale pid.
     void resolveClaudePanePidAsync(undefined, sessionName, socketName)
       .then((pid) => { if (this.providerEpoch === providerEpoch) this.tmuxPanePid = pid; })
       .catch(() => {});
-    const logFile = relayEnv(spawnArgs.env, "AGENT_RELAY_LOG_FILE");
+    const logFile = relayEnv(spawnArgs.env, "HUMWICK_LOG_FILE");
     if (logFile) {
       spawnSyncBounded(tmuxCommand(socketName, "pipe-pane", "-o", "-t", sessionName, `cat >> ${shellQuote(logFile)}`), {
         stdin: "ignore",
@@ -808,7 +808,7 @@ export class ClaudeAdapter implements ProviderAdapter {
 
   private watchTmuxSession(sessionName: string, socketName?: string, exitCodeFile?: string, oneShot = false): void {
     if (this.tmuxWatcher) clearInterval(this.tmuxWatcher);
-    // #1838 row 12 — the highest-frequency blocking site in the runner (every 2s for the
+    // row 12 — the highest-frequency blocking site in the runner (every 2s for the
     // agent's whole lifetime). Its two tmux subprocesses (has-session + capture-pane) now run
     // OFF the event loop via the offload subprocess runner, so the tick is async. Guard against
     // overlapping ticks: if a capture is still in flight when the timer fires again — a wedged
@@ -822,16 +822,16 @@ export class ClaudeAdapter implements ProviderAdapter {
       tickInFlight = true;
       void fireAndForget("[runner] claude tmux watch tick", (async () => {
         const presence = await tmuxSessionPresence(sessionName, socketName);
-        // #1838 HIGH-1: re-fence after every await — a respawn/shutdown that replaced this
+        // HIGH-1: re-fence after every await — a respawn/shutdown that replaced this
         // watcher mid-await must not let a predecessor tick emit or tear down its successor.
         if (this.tmuxWatcher !== watcher) return;
-        // #1838 HIGH-2: only a positive `absent` is evidence of death. An `unreadable` read
+        // HIGH-2: only a positive `absent` is evidence of death. An `unreadable` read
         // (wedged-but-live server, deadline SIGKILL) HOLDS this tick — never emit `offline`.
         if (presence === "unreadable") return;
         if (presence === "absent") {
           // The whole tick (including the delayed second confirmation) is serialized by the
           // in-flight guard, so an off-loop confirm can no longer race a stacked tick. The
-          // confirm itself only returns true when BOTH reads are `absent` (#1838 HIGH-2).
+          // confirm itself only returns true when BOTH reads are `absent`.
           const gone = await confirmTmuxSessionGone(sessionName, socketName).catch(() => false);
           if (this.tmuxWatcher !== watcher || !gone) return;
           const exitStatus = await claudeLaunchExitStatus(exitCodeFile, this.startupReadyObserved, oneShot, lastPane);
@@ -845,7 +845,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         } catch {
           return;
         }
-        // #1838 HIGH-1: fence again after the capture await, before any observation/status emit.
+        // HIGH-1: fence again after the capture await, before any observation/status emit.
         if (this.tmuxWatcher !== watcher) return;
         lastPane = pane;
         // A reused tmux pane can leave an old ready footer in scrollback. Until the
@@ -867,7 +867,7 @@ export class ClaudeAdapter implements ProviderAdapter {
         );
         this.modelUnavailableObservationState = modelUnavailable.state;
         if (modelUnavailable.observation) this.paneObservationCb(modelUnavailable.observation);
-        // #769/#1651: connection-retry banner detection, advisory. BOTH edges are diagnostics.
+        // connection-retry banner detection, advisory. BOTH edges are diagnostics.
         // Appearance used to publish an idle + blocked hold, which the runner reads as the
         // provider turn ENDING — completing the task claims of a turn that was still running.
         // Disappearance used to publish a bare `idle`, an unconditional turn-end with no evidence
@@ -883,10 +883,10 @@ export class ClaudeAdapter implements ProviderAdapter {
           this.connectionRetryActive = false;
           this.paneObservationCb(claudeConnectionRetryClearedObservation(sessionName));
         }
-        // #663: prompt-gate fallback. Known gates should be prevented before launch;
-        // this catches missed/new blocking panes with the same #655 debounce + busy
+        // prompt-gate fallback. Known gates should be prevented before launch;
+        // this catches missed/new blocking panes with the same debounce + busy
         // guard used for rate-limit holds.
-        // #1651: it NOTICES, it does not act. The five startup/modal gates are advisory and
+        // it NOTICES, it does not act. The five startup/modal gates are advisory and
         // return no status at all, so the only thing this branch can do for them is publish a
         // diagnostic. `status` is present solely for the usage-limit gate.
         const promptGate = evaluateClaudePromptGatePane(livePane, this.promptGatePaneState, {
@@ -910,7 +910,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   private publishConfirmedTmuxExit(status: ProviderStatusUpdate): void {
     // The pane and turn pollers are independent. Invalidate the turn generation BEFORE publishing
     // the terminal edge so an in-flight incarnation/activity read cannot land a later idle and
-    // resurrect the row with its shutting-down lifecycle pill still latched (#2505).
+    // resurrect the row with its shutting-down lifecycle pill still latched.
     this.stopStatusWatchers();
     this.statusCb(status);
   }
@@ -935,7 +935,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     if (turnWatchResume) await this.beginMonitorlessTurnWatch(process, turnWatchResume.sessionName, turnWatchResume.socketName, false);
   }
 
-  // #1647 — the shutdown sequence (observe → correlate → maybe /exit) lives in
+  // the shutdown sequence (observe → correlate → maybe /exit) lives in
   // ./claude-shutdown. Only the watcher teardown is the adapter's own business.
   async shutdownTmux(
     process: ManagedProcess,
@@ -949,7 +949,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   }
 }
 
-// #1588 — a self-resume continuation delivery carries the resumeInjection/selfResume markers the
+// a self-resume continuation delivery carries the resumeInjection/selfResume markers the
 // runner stamps in injectContext. Used to scope the monitor-path settle re-check to ONLY those
 // deliveries so ordinary message delivery is unchanged.
 function messagesAreSelfResumeContinuation(messages: Message[]): boolean {
@@ -959,11 +959,11 @@ function messagesAreSelfResumeContinuation(messages: Message[]): boolean {
   });
 }
 
-// #1647 — the exit command and its two writers now live in ./claude-exit, behind the
+// the exit command and its two writers now live in ./claude-exit, behind the
 // one-shot grant. Re-exported so existing `./claude` consumers + tests keep their path.
 export { CLAUDE_EXIT_COMMAND } from "./claude-exit";
 export { claudeShutdownGraceMs, type ClaudeShutdownDeps } from "./claude-shutdown";
-// tmux transport plumbing moved to ./claude-tmux (#300 ratchet); re-exported so
+// tmux transport plumbing moved to ./claude-tmux; re-exported so
 // existing `./claude` consumers + tests keep their import paths.
 export { CLAUDE_TMUX_SUBMIT_DELAY_MS, CLAUDE_TMUX_SUBMIT_KEY, CLAUDE_TMUX_READY_TIMEOUT_MS, tmuxSessionName, tmuxSocketName, assertTmuxSocketPathFits, tmuxEnvKeys, waitForClaudeClearCommitted } from "./claude-tmux";
 // Monitorless turn detection (Fix: isolated agents reach task "done" like Codex).
@@ -973,7 +973,7 @@ const CLAUDE_TURN_IDLE_CONFIRM_TICKS = 3;  // ~4.5s of stable idle before declar
 const CLAUDE_TURN_QUICK_GRACE_TICKS = 8;   // ~12s fallback when the spinner was never caught
 const CLAUDE_TURN_MAX_TICKS = 3600;        // ~90min safety cap so the timer never leaks
 
-// #557 — sessionStatusLineSettingsArgs now lives in ../launch-assembly (the single
+// sessionStatusLineSettingsArgs now lives in ../launch-assembly (the single
 // launch-arg home); re-exported so existing ./claude consumers + tests keep their path.
 export { sessionStatusLineSettingsArgs };
 
@@ -1034,7 +1034,7 @@ async function terminateSingleProcess(process: ManagedProcess, opts: { graceful:
   try {
     proc.kill(opts.graceful ? "SIGTERM" : "SIGKILL");
   } catch {
-    // Already gone (ESRCH) or unsignalable — re-observe rather than trust the throw. (#1746)
+    // Already gone (ESRCH) or unsignalable — re-observe rather than trust the throw.
     return pid !== undefined && isPidAlive(pid) ? "failed-to-kill" : "killed";
   }
   const timeout = new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), opts.timeoutMs));
@@ -1045,6 +1045,6 @@ async function terminateSingleProcess(process: ManagedProcess, opts: { graceful:
     } catch {}
     await proc.exited.catch(() => {});
   }
-  // Confirm death rather than assume the kill took (#1746).
+  // Confirm death rather than assume the kill took.
   return pid !== undefined && isPidAlive(pid) ? "failed-to-kill" : "killed";
 }