@humwick/runner 0.130.5 → 0.130.6

package/src/liveness.ts

@@ -1,15 +1,15 @@
 import { PROVIDER_TURN_EMPTY_TIMELINE_STATUS, PROVIDER_TURN_WATCHDOG_TIMELINE_STATUS, RECONCILED_TURN_TIMELINE_STATUS } from "@humwick/sdk";
 import type { BusyPhase, LivenessSignal } from "@humwick/sdk";
 
-// #2010 — these timeline statuses are the runner ADMITTING it could not confirm progress (a
-// held-but-unproven turn), an end (a force-cleared one), or — #2389 — a turn that demonstrably
+// these timeline statuses are the runner ADMITTING it could not confirm progress (a
+// held-but-unproven turn), an end (a force-cleared one), or — a turn that demonstrably
 // produced NOTHING. Folding their `timestamp` in as
 // progress would be circular: the watchdog fires exactly when the runner has NO positive
 // evidence, yet its own publish (`timestamp: now`) would otherwise stamp that same status frame
 // as freshly-progressing, poisoning any consumer (e.g. the server's prolonged-hold coordinator
-// wake, #2010) that reads `lastProgressAt` off it. Every OTHER timeline transition (e.g. Claude's
+// wake) that reads `lastProgressAt` off it. Every OTHER timeline transition (e.g. Claude's
 // `compacting`) is genuine forward progress and must keep counting.
-// #2389 belongs here most sharply of the three: an empty-turn event is the runner reporting the
+// belongs here most sharply of the three: an empty-turn event is the runner reporting the
 // ABSENCE of output, so stamping its own publish as fresh progress would let the frame that says
 // "this agent did nothing" be read as evidence that it just did something.
 const NON_PROGRESS_TIMELINE_STATUSES: ReadonlySet<string> = new Set([
@@ -19,7 +19,7 @@ const NON_PROGRESS_TIMELINE_STATUSES: ReadonlySet<string> = new Set([
 ]);
 
 // The raw runner-tracked signals an adapter folds into a normalized LivenessSignal.
-// This is the INPUT to the contract computation (#746): the runner owns this state
+// This is the INPUT to the contract computation: the runner owns this state
 // (transport frames, the last provider event, the pending timeline transition, the
 // active-work set), passes it to the adapter's `liveness()` verdict, and ships the
 // resulting LivenessSignal on the agent card. Provider-raw interpretation stops here —
@@ -36,12 +36,12 @@ export interface LivenessInputs {
   activeWork: Array<{ kind?: string; startedAt?: number }>;
   /** Fallback progress floor when no other progress evidence exists yet (e.g. work start). */
   fallbackProgressAt?: number;
-  /** #1980 — the runner's coarse provider status (`claims.currentStatus()`), used together with
+  /** the runner's coarse provider status (`claims.currentStatus`), used together with
    *  `providerBlocked` + `activeWork` to derive {@link LivenessSignal.busyPhase}. Provider-agnostic:
    *  `busy` + a live provider-turn ⇒ `active` (the provider is doing turn work — including a
    *  token-silent foreground `shell` gate), regardless of which provider. Omitted → no phase. */
   providerStatus?: "idle" | "busy" | "offline" | "error";
-  /** #1980 — the runner's provider-hold flag (rate-limit / pendingQuestion / a `blocked`
+  /** the runner's provider-hold flag (rate-limit / pendingQuestion / a `blocked`
    *  providerState, e.g. Claude `waiting`). When set, the phase is `blocked` — the provider is
    *  parked, not actively computing — and takes precedence over `active`. */
   providerBlocked?: boolean;
@@ -52,7 +52,7 @@ function num(value: unknown): number {
 }
 
 /**
- * The shared liveness fold (#725 / #746). Both reference adapters (Claude #713, Codex #724)
+ * The shared liveness fold. Both reference adapters
  * route through this so the verdict is computed in ONE place; each adapter's `liveness()`
  * decides WHICH raw signals it feeds in (Claude surfaces a `compacting` timeline transition
  * as progress; Codex surfaces live subprocess work-kinds). The fold itself is provider-
@@ -63,8 +63,8 @@ export function computeLivenessSignal(inputs: LivenessInputs): LivenessSignal {
     num(inputs.transport?.lastServerFrameAt),
     num(inputs.transport?.lastHeartbeatAckAt),
   );
-  // Progress = provider tokens OR a lifecycle/timeline transition (e.g. native compaction,
-  // #713) — whichever is latest, with the caller-supplied floor as the baseline. #2010: a
+  // Progress = provider tokens OR a lifecycle/timeline transition (e.g. native compaction)
+  // — whichever is latest, with the caller-supplied floor as the baseline. A
   // timeline event that is itself an admission of no-confirmed-progress (the prolonged-hold
   // watchdog, or a reconciled/force-cleared turn) must NOT count as progress — see
   // NON_PROGRESS_TIMELINE_STATUSES above.
@@ -77,7 +77,7 @@ export function computeLivenessSignal(inputs: LivenessInputs): LivenessSignal {
     timelineProgressAt,
     num(inputs.fallbackProgressAt),
   );
-  // Any work-kind that is NOT the bare provider turn is live tool/subprocess work (#724):
+  // Any work-kind that is NOT the bare provider turn is live tool/subprocess work:
   // a wedged provider turn with a live `bun test` child must read as progressing.
   const hasLiveWork = inputs.activeWork.some((work) => Boolean(work.kind && work.kind !== "provider-turn"));
   const busyPhase = deriveBusyPhase(inputs, hasLiveWork);
@@ -85,15 +85,15 @@ export function computeLivenessSignal(inputs: LivenessInputs): LivenessSignal {
 }
 
 /**
- * #1980 / #1069 — derive the coarse {@link BusyPhase} from the runner's own state. Provider-
- * agnostic by construction (the point of the #746 contract): a live `provider-turn` while the
+ * derive the coarse {@link BusyPhase} from the runner's own state. Provider-
+ * agnostic by construction (the point of the contract): a live `provider-turn` while the
  * runner status is `busy` is `active` for EVERY provider — for Claude that already covers both
  * `busy` (thinking) and `shell` (a foreground gate), and for Codex it covers `inProgress`,
  * because the adapter mints/holds the `provider-turn` work-kind for exactly those states. A
  * provider hold (`providerBlocked`) is `blocked` and wins over `active` (a parked turn is not
- * computing). Otherwise, live background-script work with no active turn is `passive` (#1856).
+ * computing). Otherwise, live background-script work with no active turn is `passive`.
  * `hasLiveWork` stays the narrower "is there background-script work" projection so its existing
- * stuck-busy veto (#724, a live `bun test` child during an active turn) is unchanged; `passive`
+ * stuck-busy veto (a live `bun test` child during an active turn) is unchanged; `passive`
  * always implies `hasLiveWork`, but `active` deliberately does not.
  */
 function deriveBusyPhase(inputs: LivenessInputs, hasLiveWork: boolean): BusyPhase | undefined {

package/src/logger.ts

@@ -4,7 +4,7 @@ import { sanitizeFsName } from "@humwick/sdk/fs-name";
 import { logDirFromEnv, logLevelFromEnv } from "./config";
 import { appendBoundedLog, RUNNER_LOG_MAX_BYTES, RUNNER_LOG_RECORD_MAX_BYTES } from "./bounded-log";
 
-// Phase 1 observability (#198): one leveled, runtime-togglable logger for the
+// Phase 1 observability: one leveled, runtime-togglable logger for the
 // Runner and the provider adapters below it. Replaces the ad-hoc scatter of
 // `console.error`, `logRunnerDiagnostic` (-> runner-<agent>.log) and
 // `sessionLog`/`sessionDebug` (-> session-mirror-<agent>.log) with a single
@@ -14,7 +14,7 @@ import { appendBoundedLog, RUNNER_LOG_MAX_BYTES, RUNNER_LOG_RECORD_MAX_BYTES } f
 // already surfaces to the dashboard log-viewer (captureSessionMirror). One place
 // to look when anything in the Runner misbehaves.
 //
-// Level is read once from AGENT_RELAY_LOG_LEVEL (default "info") and can be
+// Level is read once from HUMWICK_LOG_LEVEL (default "info") and can be
 // flipped at runtime via the control port (no restart) — so a phase refactor can
 // be watched at debug without bouncing the agent.
 
@@ -55,7 +55,7 @@ export class Logger {
     this.level = config.level ?? parseLogLevel(logLevelFromEnv()) ?? "info";
     this.agentId = config.agentId ?? "runner";
     this.headless = config.headless ?? false;
-    this.logDir = config.logDir ?? logDirFromEnv() ?? join(process.env.HOME || ".", ".agent-relay", "logs");
+    this.logDir = config.logDir ?? logDirFromEnv() ?? join(process.env.HOME || ".", ".humwick", "logs");
     this.logFileMaxBytes = config.logFileMaxBytes ?? RUNNER_LOG_MAX_BYTES;
   }
 

package/src/mcp-outbox.ts

@@ -108,7 +108,7 @@ async function deliverSessionBatchItems(input: RunnerOutboxDelivery, messages: S
 }
 
 // Deterministic session validation rejections are classified once in runner-helpers.ts
-// (isDeterministicClientError) and shared with the outbox poison policy (#2433).
+// (isDeterministicClientError) and shared with the outbox poison policy.
 
 function sessionBatchItemKeys(record: OutboxRecord): string[] {
   const messages = sessionBatchMessages(record);
@@ -122,7 +122,7 @@ function sessionBatchMessages(record: OutboxRecord): SendMessageInput[] {
 }
 
 // The subset of RunnerOutboxDelivery the notice seam needs — also satisfied by the narrower
-// Outbox.onPoison call site (#2433), which only holds the poisoned record + the HTTP client.
+// Outbox.onPoison call site, which only holds the poisoned record + the HTTP client.
 type MirrorDropNoticeSource = Pick<RunnerOutboxDelivery, "record"> & { http: HumwickHttpClient };
 
 async function emitMirrorDropNotice(input: MirrorDropNoticeSource, messages: SendMessageInput[], count: number, reason: string, suffix: string): Promise<void> {
@@ -158,7 +158,7 @@ function shortHash(value: string): string {
   return (h >>> 0).toString(36);
 }
 
-// #2433 — the Outbox.onPoison seam for SESSION rows. A permanently-dropped session-message /
+// the Outbox.onPoison seam for SESSION rows. A permanently-dropped session-message /
 // batch is REAL report-up/mirror loss (chat replyTo lineage rides the session outbox), so
 // surface it in-session through the same notice channel as duplicate/invalid drops instead
 // of only in a FATAL host log. Non-session kinds carry no chat lineage to notify about.

package/src/mcp-preflight.ts

@@ -3,7 +3,7 @@ import { hostname } from "node:os";
 import { basename, isAbsolute } from "node:path";
 import { PORTABLE_SHARED_MCP_SERVER_NAMES, activeSharedMcpServers, portableMcpDescriptorPath, type PortableMcpDescriptor, type ProvisioningMcpServer } from "@humwick/sdk";
 
-// #2729 — a registry descriptor is authored on one host (e.g. the hub's `~/.npm-global/bin/<server>`)
+// a registry descriptor is authored on one host (e.g. the hub's `~/.npm-global/bin/<server>`)
 // but launched on any. A stdio command that does not exist on THIS host would reach the agent as a
 // broken server ("MCP server failed to start (ENOENT)"). A core shared server (tokenlean/...) is
 // swapped for the descriptor this host's orchestrator provisioned (same binary + URL the shared
@@ -35,7 +35,7 @@ export interface McpPreflightOptions {
   sharedListener: boolean;
   /** Names exempt from the check (their command is provisioned after launch resolution). */
   skip?: readonly string[];
-  /** AGENT_RELAY_HOME of this host, where the orchestrator records provisioned core descriptors. */
+  /** HUMWICK_HOME of this host, where the orchestrator records provisioned core descriptors. */
   home?: string;
 }
 

package/src/mcp-source-selection.ts

@@ -22,7 +22,7 @@ export interface McpSourceSelection {
   sourceShadows: ResolvedSourceShadow[];
 }
 
-// #2368 — providers load their native host declarations, then share this precedence policy.
+// providers load their native host declarations, then share this precedence policy.
 // Serialization, service-access overlays and tool deferral consume the selected sources.
 export function resolveMcpSources(
   config: RunnerSpawnConfig,
@@ -39,7 +39,7 @@ export function resolveMcpSources(
   );
   const projectServers = Object.keys(projectMcp);
 
-  // #2114 — sharedMcp is a resolved sibling opt-in, independent of ambient H.mcp.
+  // sharedMcp is a resolved sibling opt-in, independent of ambient H.mcp.
   const sharedListenerUrl = config.agentProfile?.sharedMcp ? resolveSharedMcpUrl(config.sharedMcpUrl) : undefined;
   const sharedMcp: Record<string, ProvisioningMcpServer> = sharedListenerUrl
     ? { [SHARED_MCP_SERVER_NAME]: sharedMcpBridgeServer(sharedListenerUrl, config.cwd) }

package/src/mcp-tool-deferral.ts

@@ -28,7 +28,7 @@ export function runnerManagedRelayOnDemandTools(
     || !isCodexLeanWorkerProfile(profile?.name)
     || !profile?.sharedMcp
     || profile.relay?.mcp === false
-    // #3024 — a switched-off web tool keeps the flat bridge (launch-assembly), so nothing fronts this set.
+    // a switched-off web tool keeps the flat bridge (launch-assembly), so nothing fronts this set.
     || WEB_TOOL_NAMES.some((name) => !profileWebToolEnabled(profile, name))
   ) return undefined;
   return new Set(CODEX_WORKER_ONDEMAND_TOOLS);

package/src/mcp-vault-env.ts

@@ -4,11 +4,11 @@ import { shellQuote } from "@humwick/sdk/shell-utils";
 
 /** Codex has env_vars inheritance but no Claude-style interpolation in stdio env. */
 export function codexVaultMcpEnv(server: ProvisioningMcpServer): ProvisioningMcpServer {
-  const env = writeChildEnv({}, { ...server.env });
+  const env = writeChildEnv({}, { ...server.env }, []);
   const assignments: string[] = [];
   const slots = new Set<string>();
   for (const [key, value] of Object.entries(env)) {
-    const match = /^\$\{(AGENT_RELAY_VAULT_[A-F0-9]{24})\}$/.exec(value);
+    const match = /^\$\{(HUMWICK_VAULT_[A-F0-9]{24})\}$/.exec(value);
     if (!match) continue;
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || !server.command) throw new Error("Invalid vault MCP environment projection");
     assignments.push(`export ${key}="\${${match[1]}:?}"`);

package/src/message-body-config/config.ts

@@ -1,16 +1,16 @@
 import { relayEnv } from "@humwick/sdk/env";
 export function messageBodyMaxCharsFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_MESSAGE_BODY_MAX_CHARS");
+  return relayEnv(process.env, "HUMWICK_MESSAGE_BODY_MAX_CHARS");
 }
 
-// #1935 — the Claude Code monitor delivery caps (empirically measured against the live harness on
+// the Claude Code monitor delivery caps (empirically measured against the live harness on
 // 2026-08-02: ~3000 chars per delivered event, ~500 chars per line). Overridable per deployment,
 // since the right ceiling tracks the host's harness build — set on the host/orchestrator that
 // spawns runners. See DEFAULT_MONITOR_DELIVERY_* in adapter.ts for the resolved defaults.
 export function monitorDeliveryMaxCharsFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_MONITOR_DELIVERY_MAX_CHARS");
+  return relayEnv(process.env, "HUMWICK_MONITOR_DELIVERY_MAX_CHARS");
 }
 
 export function monitorDeliveryLineMaxCharsFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_MONITOR_DELIVERY_LINE_MAX_CHARS");
+  return relayEnv(process.env, "HUMWICK_MONITOR_DELIVERY_LINE_MAX_CHARS");
 }

package/src/mid-turn-delivery.ts

@@ -1,4 +1,4 @@
-// #2539 Phase A — the shared soft-steer foundation.
+// Phase A — the shared soft-steer foundation.
 //
 // One adapter-owned eligibility decision (`partitionMidTurnDelivery`), one config seam
 // (`resolveActiveTurnMessageDelivery`) and one acceptance-correlation id (`midTurnClientUserId`),
@@ -32,7 +32,7 @@ function isSteerableMidTurnMessage(message: Message): boolean {
 }
 
 /**
- * Stable acceptance-correlation id for one steered composition (#2539 design C). Derived from
+ * Stable acceptance-correlation id for one steered composition. Derived from
  * the ordered batch ids, so a re-offer of the SAME subset reuses the id: the app-server echoes
  * it back as the `userMessage.clientId` item field, and an echo observed after a lost steer
  * response lets the next offer settle by correlation instead of re-steering (which would

package/src/native-memory-lever.ts

@@ -1,5 +1,5 @@
 import { writeChildEnv } from "@humwick/sdk/env";
-// #1565 P5.7 (design §10.3) — the provider-NATIVE-memory lever.
+// P5.7 (design §10.3) — the provider-NATIVE-memory lever.
 //
 // WHAT THIS IS FOR. Every agent today can carry two competing memory stores: relay memory (which
 // survives a respawn) and the provider's own (which, for 8 of 11 built-in profiles, is destroyed
@@ -27,7 +27,7 @@ import { writeChildEnv } from "@humwick/sdk/env";
 //
 // NEVER THROWS. Resolution is total: any unexpected input degrades to "nothing applied, reported
 // as suppressed" rather than propagating. A failure to apply this lever must not fail a spawn
-// (the #1612 discipline, applied to the switch instead of the preamble) — an agent that launches
+// (the discipline, applied to the switch instead of the preamble) — an agent that launches
 // with its native memory still on is a two-store agent, which is exactly today's state; an agent
 // that fails to launch is an outage.
 
@@ -63,7 +63,7 @@ export interface NativeMemoryLever {
   /** The levers that actually reach this launch, as short stable ids for the projection report. */
   applied: string[];
   /** Levers that were resolved but could NOT be delivered on this base/provider. Reported LOUDLY
-   *  (the `hooksSuppressed` precedent, #1096) so a lever is never silently absent while the
+   *  so a lever is never silently absent while the
    *  report claims it applied. */
   suppressed?: { reason: string; levers: string[] };
 }
@@ -107,7 +107,7 @@ function resolveClaudeLever(
   // The env var is unconditional and authoritative — it works on EVERY base, host included, and
   // outranks the settings read inside the CLI's own predicate.
   const disable = policy === "off";
-  const env = writeChildEnv({}, { [CLAUDE_DISABLE_AUTO_MEMORY_ENV]: disable ? "1" : "0" });
+  const env = writeChildEnv({}, { [CLAUDE_DISABLE_AUTO_MEMORY_ENV]: disable ? "1" : "0" }, []);
   const applied = [`env:${CLAUDE_DISABLE_AUTO_MEMORY_ENV}=${disable ? "1" : "0"}`];
 
   const settings: Record<string, unknown> = { [CLAUDE_AUTO_MEMORY_ENABLED_SETTING]: !disable };
@@ -179,7 +179,7 @@ type NativeMemoryLeverRenderer = (
   input: ResolveNativeMemoryLeverInput,
 ) => NativeMemoryLever;
 
-// #2513 — the claude renderer is shared by every claude-family provider id (claude-b reuses
+// the claude renderer is shared by every claude-family provider id (claude-b reuses
 // the claude adapter/launch path whole), so the absent⇒off invariant holds for it too.
 const claudeLeverRenderer: NativeMemoryLeverRenderer = (policy, input) => resolveClaudeLever(
   policy,
@@ -238,7 +238,7 @@ export function resolveNativeMemoryLever(input: ResolveNativeMemoryLeverInput):
       suppressed: { reason: `provider ${input.provider} has no known native-memory lever; nothing was applied`, levers: ["nativeMemory"] },
     };
   } catch (err) {
-    // The fail-safe (#1612's discipline applied to the switch). A lever we could not compute must
+    // The fail-safe (discipline applied to the switch). A lever we could not compute must
     // degrade to "not applied, loudly reported" — never to a failed spawn.
     return {
       ...none(),
@@ -293,7 +293,7 @@ export function claudeManagedNativeMemorySettings(
 }
 
 /**
- * The fail-safe at the APPLY seam (#1612's discipline, moved from the preamble to the switch). The
+ * The fail-safe at the APPLY seam (discipline, moved from the preamble to the switch). The
  * file-channel belt is best-effort by construction: the authoritative lever is the env var / `-c`
  * arg, computed into the launch and touching no disk, so a failed belt write costs nothing an
  * operator can observe — while a THROW here would fail the whole spawn. So: never propagate, and
@@ -305,7 +305,7 @@ export function applyNativeMemoryBelt(label: string, apply: () => void): string
     return undefined;
   } catch (err) {
     const reason = `native-memory lever: ${label} could not be written: ${(err as Error)?.message ?? String(err)}. `
-      + "The authoritative env/argv lever still applies (it outranks the file channel), and the spawn continues — design #1565 §10.3.";
+      + "The authoritative env/argv lever still applies (it outranks the file channel), and the spawn continues — design §10.3.";
     console.warn(reason);
     return reason;
   }

package/src/outbox.ts

@@ -8,7 +8,7 @@ import { logger } from "./logger";
 import { runnerOutboxDirFromEnv } from "./config";
 import { isDeterministicClientError, isTransientDeliveryError } from "./runner-helpers";
 
-// Phase 2 (#196) — the "nothing is ever lost" half. Runner→server events that used to be
+// Phase 2 — the "nothing is ever lost" half. Runner→server events that used to be
 // fire-and-forget over HTTP (session turns, reasoning/tool traces, prompt echoes, insights,
 // hook-fatal reports) were silently dropped whenever the server was momentarily down. This
 // is a durable, FIFO, disk-backed queue that:
@@ -18,7 +18,7 @@ import { isDeterministicClientError, isTransientDeliveryError } from "./runner-h
 //     reorder turns),
 //   - poisons a DETERMINISTICALLY-failing head immediately and an unknown-failure head after
 //     maxAttempts so it can't block the queue — but NEVER poisons on attempt count for
-//     TRANSIENT (connection-class / 5xx / 429) failures (#2433): report-up chat rides this
+//     TRANSIENT (connection-class / 5xx / 429) failures: report-up chat rides this
 //     queue, so a poisoned row is real message loss. A transient head instead parks onto a
 //     slow periodic re-drive after a long CONTINUOUS-failure wall-clock budget, so an ordinary
 //     relay-restart window can't drop anything no matter how hard flush() hammers,
@@ -58,14 +58,14 @@ type OutboxSend = (record: OutboxRecord) => Promise<void>;
 interface OutboxOptions {
   agentId: string;
   send: OutboxSend;
-  // Storage directory. Defaults to AGENT_RELAY_RUNNER_OUTBOX_DIR, else a per-host temp dir.
+  // Storage directory. Defaults to HUMWICK_RUNNER_OUTBOX_DIR, else a per-host temp dir.
   dir?: string;
   maxRows?: number;
   maxAttempts?: number;
   baseBackoffMs?: number;
   maxBackoffMs?: number;
   pollMs?: number;
-  // #2433 — transient (connection-class / 5xx / 429) failures NEVER poison on attempt count.
+  // transient (connection-class / 5xx / 429) failures NEVER poison on attempt count.
   // After this much CONTINUOUS wall-clock failure on a row, park it onto a slow periodic
   // re-drive (every transientRedriveMs) instead of hot-looping, so a long relay outage still
   // recovers every frame once the relay returns. Sized to outlast any ordinary restart/deploy
@@ -75,7 +75,7 @@ interface OutboxOptions {
   // Observability seam: called when a row is actually POISONED (permanently dropped). Only
   // deterministic client rejections and unknown-class failures past maxAttempts get here —
   // never transient ones. The session outbox uses it to surface mirror/report-up loss
-  // in-session (#2433) rather than only in a FATAL host log.
+  // in-session rather than only in a FATAL host log.
   onPoison?: (record: OutboxRecord, reason: string) => void | Promise<void>;
 }
 
@@ -142,7 +142,7 @@ export class Outbox {
     this.transientRedriveMs = options.transientRedriveMs ?? DEFAULTS.transientRedriveMs;
     this.onPoison = options.onPoison;
 
-    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "agent-relay-outbox");
+    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "humwick-outbox");
     this.path = options.dir === ":memory:" ? ":memory:" : join(dir, `outbox-${safeName(this.agentId)}.sqlite`);
     if (this.path !== ":memory:") mkdirSync(dirname(this.path), { recursive: true });
 
@@ -165,7 +165,7 @@ export class Outbox {
         created_at INTEGER NOT NULL
       )
     `);
-    // Pre-#2433 databases lack the transient-park bookkeeping column (fresh CREATEs include it).
+    // Previous databases lack the transient-park bookkeeping column (fresh CREATEs include it).
     const columns = this.db.query("PRAGMA table_info(outbox)").all() as Array<{ name: string }>;
     if (!columns.some((column) => column.name === "first_failed_at")) {
       this.db.exec("ALTER TABLE outbox ADD COLUMN first_failed_at INTEGER NOT NULL DEFAULT 0");
@@ -229,13 +229,13 @@ export class Outbox {
     this.pollTimer.unref?.();
   }
 
-  // (#1617) — the ONE way a background caller starts a drain. `drain()` is a bare try/finally with
+  // the ONE way a background caller starts a drain. `drain` is a bare try/finally with
   // no catch, and drainOnce() touches SQLite outside the send() try/catch (the head SELECT, and the
   // attempt/poison UPDATEs in the failure path), so a closed or erroring database rejects it. Every
   // pump site is fire-and-forget — an enqueue microtask, start()'s initial pump and poll timer, the
   // scheduleDue wake-up — with nobody to await the promise, and Bun exits(1) on an unhandled
-  // rejection with no handler installed anywhere in the runner (#1614). That crashed the whole
-  // agent over a queue error, on a runner nothing respawns (#1618).
+  // rejection with no handler installed anywhere in the runner. That crashed the whole
+  // agent over a queue error, on a runner nothing respawns.
   //
   // Reported through this module's own existing channel (logger, same as the bound-exceeded warn
   // and the poison fatal) rather than swallowed: a pump that stops pumping is its own bug, and
@@ -248,13 +248,13 @@ export class Outbox {
   }
 
   // Drain everything we can before the process exits, ignoring per-row backoff. Used on
-  // shutdown/kill/crash (#183): the capture seam durably enqueues the end-of-session
+  // shutdown/kill/crash: the capture seam durably enqueues the end-of-session
   // Insights datapoint, but the per-agent outbox is never reopened once the agent is gone,
   // so a row that hasn't been POSTed yet is stranded forever. flush() blocks (bounded) on
   // delivery — the opposite intent of the polite, backoff-respecting steady-state drain.
   // Returns true if the queue fully drained within the deadline.
   //
-  // #2433: the forced 150ms retry loop here used to consume the per-row attempt/poison
+  // the forced 150ms retry loop here used to consume the per-row attempt/poison
   // budget, so <2s of relay downtime at a flush boundary poisoned frames. Force-drain
   // failures no longer burn the TRANSIENT poison budget (see drainOnce) — flush() can
   // hammer as hard as it likes during an outage without ever pushing a row toward poison.
@@ -314,7 +314,7 @@ export class Outbox {
         const reason = errMessage(error);
         const transient = isTransientDeliveryError(error);
         const deterministic = !transient && isDeterministicClientError(error);
-        // #2433: flush()'s forced loop hammers every 150ms while ignoring backoff; letting
+        // flush's forced loop hammers every 150ms while ignoring backoff; letting
         // those passes consume the TRANSIENT attempt budget is what let a <2s relay restart
         // window poison frames at a flush boundary. Forced drains of transient failures
         // therefore burn NO attempt budget — classification still applies, counting does
@@ -328,7 +328,7 @@ export class Outbox {
         }
 
         if (transient) {
-          // Never poisoned on attempt count (#2433): retry under backoff until either the
+          // Never poisoned on attempt count: retry under backoff until either the
           // relay returns (the row delivers) or the CONTINUOUS-failure wall-clock budget
           // runs out and the row parks onto a slow periodic re-drive cadence.
           const firstFailedAt = row.first_failed_at > 0 ? row.first_failed_at : now;
@@ -369,7 +369,7 @@ export class Outbox {
   }
 
   // Permanently drop a row. Only reachable for deterministic client rejections (immediately)
-  // or unknown-class failures past maxAttempts — NEVER for transient ones (#2433). The
+  // or unknown-class failures past maxAttempts — NEVER for transient ones. The
   // onPoison seam lets the session outbox surface the loss in-session instead of only in
   // this FATAL host log.
   private async poisonRow(row: Row, attempts: number, reason: string, immediate: boolean): Promise<void> {

package/src/pending-permission-store.ts

@@ -29,7 +29,7 @@ export class PendingPermissionStore {
   readonly path: string;
 
   constructor(options: { agentId: string; dir?: string }) {
-    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "agent-relay-outbox");
+    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "humwick-outbox");
     this.path = options.dir === ":memory:" ? ":memory:" : join(dir, `pending-permissions-${safeName(options.agentId)}.sqlite`);
     try {
       if (this.path !== ":memory:") mkdirSync(dirname(this.path), { recursive: true });

package/src/profile-home.ts

@@ -32,7 +32,7 @@ export function profileAllowsHostGlobalInstructions(config: { agentProfile?: Run
  *
  * The predicate itself lives in the sdk ({@link sdkProjectSettingSourcesOn}) so the
  * effective-profile survey and the v2 cell deriver stay in step with the runner's
- * actual launch derivation — see #2084.
+ * actual launch derivation —.
  */
 export function projectSettingSourcesOn(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
   const profile = config.agentProfile;
@@ -46,14 +46,14 @@ export function projectSettingSources(config: { agentProfile?: RunnerSpawnConfig
   return projectSettingSourcesOn(config) ? ["user", "project"] : ["user"];
 }
 
-// #3387 — every runner-managed profiled launch runs in a Relay-owned home; `base:"host"` only
+// every runner-managed profiled launch runs in a Relay-owned home; `base:"host"` only
 // changes which host classes an omitted Host field inherits (see hostSourcesFor). A profile-less
 // launch is a user's own wrapped session and keeps the provider's native home.
 function profileRequiresIsolatedHome(config: RunnerSpawnConfig): boolean {
   return Boolean(config.agentProfile);
 }
 
-// #557 — PURE: the Relay-owned provider config home path a launch WILL use, or undefined for a
+// PURE: the Relay-owned provider config home path a launch WILL use, or undefined for a
 // profile-less launch (the provider's normal home). The launch assembler computes the home this way
 // to report it + build CLAUDE_CONFIG_DIR/skill/plugin paths without side effects;
 // prepare*ProfileHome creates it at the same path at spawn time.
@@ -78,7 +78,7 @@ export function providerHomePathFor(provider: SpawnProvider, config: RunnerSpawn
 // the repo's CLAUDE.md / AGENTS.md as behavioral instructions, NOT "don't
 // operate here" — an isolated agent must still read/edit/execute in its own cwd.
 //
-// #2254 — host-base launches skip the onboarding/theme bootstrap (an
+// host-base launches skip the onboarding/theme bootstrap (an
 // onboarded host config already answers those), but they do NOT dodge folder trust:
 // --dangerously-skip-permissions does not bypass the trust gate, and a cwd the host
 // config has never seen still renders the dialog and wedges the spawn. Trust is
@@ -91,20 +91,20 @@ const BOOTSTRAP_HOOKS = new Map<string, BootstrapHook>();
 /**
  * The ONE materialization seam for an instance-keyed provider home
  * (`<root>/<provider>/<profile>/<instanceId>`) — every adapter that creates one MUST route
- * through it (#2624: the OpenCode family built its home by hand, so its homes carried no
+ * through it (the OpenCode family built its home by hand, so its homes carried no
  * owner-marker and no tombstone reclaim, and the reaper skipped every one of them as
  * "unmarked" forever). `identity` must be exactly the path segments of `target`: the reaper
  * refuses a marker that does not describe its own directory.
  */
 export function materializeProviderHome(target: string, identity: { provider: string; profile: string; instanceId: string; agentId?: string }, mode?: number): void {
-  // #1256 spawn-side reclaim — FIRST recover any quarantine tombstone the reaper left for
+  // spawn-side reclaim — FIRST recover any quarantine tombstone the reaper left for
   // this exact instanceId (atomic rename back to `target`), BEFORE creating a fresh home.
   // This makes reconnection always safe (a reconnecting/resuming agent recovers its home)
   // and lets a crash-stranded tombstone self-heal. A lost reclaim race just falls through
   // to a fresh mkdir below — never a corrupt home.
   reclaimProviderHomeTombstone(target);
   mkdirSync(target, { recursive: true, ...(mode === undefined ? {} : { mode }) });
-  // #1256 — stamp the owner-marker so the reaper can later reclaim this home if it becomes
+  // stamp the owner-marker so the reaper can later reclaim this home if it becomes
   // orphaned, but only ever on THIS host (cross-host safety).
   writeProviderHomeMarker(target, identity);
 }
@@ -132,23 +132,23 @@ function prepareProviderHome(provider: SpawnProvider, config: RunnerSpawnConfig)
 export const prepareCodexProfileHome = (config: RunnerSpawnConfig) => prepareProviderHome("codex", config);
 
 /**
- * #2254 — every Claude launch, isolated or host-base, leaves this function with folder trust
+ * every Claude launch, isolated or host-base, leaves this function with folder trust
  * already granted in the config file it will read. `prepareProviderHome` returns undefined for
  * a host-base profile (and for a profile-less spawn), which is exactly the class that used to
  * be seeded nowhere and wedged on the trust dialog; `ensureClaudeWorkspaceTrust` therefore runs
  * unconditionally, targeting the shared host config when there is no isolated home.
  *
- * #2513 — provider-id-dynamic for the claude family: claude-b passes its own id so the
+ * provider-id-dynamic for the claude family: claude-b passes its own id so the
  * isolated home, bootstrap hook, and auth links resolve against `~/.claude-b` (its manifest
  * configDir), never `~/.claude`.
  */
 export const prepareClaudeProfileHome = (config: RunnerSpawnConfig, provider: SpawnProvider = "claude"): ProviderHome | undefined => {
   const home = prepareProviderHome(provider, config);
-  // #2513 review HIGH-1 — a dedicatedHome provider's host-base launch still reads the
+  // review HIGH-1 — a dedicatedHome provider's host-base launch still reads the
   // provider's OWN effective home (launch assembly exports CLAUDE_CONFIG_DIR at it), so
   // folder trust must be seeded in THAT home's .claude.json, not the shared ~/.claude.json.
   const trust = ensureClaudeWorkspaceTrust(config.cwd, home?.path ?? providerHostConfigHome(provider));
-  // A seed that did not land puts this launch straight back into the #2254 wedge — CC opens
+  // A seed that did not land puts this launch straight back into the wedge — CC opens
   // its trust dialog and the spawn hangs until a human answers. The failure modes are all
   // environmental (an unparseable or unwritable host config, an operator opt-out), so the fix
   // cannot self-heal; it must at least say so instead of failing silently the way the missing
@@ -160,7 +160,7 @@ export const prepareClaudeProfileHome = (config: RunnerSpawnConfig, provider: Sp
 };
 
 function bootstrapCodexFirstRun(codexHome: string, config: RunnerSpawnConfig): void {
-  // Keep bootstrap to one config read/write while repairing auth links (#2670).
+  // Keep bootstrap to one config read/write while repairing auth links.
   const path = join(codexHome, "config.toml");
   const current = existsSync(path) ? readFileSync(path, "utf8") : "";
   const next = withCodexWorkspaceTrust(withTomlFeatureFlag(current, "apps", false), config);
@@ -176,7 +176,7 @@ function bootstrapClaudeFirstRun(claudeHome: string, config: RunnerSpawnConfig):
 
 BOOTSTRAP_HOOKS.set("codex", bootstrapCodexFirstRun);
 BOOTSTRAP_HOOKS.set("claude", bootstrapClaudeFirstRun);
-// #2513 — the claude-b provider runs the identical claude first-run bootstrap (relay
+// the claude-b provider runs the identical claude first-run bootstrap (relay
 // manual + config seed) inside its own claude-b-keyed home.
 BOOTSTRAP_HOOKS.set("claude-b", bootstrapClaudeFirstRun);
 BOOTSTRAP_HOOKS.set("claude-api", bootstrapClaudeFirstRun);
@@ -190,7 +190,7 @@ export function providerSourceHome(provider: string): string {
 }
 
 /**
- * #2513 — the effective HOST config home a `dedicatedHome` provider (claude-b) launches
+ * the effective HOST config home a `dedicatedHome` provider (claude-b) launches
  * from when it has no isolated managed home, or undefined for the primary provider
  * (claude), whose host-base launches keep their historical behavior of falling back to
  * the binary's own resolution ($CLAUDE_CONFIG_DIR ?? ~/.claude). Callers that need one
@@ -209,7 +209,7 @@ function ensureClaudeConfigSeed(claudeHome: string, config: RunnerSpawnConfig):
     writeJsonAtomic(path, seed);
     return;
   }
-  // #1368/#harden — the isolated home is instance-keyed and PERSISTS across resumes/reconnects, so a
+  // /#harden — the isolated home is instance-keyed and PERSISTS across resumes/reconnects, so a
   // relaunch (e.g. auto-resume after a tmux/provider exit) reuses the existing `.claude.json` and
   // never re-runs the absent-file seed above. Re-heal every prompt-gate key the seed would have
   // applied on a fresh home (onboarding, theme, bypass-permissions, workspace-trust): a resumed
@@ -309,7 +309,7 @@ export async function hydrateClaudeHostConfig(config: RunnerSpawnConfig, provide
  * Loads only the seed values and host-scope MCP declaration required by a Claude launch. This
  * shared worker-pool seam gives registration projection and synchronous launch assembly the same
  * snapshot without ever parsing the host's potentially huge config on the runner event loop.
- * #2513 — keyed by provider id so a claude-family provider (claude-b) reads ITS source home.
+ * keyed by provider id so a claude-family provider (claude-b) reads ITS source home.
  */
 export async function readClaudeHostConfig(provider: SpawnProvider = "claude"): Promise<Record<string, unknown> | undefined> {
   const hostPath = join(providerSourceHome(provider), ".claude.json");
@@ -322,10 +322,10 @@ export async function readClaudeHostSettings(provider: SpawnProvider = "claude")
   return runnerHostConfigOffload().run<{ path: string; kind: "settings" }, Record<string, unknown> | undefined>("runner-claude-host-config-read", { path: settingsPath, kind: "settings" });
 }
 
-// #662 — the host USER-scope MCP servers: the top-level `mcpServers` of `~/.claude.json`.
+// the host USER-scope MCP servers: the top-level `mcpServers` of `~/.claude.json`.
 // These are the ambient host MCP a host-base Claude auto-loads on EVERY launch when NOT
 // strict (user scope is global across all projects — callmux/qmd/gh on this host). Since
-// the #662 wedge fix makes every managed launch `--strict-mcp-config` (so Claude ignores
+// the wedge fix makes every managed launch `--strict-mcp-config` (so Claude ignores
 // all on-disk config and never renders the project-`.mcp.json` enable modal), an
 // `mcp.mode:"host"` profile must re-inject these explicitly into `--mcp-config` to keep
 // honoring host mode. Deliberately NOT the project-cwd `.mcp.json` (project scope — the
@@ -356,7 +356,7 @@ function linkExistingAuthItems(sourceHome: string, targetHome: string, items: st
 
 function linkExistingPath(source: string, target: string): boolean {
   if (!existsSync(source) || existsSync(target)) return false;
-  // #2670 — existsSync follows links; a reaped auth source leaves a dangling entry behind.
+  // existsSync follows links; a reaped auth source leaves a dangling entry behind.
   if (lstatSync(target, { throwIfNoEntry: false })?.isSymbolicLink()) unlinkSync(target);
   symlinkSync(source, target);
   return true;