@humwick/runner 0.130.4 → 0.130.6

package/src/adapters/project-shell.ts

@@ -1,8 +1,8 @@
 import { relayEnv, writeChildEnv } from "@humwick/sdk/env";
-// #2947 — the orchestrator hands the runner the project's toolchain PATH plus shell hooks that re-lead
+// the orchestrator hands the runner the project's toolchain PATH plus shell hooks that re-lead
 // it after the user's shell init. The provider process keeps the host PATH; only its shell tool re-leads.
-// The same hooks keep the agent's private TMPDIR when a login profile resets it (#3084).
-// A hook the user already configured is chained behind ours, never dropped; an inherited Relay hook never is (#3084).
+// The same hooks keep the agent's private TMPDIR when a login profile resets it.
+// A hook the user already configured is chained behind ours, never dropped; an inherited Relay hook never is.
 import { resolve } from "node:path";
 import { browserToolsBinDir, isRecord, PROJECT_ENV_FILE_ENV, PROJECT_PATH_ENV, PROJECT_ZDOTDIR_ENV, RELAY_BIN_PATH_ENV } from "@humwick/sdk";
 import { AGENT_TMPDIR_ENV } from "@humwick/sdk/host-tmpdir";
@@ -14,13 +14,13 @@ import { providerSourceHome } from "../profile-home";
 import { readCodexConfig } from "./codex-effective-config";
 import { serviceAccessEnvKeys } from "./service-access";
 
-/** #3084 — every launch, orchestrator-spawned or direct: the agent's private TMPDIR plus the hooks that keep
- *  it (and #2947's toolchain PATH) after shell init. */
+/** every launch, orchestrator-spawned or direct: the agent's private TMPDIR plus the hooks that keep
+ *  it (and the toolchain PATH) after shell init. */
 export async function agentShellLaunchEnv(agentId: string, operatorEnv?: Record<string, string>): Promise<Record<string, string>> {
-  return writeChildEnv({}, { ...await providerScratchEnv(agentId, undefined, operatorEnv), [PROJECT_ENV_FILE_ENV]: PROJECT_ENV_SCRIPT, [PROJECT_ZDOTDIR_ENV]: PROJECT_ZDOTDIR, [RELAY_BIN_PATH_ENV]: relayBinPath() });
+  return writeChildEnv({}, { ...await providerScratchEnv(agentId, undefined, operatorEnv), [PROJECT_ENV_FILE_ENV]: PROJECT_ENV_SCRIPT, [PROJECT_ZDOTDIR_ENV]: PROJECT_ZDOTDIR, [RELAY_BIN_PATH_ENV]: relayBinPath() }, []);
 }
 
-/** #3489 — this runner's own `agent-relay-browser` and the host's provisioned `playwright-cli`: a login shell's
+/** this runner's own `humwick-browser` and the host's provisioned `playwright-cli`: a login shell's
  *  PATH (an older global install) can never pick which Relay release or browser tools an agent runs. */
 export function relayBinPath(): string {
   return [resolve(import.meta.dir, "../../agent-bin"), browserToolsBinDir(humwickHome())].join(":");
@@ -40,7 +40,7 @@ export function codexProjectShellConfigArgs(env: Record<string, string>, configA
   const path = relayEnv(env, PROJECT_PATH_ENV);
   if (!shellHookNeeded(env)) return [];
   const configured = codexShellPolicySet(configArgs, codexHome || providerSourceHome("codex"));
-  if (relayEnv(env, "AGENT_RELAY_SERVICE_ACCESS_ENV_FILE")) {
+  if (relayEnv(env, "HUMWICK_SERVICE_ACCESS_ENV_FILE")) {
     for (const key of serviceAccessEnvKeys(env)) if (relayEnv(configured, key) !== undefined && relayEnv(configured, key) !== relayEnv(env, key)) throw new Error("vault_env_conflict:shell:" + key);
     const policy = codexShellPolicy(configArgs, codexHome || providerSourceHome("codex"));
     if ((Array.isArray(policy.exclude) && policy.exclude.length) || (Array.isArray(policy.include_only) && policy.include_only.length) || (policy.inherit && policy.inherit !== "all")) throw new Error("vault_env_conflict:shell_environment_policy");
@@ -50,9 +50,9 @@ export function codexProjectShellConfigArgs(env: Record<string, string>, configA
     [PROJECT_PATH_ENV]: path,
     [RELAY_BIN_PATH_ENV]: relayEnv(env, RELAY_BIN_PATH_ENV),
     ...composeShellHooks(user, { BASH_ENV: relayEnv(env, PROJECT_ENV_FILE_ENV), ZDOTDIR: relayEnv(env, PROJECT_ZDOTDIR_ENV) }),
-  });
+  }, []);
   // An empty chain variable is set too: it clears a stale one the app-server env would hand down.
-  return [...(relayEnv(env, "AGENT_RELAY_SERVICE_ACCESS_ENV_FILE") ? ["-c", 'shell_environment_policy.inherit="all"', "-c", "shell_environment_policy.ignore_default_excludes=true"] : []),
+  return [...(relayEnv(env, "HUMWICK_SERVICE_ACCESS_ENV_FILE") ? ["-c", 'shell_environment_policy.inherit="all"', "-c", "shell_environment_policy.ignore_default_excludes=true"] : []),
     ...Object.entries(set).flatMap(([key, value]) => value === undefined ? [] : ["-c", `shell_environment_policy.set.${key}=${tomlString(value)}`])];
 }
 
@@ -64,7 +64,7 @@ export function openCodeProjectShellEnv(env: Record<string, string>): Record<str
 }
 
 function shellHookNeeded(env: Record<string, string>): boolean {
-  return Boolean(relayEnv(env, PROJECT_PATH_ENV) || relayEnv(env, AGENT_TMPDIR_ENV) || relayEnv(env, "AGENT_RELAY_SERVICE_ACCESS_ENV_FILE"));
+  return Boolean(relayEnv(env, PROJECT_PATH_ENV) || relayEnv(env, AGENT_TMPDIR_ENV) || relayEnv(env, "HUMWICK_SERVICE_ACCESS_ENV_FILE"));
 }
 
 /** Codex's own `shell_environment_policy.set` without us: CODEX_HOME/config.toml, then `-c` overrides in order. */

package/src/adapters/service-access.ts

@@ -12,7 +12,7 @@ import { extractCallerSettings } from "../claude-settings";
 import { codexConfigOverrides, isRecord } from "@humwick/sdk";
 import { projectSettingSources, providerHomePathFor, providerSourceHome } from "../profile-home";
 
-export const SERVICE_ACCESS_ENV_FILE = "AGENT_RELAY_SERVICE_ACCESS_ENV_FILE";
+export const SERVICE_ACCESS_ENV_FILE = "HUMWICK_SERVICE_ACCESS_ENV_FILE";
 const PROXY_CA_ENV_KEYS = ["SSL_CERT_FILE", "CURL_CA_BUNDLE", "GIT_SSL_CAINFO", "NODE_EXTRA_CA_CERTS", "REQUESTS_CA_BUNDLE"] as const;
 export const PROXY_TRUST_ENV_KEYS = ["HTTPS_PROXY", "HTTP_PROXY", "https_proxy", "http_proxy", "NO_PROXY", "no_proxy", "NODE_USE_ENV_PROXY", ...PROXY_CA_ENV_KEYS] as const;
 
@@ -42,7 +42,7 @@ export function prepareServiceAccessConfig(config: RunnerSpawnConfig): RunnerSpa
     if (!cert.ca || cert.fingerprint256.replaceAll(":", "").toLowerCase() !== access.caFingerprint || Date.parse(cert.validTo) <= Date.now()) fail("vault_ca_mismatch");
   } catch { fail("vault_ca_mismatch"); }
   if (access.expiresAt <= Date.now()) fail("vault_token_expired");
-  const inherited = writeChildEnv({}, { ...config.env, ...config.providerConfig.env });
+  const inherited = writeChildEnv({}, { ...config.env, ...config.providerConfig.env }, []);
   if (inherited.NODE_TLS_REJECT_UNAUTHORIZED === "0" || inherited.GIT_SSL_NO_VERIFY === "true") fail("vault_tls_verification_disabled");
   // Ambient routing cannot silently bypass a brokered host, even through ALL_PROXY.
   for (const key of ["HTTPS_PROXY", "HTTP_PROXY", "https_proxy", "http_proxy", "ALL_PROXY", "all_proxy", "NO_PROXY", "no_proxy"]) {
@@ -82,9 +82,9 @@ export function prepareServiceAccessConfig(config: RunnerSpawnConfig): RunnerSpa
     ...dummy, HTTPS_PROXY: proxy.href, HTTP_PROXY: proxy.href, https_proxy: proxy.href, http_proxy: proxy.href,
     NO_PROXY: [...bypass].join(","), no_proxy: [...bypass].join(","),
     ...Object.fromEntries(PROXY_CA_ENV_KEYS.map((key) => [key, bundle])), NODE_USE_ENV_PROXY: "1", [SERVICE_ACCESS_ENV_FILE]: script,
-  });
+  }, []);
   writeFileSync(script, Object.entries(env).map(([key, value]) => `export ${key}=${shellQuote(value)}`).join("\n") + "\n", { mode: 0o600 });
-  return { ...config, providerConfig: { ...config.providerConfig, env: writeChildEnv({}, { ...config.providerConfig.env, ...env }) }, serviceAccessEnv: env, env: writeChildEnv({}, { ...config.env, ...env, [PROJECT_ENV_FILE_ENV]: PROJECT_ENV_SCRIPT, [PROJECT_ZDOTDIR_ENV]: PROJECT_ZDOTDIR }) };
+  return { ...config, providerConfig: { ...config.providerConfig, env: writeChildEnv({}, { ...config.providerConfig.env, ...env }, []) }, serviceAccessEnv: env, env: writeChildEnv({}, { ...config.env, ...env, [PROJECT_ENV_FILE_ENV]: PROJECT_ENV_SCRIPT, [PROJECT_ZDOTDIR_ENV]: PROJECT_ZDOTDIR }, []) };
 }
 
 /** References carry the child's env into native MCP config without writing the proxy token. */
@@ -107,11 +107,11 @@ export function serviceAccessMcpServers(config: RunnerSpawnConfig, servers: Reco
       if (value !== undefined && value !== `\${${key}}` && value !== config.serviceAccessEnv![key]) fail("vault_env_conflict:mcp:" + name + ":" + key);
     }
     if (config.provider === "codex") {
-      const env = writeChildEnv({}, { ...server.env }), configEnv = writeChildEnv({}, { ...server.configEnv });
+      const env = writeChildEnv({}, { ...server.env }, []), configEnv = writeChildEnv({}, { ...server.configEnv }, []);
       for (const key of keys) { writeChildEnv(env, {}, [key]); writeChildEnv(configEnv, {}, [key]); }
       return [name, { ...server, env, configEnv, env_vars: [...new Set([...(Array.isArray(server.env_vars) ? server.env_vars : Object.keys(server.env_vars ?? {})), ...keys])] }];
     }
-    return [name, { ...server, env: writeChildEnv({}, { ...server.env, ...Object.fromEntries(keys.map((key) => [key, `\${${key}}`])) }) }];
+    return [name, { ...server, env: writeChildEnv({}, { ...server.env, ...Object.fromEntries(keys.map((key) => [key, `\${${key}}`])) }, []) }];
   }));
 }
 

package/src/adapters/tmux-offload.ts

@@ -1,5 +1,5 @@
-// Off-loop tmux subprocess transport (#1838 Wave 2, rows 12/14/15/16 — first real
-// adoption of the #1809/#1822 offload primitive).
+// Off-loop tmux subprocess transport (Wave 2, rows 12/14/15/16 — first real
+// adoption of the offload primitive).
 //
 // Every tmux subprocess the runner spawns from a HOT PATH — the 2s pane watcher, the 4s
 // busy reconciler, the 1.5s monitorless turn watch, and the per-payload input transport —
@@ -7,7 +7,7 @@
 // `Bun.spawn`, bounded by a hard deadline (SIGTERM → SIGKILL of the whole process group
 // after a grace window), instead of a synchronous `Bun.spawnSync` that pins the runner's
 // single event loop for the entire 10s deadline while a wedged tmux socket hangs (the
-// #1760 class; #1815 findings 1/6/7/10). A blocked tmux call here would otherwise freeze
+// class; findings 1/6/7/10). A blocked tmux call here would otherwise freeze
 // this agent's bus connection, control server, heartbeat, and every timer at once.
 //
 // AT-MOST-ONCE — a property of the backend, not a per-call flag. The offload envelope's
@@ -45,7 +45,7 @@ export async function destroyTmuxRunner(): Promise<void> {
   if (current) await current.destroy();
 }
 
-/** Per-call bounding for a read that sits inside a caller's OWN deadline loop (#1838 round-3
+/** Per-call bounding for a read that sits inside a caller's OWN deadline loop (round-3
  * MED): pass the REMAINING outer budget as `timeoutMs` so the subprocess deadline shrinks with
  * the loop, and/or a `signal` the caller aborts at its absolute deadline. Without this each run
  * would get the runner's full ~10s default and blow the caller's (e.g. 500ms) deadline. */
@@ -75,7 +75,7 @@ export const TMUX_CAPTURE_SCROLLBACK_LINES = 80;
 /**
  * The `tmux capture-pane` argv, with the scrollback window as the single explicit knob.
  * `scrollbackLines` omitted/0 ⇒ the VISIBLE SCREEN ONLY (no `-S`). Exported so the two capture
- * scopes are assertable in a unit test — the #2261 regression was exactly a caller reading the
+ * scopes are assertable in a unit test — the regression was exactly a caller reading the
  * wrong one.
  */
 export function tmuxCapturePaneArgv(sessionName: string, socketName?: string, scrollbackLines = 0, styled = false): string[] {
@@ -88,7 +88,7 @@ export function tmuxCapturePaneArgv(sessionName: string, socketName?: string, sc
 /**
  * Off-loop `tmux capture-pane` of the VISIBLE SCREEN ONLY — no `-S` scrollback window.
  *
- * #2261: the difference matters for anything that reads a repaint as evidence. Claude Code's
+ * the difference matters for anything that reads a repaint as evidence. Claude Code's
  * `/clear` repaints only the visible screen (`ESC[H` + a per-line `ESC[2K`; it never emits the
  * `ESC[3J` that would drop tmux's history), so the pre-clear conversation SURVIVES verbatim in
  * scrollback. A `-S -80` capture therefore still contains the wiped conversation long after the
@@ -98,7 +98,7 @@ export function tmuxCapturePaneArgv(sessionName: string, socketName?: string, sc
  */
 export async function captureTmuxVisiblePaneAsync(sessionName: string, socketName?: string, opts: TmuxReadOpts & { styled?: boolean } = {}): Promise<string> {
   const { styled, ...readOpts } = opts;
-  // `styled` keeps SGR escapes (`-e`) for readers that must tell dim placeholder text from input (#2664).
+  // `styled` keeps SGR escapes (`-e`) for readers that must tell dim placeholder text from input.
   const result = await runTmux("tmux-capture-pane", tmuxCapturePaneArgv(sessionName, socketName, 0, styled), readOpts);
   return result.stdout;
 }
@@ -107,7 +107,7 @@ export async function captureTmuxVisiblePaneAsync(sessionName: string, socketNam
 export type TmuxSessionPresence = "present" | "absent" | "unreadable";
 
 /**
- * Off-loop `tmux has-session` (read-only, idempotent), as a TRI-STATE (#1838 review HIGH-2).
+ * Off-loop `tmux has-session` (read-only, idempotent), as a TRI-STATE.
  *
  * A boolean `present`/`!present` collapses "the session is gone" together with "I could not
  * find out", so a wedged-but-LIVE tmux server (has-session SIGKILLed at its deadline) would
@@ -162,7 +162,7 @@ export async function runTmuxInput(taskName: string, argv: string[], signal?: Ab
 }
 
 /**
- * Off-loop `tmux load-buffer -b <name> -`, streaming the payload on STDIN (#1838 row 16).
+ * Off-loop `tmux load-buffer -b <name> -`, streaming the payload on STDIN.
  *
  * This replaces the old `set-buffer -b <name> <text>` whose payload rode in argv — an
  * ARG_MAX exposure for a large delivered message (up to the platform's arg limit, beyond

package/src/adapters/tool-summary.ts

@@ -45,7 +45,7 @@ export function oneLineText(value: unknown): string {
  * in the chat mirror / a report-up. This is NOT a proof that no secret can ever leak — a one-line
  * free-text summary of arbitrary tool input cannot make that guarantee — so it layers three
  * conservative, structural nets and errs toward over-redaction (a real secret surfacing is always
- * the worse outcome, #2354):
+ * the worse outcome):
  *   1. positional shapes — URL basic-auth, `Authorization: Bearer/Basic …`;
  *   2. known provider key prefixes — OpenRouter/Anthropic/OpenAI `sk-…`, GitHub `gh?_`, Slack
  *      `xox…`, AWS `AKIA…`;
@@ -142,7 +142,7 @@ export function summarizeToolInput(input: Record<string, unknown> | undefined, e
   return "";
 }
 
-// #2437 — the structured-params sibling of the one-line summary above: the FULL tool-call
+// the structured-params sibling of the one-line summary above: the FULL tool-call
 // input/arguments, redacted then size-capped for the dashboard trace's expandable detail (the
 // one-line `body` stays a short label; this is the "show me everything" view). Own budget, own
 // key list — deliberately separate constants from the one-line summary's so tuning one never
@@ -170,7 +170,7 @@ function redactParamsValue(value: unknown, depth: number): unknown {
 
 /**
  * Redact then size-cap a tool call's raw input/arguments for the dashboard trace's expandable
- * detail (#2437). Redaction runs FIRST, over the whole structured value — every string passes
+ * detail. Redaction runs FIRST, over the whole structured value — every string passes
  * through the shared `redactSecrets` net, and any object key matching
  * `/token|secret|password|key|authorization/i` is replaced wholesale — so a later byte-budget cut
  * can never land mid-secret. Only THEN is the redacted value serialized and size-capped: within
@@ -193,7 +193,7 @@ export function redactAndCapParams(input: unknown, maxBytes: number = PARAMS_DEF
   return `${truncated}${PARAMS_TRUNCATION_MARKER}`;
 }
 
-/** #3411 — the absolute file paths among a tool's raw input values: a relative path resolves
+/** the absolute file paths among a tool's raw input values: a relative path resolves
  *  against `cwd` when one is known and is dropped otherwise. Undefined when none remain. */
 export function absoluteToolPaths(candidates: readonly unknown[], cwd?: string): string[] | undefined {
   const paths: string[] = [];
@@ -205,7 +205,7 @@ export function absoluteToolPaths(candidates: readonly unknown[], cwd?: string):
   return paths.length ? paths : undefined;
 }
 
-/** #3508 — the files a Codex shell command reads: Codex parses each read into `commandActions`
+/** the files a Codex shell command reads: Codex parses each read into `commandActions`
  *  ({ type: "read", path }), so a read touches its file's area just as an edit does. */
 export function codexReadPaths(item: Record<string, unknown>, cwd?: string): string[] | undefined {
   const actions = Array.isArray(item.commandActions) ? item.commandActions.filter(isRecord) : [];

package/src/agent-redact.ts

@@ -4,7 +4,7 @@ import { AGENT_REDACT_FILES, AGENT_REDACT_VERSION, agentRedactInstallDir, agentR
 import { humwickHome, redactionEnabledFromEnv } from "./config";
 import { parseHookSet } from "./project-hooks";
 
-// #3025 — agent-redact post-tool hooks for every runner-managed launch. The orchestrator installs
+// agent-redact post-tool hooks for every runner-managed launch. The orchestrator installs
 // the pinned binary and the hook entries its `install` command writes (agent-redact-provisioning.ts).
 // A host without them launches agents without redaction and says so: an agent must always run.
 

package/src/agent-runner/commands/dispatch.ts

@@ -41,9 +41,9 @@ interface CommandDispatchDeps {
   deleteAgent(): Promise<unknown>;
   stop(): Promise<void>;
   updateCommand(commandId: string, input: { status: string; result?: Record<string, unknown>; error?: string }): Promise<unknown>;
-  /** `GET /api/commands/:id` — the full record behind a bounded bus event (#3606). */
+  /** `GET /api/commands/:id` — the full record behind a bounded bus event. */
   fetchCommand(commandId: string): Promise<Response>;
-  /** #3398 — the command's destructive input reached the provider and no reset has settled it. */
+  /** the command's destructive input reached the provider and no reset has settled it. */
   destructiveInputUnsettled(commandId: string): boolean;
   checkAcknowledgement(ack: unknown, status: string): void;
 }
@@ -52,7 +52,7 @@ export class CommandDispatch {
   constructor(private readonly deps: CommandDispatchDeps) {}
 
   /**
-   * The bus dispatch seam (#1565 F1).
+   * The bus dispatch seam.
    *
    * Commands that put a payload into the provider's input channel take their place in the
    * `providerInput` queue HERE, synchronously, before the first `await` — so the order the relay
@@ -72,7 +72,7 @@ export class CommandDispatch {
     const target = typeof command?.target === "string" ? command.target : this.deps.agentId;
     if (target !== this.deps.agentId && target !== this.deps.options.runnerId) return;
     if (type !== "agent.shutdown" && type !== "agent.restart" && type !== "agent.reconnect" && type !== "agent.kill" && type !== "agent.compact" && type !== "agent.clearContext" && type !== "agent.injectContext" && type !== "agent.permissionDecision" && type !== "agent.interrupt" && type !== "agent.releaseSubmitHold" && type !== "prompt.inject") return;
-    // #3606 — a bus event carries params whole only up to a size budget; read the rest by id.
+    // a bus event carries params whole only up to a size budget; read the rest by id.
     if (command?.paramsOmitted === true) {
       try { params = await this.loadCommandParams(commandId); } catch (error) {
         await this.updateCommand(commandId, "failed", undefined, `command params unavailable: ${errMessage(error)}`).catch(() => {});
@@ -84,7 +84,7 @@ export class CommandDispatch {
 
     const exitAfterCommand = type === "agent.shutdown" || type === "agent.kill";
     if (exitAfterCommand) this.deps.beginExitCommand();
-    // #1746 — the confirmed terminal outcome of an exit command's provider teardown. Stays
+    // the confirmed terminal outcome of an exit command's provider teardown. Stays
     // undefined if shutdownProvider never ran or threw; only a positive `killed` authorizes
     // deregistration (a roster removal must imply the process is gone).
     let killOutcome: ShutdownOutcome | undefined;
@@ -94,8 +94,8 @@ export class CommandDispatch {
     try {
       await this.deps.runNativeSelfResume(nativeSelfResume, () => this.updateCommand(commandId, "accepted"));
       await this.deps.runNativeSelfResume(nativeSelfResume, () => this.updateCommand(commandId, "running"));
-      // Pre-session-destroy seam (#183): for destructive transitions, run end-of-session
-      // work (Insights capture, #184) BEFORE the invasive operation, surfaced as a
+      // Pre-session-destroy seam: for destructive transitions, run end-of-session
+      // work BEFORE the invasive operation, surfaced as a
       // non-addressable "finalizing" state so the agent isn't mistaken for merely busy.
       const destroyReason = boundaryReasonForCommand(type);
       if (destroyReason) await this.deps.runNativeSelfResume(nativeSelfResume, () => this.deps.runPreSessionDestroy(destroyReason));
@@ -138,8 +138,8 @@ export class CommandDispatch {
       if (nativeSelfResume) this.deps.rejectNativeSelfResume(nativeSelfResume, error instanceof Error ? error : new Error(errMessage(error)));
       this.deps.finishCommandClaim(commandId);
       this.deps.publishStatus();
-      // An unsettled destructive input can still reset the context: Relay replaces the process (#3398).
-      // One that never reached the provider says so: nothing can still apply, and Relay closes its obligation (#3441).
+      // An unsettled destructive input can still reset the context: Relay replaces the process.
+      // One that never reached the provider says so: nothing can still apply, and Relay closes its obligation.
       const unsettled = this.deps.destructiveInputUnsettled(commandId) ? { destructiveInputUnsettled: true }
         : error instanceof ContextSubmitAborted ? { destructiveInputSubmitted: false } : undefined;
       await this.updateCommand(commandId, "failed", unsettled, errMessage(error)).catch(() => {});
@@ -150,7 +150,7 @@ export class CommandDispatch {
         if (params.preserveRegistration === true) {
           await this.deps.setOffline().catch(() => {});
         } else if (killOutcome === "killed") {
-          // #1746 — CONFIRM-DEAD-BEFORE-DEREGISTER. Only remove the roster row once the
+          // CONFIRM-DEAD-BEFORE-DEREGISTER. Only remove the roster row once the
           // provider is positively confirmed gone. If the force-kill could not confirm death
           // (killOutcome "failed-to-kill", or undefined because shutdownProvider threw), leave
           // the agent registered so it stays visible (as "kill-failed") rather than becoming a

package/src/agent-runner/commands/lifecycle.ts

@@ -47,7 +47,7 @@ export class LifecycleCommands {
     const hasProviderTurn = this.deps.hasProviderTurn();
     if (hasProviderTurn || !redirect) {
       this.deps.sessionLog(`interrupt requested via ${typeof params.requestedVia === "string" ? params.requestedVia : "dashboard"}`);
-      // #2389 — an interrupted turn always ends with no output, and that state already has its
+      // an interrupted turn always ends with no output, and that state already has its
       // own notice (`agent.turn_interrupted`). It must not also draw an empty-turn strike.
       this.deps.resetEmptyTurns();
       providerResult = await this.deps.options.adapter.interrupt(this.deps.process()!);
@@ -63,7 +63,7 @@ export class LifecycleCommands {
     try {
       killOutcome = await this.deps.shutdownProvider(type === "agent.kill", commandTimeoutMs(params));
     } catch (shutdownError) {
-      // #1725 fix-forward — a throw INSIDE shutdownProvider (e.g. tmux missing from PATH ⇒
+      // fix-forward — a throw INSIDE shutdownProvider (e.g. tmux missing from PATH ⇒
       // defaultKillSession's Bun.spawnSync throws ENOENT) previously left killOutcome undefined
       // and the "kill-failed" pill unset (that pill is set inside shutdownProvider, which never
       // completed) — so the confirm-dead gate below deleted nothing AND published nothing, wedging

package/src/agent-runner/commands/prompt.ts

@@ -34,7 +34,7 @@ interface PromptCommandsDeps {
   publishStatus(): void;
 }
 
-// #329: a cold isolated profile (first-run trust/onboarding/install gates) can take far longer
+// a cold isolated profile (first-run trust/onboarding/install gates) can take far longer
 // than the warm-restart window to render an input-ready TUI, so the first prompt delivery gets a
 // generous timeout. If it still misses, the prompt is re-attempted on the next provider ready
 // signal (short timeout, since it just went idle), up to a bounded number of attempts.
@@ -42,11 +42,11 @@ const INITIAL_PROMPT_FIRST_READY_TIMEOUT_MS = 30_000;
 const INITIAL_PROMPT_RETRY_READY_TIMEOUT_MS = 10_000;
 const MAX_INITIAL_PROMPT_ATTEMPTS = 6;
 const PROMPT_NOT_DURABLE = "prompt refused under a provider hold and could not be parked durably; not delivered";
-/** Who a prompt.inject came from (every producer stamps its session message's sender); parked copies keep it (#2664). */
+/** Who a prompt.inject came from (every producer stamps its session message's sender); parked copies keep it. */
 export const promptOrigin = (params: Record<string, unknown>): string => [params.from, params.requestedBy].find((id): id is string => typeof id === "string" && id !== "") ?? "user";
 
 export class PromptCommands {
-  // #329: a spawn-time initial prompt whose first delivery timed out before the TUI was
+  // a spawn-time initial prompt whose first delivery timed out before the TUI was
   // ready. Held (not dropped) for a ready-signal-driven re-attempt; cleared on success.
   private pendingInitialPrompt?: string;
   private deliveringInitialPrompt = false;
@@ -75,7 +75,7 @@ export class PromptCommands {
   }
 
   // Deliver the spawn-time first prompt, surviving a cold-start TUI that isn't input-ready yet
-  // (#329). Timeout stashes it for ready-signal retry and surfaces the stall on the timeline.
+  // Timeout stashes it for ready-signal retry and surfaces the stall on the timeline.
   private async attemptInitialPromptDelivery(prompt: string, readyTimeoutMs: number): Promise<void> {
     if (this.deliveringInitialPrompt || this.deps.isStopped() || !this.deps.process() || !this.deps.options.adapter.deliverInitialPrompt) return;
     this.deliveringInitialPrompt = true;
@@ -83,20 +83,20 @@ export class PromptCommands {
     let arm: EmptyTurnArm | undefined;
     try {
       const startedAt = Date.now();
-      // #2389 — armed BEFORE the delivery is awaited. On OpenCode `deliverInitialPrompt` awaits the
+      // armed BEFORE the delivery is awaited. On OpenCode `deliverInitialPrompt` awaits the
       // synchronous /message POST, which returns only when the assistant message is complete; an arm
       // taken on resolution lands at or after that turn's own idle edge and misses it entirely.
       arm = this.deps.armInput(Date.now(), "ladder", true);
       this.deps.recordInjectedPrompt(prompt);
       const outcome = await this.deps.offerPromptOrPark(prompt, { readyTimeoutMs, isInitial: true, inputObserver: this.deps.inputObserver(arm) });
-      // #2619 — a refused launch prompt that could not be made durable stays pending (re-offered
+      // a refused launch prompt that could not be made durable stays pending (re-offered
       // on the next ready edge); a durably parked one redelivers from the inbox.
       this.pendingInitialPrompt = outcome === "not-durable" ? prompt : undefined;
       if (outcome !== "accepted") {
         this.deps.sessionLog(`initial prompt attempt ${attempt} refused under a provider hold (${prompt.length} chars); ${outcome === "parked" ? "parked for redelivery" : "not durable, kept pending"}`);
         return;
       }
-      // #2397 round 3 review (LOW-5r) — a synchronous-endpoint adapter (OpenCode) can resolve this
+      // round 3 review (LOW-5r) — a synchronous-endpoint adapter (OpenCode) can resolve this
       // call NORMALLY after running its own bounded retry+reroll loop into a TERMINAL provider
       // failure (see failTurn) rather than throwing — throwing here would route into this method's
       // own retry-and-give-up path, re-sending the same prompt on top of the budget the adapter
@@ -104,11 +104,11 @@ export class PromptCommands {
       // the adapter's own `error` status and cleared by the `busy` edge THIS delivery started with
       // (setProviderStatus, ~line 1841), so a set value here can only have been raised during this
       // very call, never stale. Without this check, a freshly spawned agent's terminally-failed
-      // first turn — the exact incident #2397 was filed on — was still logged "delivered".
+      // first turn — the exact incident was filed on — was still logged "delivered".
       if (this.deps.terminalFailure()) {
         this.deps.sessionLog(`initial prompt attempt ${attempt} ended in a terminal provider failure (${prompt.length} chars, ${Date.now() - startedAt}ms): ${this.deps.terminalFailure()!.message}`);
       } else {
-        // #2389 — delivery used to be logged ONLY on exception, so a spawn that idled forever left no
+        // delivery used to be logged ONLY on exception, so a spawn that idled forever left no
         // evidence of whether its first prompt ever reached the provider; establishing that took
         // SQLite archaeology on retained provider state. Say so on success too.
         this.deps.sessionLog(`initial prompt delivered on attempt ${attempt} (${prompt.length} chars, ${Date.now() - startedAt}ms)`);
@@ -117,8 +117,8 @@ export class PromptCommands {
       // Nothing reached the provider, so nothing is owed — unless a turn started meanwhile, which
       // disarmInput checks: a synchronous-endpoint transport can throw after the model already ran.
       if (arm) this.deps.disarmInput(arm);
-      // #2534 — the adapter proved the provider ACCEPTED and persisted this prompt (matched to the
-      // outbound request identity) before its completion await failed (e.g. the #2425 whole-turn
+      // the adapter proved the provider ACCEPTED and persisted this prompt (matched to the
+      // outbound request identity) before its completion await failed (e.g. the whole-turn
       // abort on a long first turn). The provider is already working on it, so requeueing would
       // run the same assignment a second time — and with the acceptance-keyed markers retained,
       // the retry would also no longer carry the launch briefing. Drop it like a normal success.
@@ -187,13 +187,13 @@ export class PromptCommands {
     // Mark so the matching UserPromptSubmit echo isn't double-posted: a chat-box
     // prompt already created its own session message shown in the dashboard.
     this.deps.recordInjectedPrompt(prompt.trim(), imagePaths);
-    // #1228: prompt injection is a manual dashboard "continue"/chat-box send, not the
+    // prompt injection is a manual dashboard "continue"/chat-box send, not the
     // agent's genuine first turn — never label it as the initial prompt.
-    // #2389/#2539 — offer through the ONE provider-input seam: arm the empty-turn watch at
+    // offer through the ONE provider-input seam: arm the empty-turn watch at
     // hand-off, serialize through the FIFO behind any reserved ticket, disarm on rejection.
-    // #2543 — a busy recipient (the adapter answered with the shared turn-in-progress signal
+    // a busy recipient (the adapter answered with the shared turn-in-progress signal
     // instead of an unguarded start) DEFERS: bounded wait for the provider turn to clear, then
-    // one re-offer on the idle path through a fresh FIFO slot — the same shape as the #2539
+    // one re-offer on the idle path through a fresh FIFO slot — the same shape as the
     // context-injection defer. A timed-out wait (or any other failure) throws so the command
     // fails visibly — never a silent drop.
     const submitHeld = (outcome: string) => outcome === "submit-held";
@@ -216,7 +216,7 @@ export class PromptCommands {
     return { injected: true, messageId, attachmentCount: attachments.length };
   }
 
-  // #1173: the resolution side of the deny-then-hold AskUserQuestion flow (see control-server.ts's
+  // the resolution side of the deny-then-hold AskUserQuestion flow (see control-server.ts's
   // handlePermissionRequest). By the time this fires, the original PreToolUse hook has long since
   // been answered with `deny` — there's no live HTTP request to respond to — so the human's answer
   // (or dismissal) is delivered by clearing the pending-question hold and injecting a normal
@@ -234,9 +234,9 @@ export class PromptCommands {
       return;
     }
     this.deps.recordInjectedPrompt(text.trim());
-    // #1228: this resolves a held AskUserQuestion mid-session — never the initial prompt.
-    // #2389/#2539 — the answer unblocks a turn that is waiting on it, so it arms.
-    // #2543 — offered through the same seam with the same busy policy: the adapter's shared
+    // this resolves a held AskUserQuestion mid-session — never the initial prompt.
+    // the answer unblocks a turn that is waiting on it, so it arms.
+    // offered through the same seam with the same busy policy: the adapter's shared
     // turn-in-progress refusal defers (bounded turn-clear wait + one re-offer) instead of an
     // unguarded start; any other failure stays best-effort logged, exactly as before.
     const deliver = async (inputObserver?: ProviderInputObserver) => {

package/src/agent-runner/credentials.ts

@@ -14,13 +14,13 @@ interface CredentialsDeps {
   publishRenewalFailure(): void;
   logRunnerDiagnostic(message: string): void;
   reportBackgroundRejection(scope: string, status: string, title: string, error: unknown): void;
-  /** Recovery gave up: the runner must exit so Relay sees a terminal failure, not a mint loop (#3775). */
+  /** Recovery gave up: the runner must exit so Relay sees a terminal failure, not a mint loop. */
   onTerminalAuthFailure(reason: string): void;
 }
 
 const TOKEN_RENEW_LOG_INTERVAL_MS = 5 * 60 * 1000;
 const TOKEN_RENEW_RETRY_MS = 60_000;
-// #3775 — a successful mint does not prove the hub accepts the runner: an orphaned runner kept
+// a successful mint does not prove the hub accepts the runner: an orphaned runner kept
 // getting 401 on its fresh token and re-minted ~2/s. Auth recoveries back off (1 s doubling to
 // 5 min, jittered) and stop after a bounded count; only a quiet spell resets the count.
 export const AUTH_RECOVERY_MAX_ATTEMPTS = 10;
@@ -68,14 +68,14 @@ export class Credentials {
   }
 
   // Timer/edge callers cannot await renewal; report an escaping rejection so it cannot
-  // silently strand the runner off the bus (#1617).
+  // silently strand the runner off the bus.
   private renewRuntimeTokenInBackground(): void {
     void this.renewRuntimeToken().catch((error) => this.deps.reportBackgroundRejection("runtime token renewal", "runtime-token-renewal-failed", "Runtime token renewal aborted", error));
   }
 
   // The TTL timer cannot detect revocation: recover on auth failure, coalescing a burst into the
   // one recovery in flight or scheduled.
-  // Orchestrator re-mint heals stale/expired tokens but preserves hard revocation (#484).
+  // Orchestrator re-mint heals stale/expired tokens but preserves hard revocation.
   recoverRuntimeTokenAfterAuthFailure(source: string): void {
     if (this.deps.isStopped() || this.authRecoveryExhausted || this.tokenRotation.inFlight || this.authRecoveryTimer) return;
     if (!this.isRuntimeTokenRenewable() && !this.canRemintViaOrchestrator()) return;
@@ -212,7 +212,7 @@ export class Credentials {
     }
   }
 
-  // #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.
   async remintRuntimeTokenAtBoundary(reason: "clear" | "compact"): Promise<Record<string, unknown>> {
     try {
       // Queued behind a renewal in flight, so it re-derives from the token that renewal installs.

package/src/agent-runner/inbox.ts

@@ -10,7 +10,7 @@ export async function bootstrapUnreadMessages(http: Pick<HumwickHttpClient, "pol
   } catch (error) { logger.error("runner", `inbox bootstrap failed: ${error}`); }
 }
 
-/** Keep startup failure visible to each sender, including mail queued before the check (#3751). */
+/** Keep startup failure visible to each sender, including mail queued before the check. */
 export async function reportUnavailableMessages(
   http: Pick<HumwickHttpClient, "sendMessage" | "markRead">, agentId: string,
   pending: Map<number, Message>, settled: Set<number>, reason: string,

package/src/agent-runner/lifecycle-milestones.ts

@@ -91,7 +91,7 @@ export class LifecycleMilestones {
   private backgroundStopped(): void {
     this.deps.stopAttachmentCacheSweep();
     this.deps.stopTestRunDedupSweep();
-    // #2389 — before the shutdown await, not after: an escalation or settle timer firing during a
+    // before the shutdown await, not after: an escalation or settle timer firing during a
     // graceful provider shutdown would publish a "produced nothing" verdict about a turn the
     // shutdown itself ended.
     this.deps.disposeEmptyTurns();
@@ -103,7 +103,7 @@ export class LifecycleMilestones {
   }
 
   private async providerShutDown(): Promise<void> {
-    // #2491 review MED-1 — time-boxed like the other two settleTerminalTokenUsage call
+    // review MED-1 — time-boxed like the other two settleTerminalTokenUsage call
     // sites (restartUnexpectedProviderExit, runPreSessionDestroy): an unsettled capture
     // must not eat into the graceful-shutdown grace window and push the provider toward a
     // forced SIGKILL.
@@ -163,7 +163,7 @@ export class LifecycleMilestones {
     this.deps.clearProviderTurnWork();
     this.deps.clearSubagentWork();
     this.deps.clearBackgroundScriptWork();
-    // #2389 — a pre-restart obligation must never be charged against an unrelated post-restart
+    // a pre-restart obligation must never be charged against an unrelated post-restart
     // turn. Covers every restart, including the suppressPrompt one recoverNativeSelfResumeExit
     // takes, where the agent comes back with no prompt at all.
     this.deps.resetEmptyTurns();

package/src/agent-runner/lifecycle-phase.ts

@@ -11,7 +11,7 @@ export class LifecyclePhase {
   // hooks, watchers and semantic heartbeats, but deliberately does NOT pin the runner projection
   // offline: runner-owned lifecycle pills remain visible until teardown actually completes.
   private terminalStatusLatchedValue = false;
-  // #2414: signal intent must suppress restart without skipping stop() teardown.
+  // signal intent must suppress restart without skipping stop teardown.
   private shuttingDownValue = false;
   private exitCommandInProgressValue = false;
   private restartInProgressValue = false;
@@ -32,7 +32,7 @@ export class LifecyclePhase {
 
   constructor(private readonly deps: LifecyclePhaseDeps) {}
 
-  // #2414: latch synchronously in the signal handler, before child exit callbacks.
+  // latch synchronously in the signal handler, before child exit callbacks.
   markShuttingDown(): void {
     this.shuttingDownValue = true;
     if (!this.lifecycleActionValue) this.setLifecycleAction("shutting-down");

package/src/agent-runner/liveness-exchange.ts

@@ -15,16 +15,14 @@ interface LivenessExchangeDeps {
   isStopped(): boolean;
   isTerminalStatusLatched(): boolean;
   currentStatus: ClaimTracker["currentStatus"];
-  sampleQuota(): Promise<Pick<HeartbeatReport, "providerQuota" | "quotaLeaseToken"> | undefined>;
-  acceptQuota(report: HeartbeatReport, result: HeartbeatResult["providerQuota"]): void;
   enqueueMessage(message: Message): void;
   triggerEffort(): void;
   recoverRuntimeTokenAfterAuthFailure(source: string): void;
   logRunnerDiagnostic(message: string): void;
 }
 
-/** The runner's periodic liveness exchange (#3608). It rides the registered bus socket and falls
- *  back to HTTP while the socket is down or the exchange fails on it (#3618). */
+/** The runner's periodic liveness exchange. It rides the registered bus socket and falls
+ *  back to HTTP while the socket is down or the exchange fails on it. */
 export class LivenessExchange {
   private timer?: Timer;
   private inFlight = false;
@@ -54,13 +52,9 @@ export class LivenessExchange {
     const status = this.deps.currentStatus();
     const agentStatus = runnerAgentStatus(status);
     try {
-      const quota = await this.deps.sampleQuota().catch((error) => {
-        this.deps.logRunnerDiagnostic(`passive provider quota sample failed: ${errMessage(error)}`);
-      });
-      // #3608 — inbox recovery and fresh quota samples ride the single liveness exchange.
-      const report: HeartbeatReport = { status: agentStatus, ready: agentStatus !== "offline", unread: true, ...quota };
+      // inbox recovery rides the single liveness exchange.
+      const report: HeartbeatReport = { status: agentStatus, ready: agentStatus !== "offline", unread: true };
       const result = await this.exchange(report);
-      this.deps.acceptQuota(report, result?.providerQuota);
       for (const message of result?.messages ?? []) this.deps.enqueueMessage(message);
       this.deps.triggerEffort();
     } catch (error) {