@humwick/runner 0.130.5 → 0.130.6

package/src/runner-exit.ts

@@ -1,7 +1,7 @@
 import { formatRunnerExitLine } from "@humwick/sdk";
 
 /**
- * #2619 — the ONLY way the runner process exits. Every exit writes the structured exit record
+ * the ONLY way the runner process exits. Every exit writes the structured exit record
  * (code + cause) to stderr first: the orchestrator parses it back from the log tail, which
  * outlives a garbage-collected systemd unit. A guard test forbids a direct process.exit anywhere
  * else in the runner.

package/src/runner-helpers.ts

@@ -22,12 +22,12 @@ interface RuntimeProviderOptions {
   effort?: string;
   approvalMode: string;
   headless: boolean;
-  /** #2773 — a headless-pipe launch has no terminal to read, write, or attach. */
+  /** a headless-pipe launch has no terminal to read, write, or attach. */
   launchMode?: LaunchMode;
   startedAt: number;
   adapter: ProviderAdapter;
   providerConfig?: ProviderConfig;
-  /** #2950 — the running process accepts an in-place effort change (see runnerEffortSwitch). */
+  /** the running process accepts an in-place effort change (see runnerEffortSwitch). */
   effortSwitch?: boolean;
 }
 
@@ -167,7 +167,7 @@ export function runnerShouldRestartUnexpectedProviderExit(
     && input.hasTerminalSession;
 }
 
-// #1258 (L3): claude prints its resume banner ANSI-dimmed — the raw log bytes are
+// (L3): claude prints its resume banner ANSI-dimmed — the raw log bytes are
 // `\x1b[2mclaude --resume <uuid>\x1b[22m`, so `claude` is immediately preceded by the SGR
 // escape's trailing `m`. A leading `\b` in the extraction regex finds no word boundary
 // (`m`→`c` are both word chars) and yields zero matches, stranding the resume id as null.
@@ -286,7 +286,7 @@ export function commandTimeoutMs(params: Record<string, unknown>, fallback = 10_
   return Math.min(raw, 60_000);
 }
 
-// #1339: the Codex adapter rejects a delivery attempted while a turn is already in progress
+// the Codex adapter rejects a delivery attempted while a turn is already in progress
 // (Codex has no queue-while-busy the way Claude's input buffer does), so the runner re-queues
 // and re-drains once the turn ends. That rejection is expected flow control, not a fault — the
 // drain loop retries roughly once a second during a long turn, so it must not spam the log.
@@ -298,14 +298,14 @@ export function shouldLogDeliveryFailure(error: unknown): boolean {
     && message !== CODEX_TURN_IN_PROGRESS_MESSAGE;
 }
 
-/** The same rejection, seen from the COMMAND side (#1565 F1): a serialized boundary payload that
+/** The same rejection, seen from the COMMAND side: a serialized boundary payload that
  *  met the turn the payload before it started is deferred until that turn ends, not failed. */
 export function isTurnInProgressDeliveryError(error: unknown): boolean {
   return errMessage(error) === CODEX_TURN_IN_PROGRESS_MESSAGE;
 }
 
 /** Command types that put a payload into the provider's single input channel, and therefore take a
- *  `ProviderInputQueue` ticket at dispatch so two of them can never interleave (#1565 F1). */
+ *  `ProviderInputQueue` ticket at dispatch so two of them can never interleave. */
 export const PROVIDER_INPUT_COMMAND_TYPES: ReadonlySet<string> = new Set(["agent.clearContext", "agent.injectContext", "prompt.inject"]);
 
 export function runtimeTokenRenewDelayMs(expiresAtSeconds: number, nowMs = Date.now()): number | undefined {
@@ -426,7 +426,7 @@ function runtimeProviderTerminalCapabilities(options: RuntimeProviderOptions): P
   return {};
 }
 
-// #557 — the agent-card projection now DESCRIBES the assembled launch (same source the
+// the agent-card projection now DESCRIBES the assembled launch (same source the
 // adapter turns into args), so it can't drift from reality. `config`/`providerConfig` are
 // the spawn inputs; when present we assemble (pure — no disk writes here) and report that.
 export function appliedAgentProfileMetadata(
@@ -512,7 +512,7 @@ export function isHttpAuthError(error: unknown): boolean {
   return status === 401 || status === 403;
 }
 
-// #2433 — outbox delivery-error classification. The runner outboxes must never poison
+// outbox delivery-error classification. The runner outboxes must never poison
 // (permanently drop) an event over a CONNECTION-class failure: report-up chat rides the
 // session outbox, so a poisoned row is real message loss. These predicates split a send()
 // rejection into TRANSIENT (connect-phase transport failure, HTTP 5xx, or 429) versus
@@ -537,7 +537,7 @@ function httpErrorStatus(error: unknown): number | undefined {
   return typeof status === "number" ? status : undefined;
 }
 
-// TRANSIENT for the outbox retry policy (#2433): connection-class transport failures plus
+// TRANSIENT for the outbox retry policy: connection-class transport failures plus
 // HTTP 5xx/429 (relay momentarily overloaded/restarting). Transient failures NEVER poison on
 // attempt count — the outbox parks the head on a slow periodic re-drive until the relay returns.
 export function isTransientDeliveryError(error: unknown): boolean {
@@ -546,7 +546,7 @@ export function isTransientDeliveryError(error: unknown): boolean {
   return status !== undefined && (status >= 500 || status === 429);
 }
 
-// DETERMINISTIC client rejection (#2433): the relay is up, parsed the payload, and will refuse
+// DETERMINISTIC client rejection: the relay is up, parsed the payload, and will refuse
 // it every time. Poison immediately so one genuinely-bad row cannot stall the queue.
 export function isDeterministicClientError(error: unknown): boolean {
   const status = httpErrorStatus(error);

package/src/runner-insights.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceMetadata } from "@humwick/sdk";
+import { renderContinuationArchive, type WorkspaceMetadata } from "@humwick/sdk";
 import type { ManagedProcess, ProviderAdapter } from "./adapter";
 import type { Outbox } from "./outbox";
 import type { SessionDestroyReason } from "./session-destroy";
@@ -60,7 +60,9 @@ export class RunnerInsights {
     const segment = archive.slice(this.archiveObservedChars).trim();
     this.archiveObservedChars = archive.length;
     if (!segment) return;
-    const bounded = boundContinuationArchiveSegment(segment);
+    const rendered = renderContinuationArchive(segment);
+    if (!rendered.trim()) return;
+    const bounded = boundContinuationArchiveSegment(rendered);
     if (bounded.droppedBytes > 0) this.deps.sessionLog(`continuation archive truncated at ${bounded.keptBytes} bytes; dropped ${bounded.droppedBytes} bytes (${reason})`);
     this.deps.getOutbox().enqueue({
       kind: "continuation-archive",

package/src/runner-mcp-proxy.ts

@@ -1,5 +1,5 @@
 import { sharedCallmuxToolCallTimeoutMsFromEnv, type HumwickHttpClient, webSearchEnabledFromEnv, webCallLogEnabledFromEnv, errMessage, type WebToolCall, type AgentProfile } from "@humwick/sdk";
-import { RelayMcpProxy, type RelayMcpProxyOptions } from "./relay-mcp-proxy";
+import { HumwickMcpProxy, type RelayMcpProxyOptions } from "./relay-mcp-proxy";
 import { runnerManagedRelayOnDemandTools } from "./mcp-tool-deferral";
 import { logger } from "./logger";
 import type { WebToolLogOptions } from "./web-tool-call-proxy";
@@ -9,9 +9,9 @@ export function runnerMcpHiddenTools(provider: string, profile: AgentProfile | u
   return profile?.webTools?.brave === false ? new Set([...(hidden ?? []), "web_search"]) : hidden;
 }
 
-export function startRunnerMcpProxy(options: RelayMcpProxyOptions): { proxy?: RelayMcpProxy; endpoint?: string } {
+export function startRunnerMcpProxy(options: RelayMcpProxyOptions): { proxy?: HumwickMcpProxy; endpoint?: string } {
   try {
-    const proxy = new RelayMcpProxy(options);
+    const proxy = new HumwickMcpProxy(options);
     const endpoint = proxy.start().url;
     logger.info("mcp-proxy", `runner MCP proxy listening at ${endpoint} (worktree=${options.initialContext?.isolatedWorktree ?? false})`);
     return { proxy, endpoint };

package/src/runner-spawn-config.ts

@@ -34,9 +34,9 @@ export function buildRunnerSpawnConfig(
     provider: source.provider,
     ...(source.model ? { model: source.model } : {}),
     ...(source.effort ? { effort: source.effort } : {}),
-    // #2595 — positive-only gate mirrors the CLI parse; an unset/invalid value stays absent.
+    // positive-only gate mirrors the CLI parse; an unset/invalid value stays absent.
     ...(typeof source.contextWindowTokens === "number" && Number.isSafeInteger(source.contextWindowTokens) && source.contextWindowTokens > 0 ? { contextWindowTokens: source.contextWindowTokens } : {}),
-    // #2599 — the record arrives pre-parsed by the shared parser at the CLI seam; thread it
+    // the record arrives pre-parsed by the shared parser at the CLI seam; thread it
     // verbatim. The ADAPTER applies precedence (payload > manifest > undefined), not this builder.
     ...(source.modelRecord ? { modelRecord: source.modelRecord } : {}),
     runnerId: source.runnerId,
@@ -58,7 +58,7 @@ export function buildRunnerSpawnConfig(
     ...(source.tmuxSession ? { tmuxSession: source.tmuxSession } : {}),
     providerArgs: runtime.resumeId ? [...source.providerArgs, "--resume", runtime.resumeId] : [...source.providerArgs],
     providerConfig: source.providerConfig,
-    env: writeChildEnv({}, { ...runtime.env }),
+    env: writeChildEnv({}, { ...runtime.env }, []),
     controlPort: runtime.controlPort,
     ...(runtime.relayMcpEndpoint ? { relayMcpEndpoint: runtime.relayMcpEndpoint } : {}),
     ...(runtime.mcpProxySecret ? { mcpProxySecret: runtime.mcpProxySecret } : {}),

package/src/runtime-token-file.ts

@@ -19,7 +19,7 @@ function replaceFile(path: string, value: string): void {
  * Publish the runner's live credential to CLI children. A provider's process
  * environment is immutable after it starts, but each CLI invocation can read
  * these stable paths afresh. The orchestrator creates the initial files when
- * it materializes the session launch script (#2318).
+ * it materializes the session launch script.
  */
 export function persistRuntimeTokenFiles(token: string, expiresAt?: number): void {
   const tokenFile = runtimeTokenFileFromEnv();

package/src/runtime-token-remint.ts

@@ -28,7 +28,7 @@ export class TokenRotation {
 }
 
 /**
- * #1245 — re-derive the runner's token from the agent's CURRENT profile at a clear/compact boundary and
+ * re-derive the runner's token from the agent's CURRENT profile at a clear/compact boundary and
  * report the outcome for the command result. Never throws: a failed re-mint keeps the still-valid token.
  */
 export async function rederiveRuntimeToken(

package/src/service-access.ts

@@ -34,7 +34,7 @@ export async function withServiceAccessLaunch<T>(
 }
 
 /**
- * #3577: the provider gets a loopback proxy URL and local credential for its whole life; the session
+ * the provider gets a loopback proxy URL and local credential for its whole life; the session
  * token behind it renews at half its remaining lifetime (retrying each minute) until the launch ends.
  * A 409 means the launch is no longer live, so exit cleanup owns the session from there.
  */
@@ -57,7 +57,7 @@ export async function startServiceAccessRenewal(http: LaunchHttp, identity: Laun
       hop.setToken(renewed.token);
       schedule((renewed.expiresAt - Date.now()) / 2);
     } catch (error) {
-      console.warn(`[agent-relay] ${error instanceof Error ? error.message : "Vault access renewal failed"}; retrying in ${RENEW_RETRY_MS / 1000}s`);
+      console.warn(`[humwick] ${error instanceof Error ? error.message : "Vault access renewal failed"}; retrying in ${RENEW_RETRY_MS / 1000}s`);
       schedule(RENEW_RETRY_MS);
     }
   };

package/src/session-destroy.ts

@@ -2,7 +2,7 @@ export type SessionDestroyReason = "compact" | "clear" | "restart" | "shutdown"
 
 export type LifecycleAction =
   | "shutting-down" | "killing" | "restarting"
-  // #1746 — a TERMINAL marker: the graceful+force-kill path ran and the provider process
+  // a TERMINAL marker: the graceful+force-kill path ran and the provider process
   // still could not be confirmed dead. The runner deliberately keeps the agent registered
   // (a roster removal must imply the process is gone), so this pill replaces an indefinite
   // "shutting-down" with an operator-visible "the kill did not take" state.

package/src/session-insights.ts

@@ -1,4 +1,4 @@
-// Provider-agnostic core for the #184 context-gathering signal (epic #183).
+// Provider-agnostic core for the context-gathering signal.
 //
 // The transcript *format* is provider-specific (Claude JSONL, Codex app-server items,
 // future providers), so each adapter normalizes its session into the same `SessionEvent`

package/src/session-scratch.ts

@@ -1,23 +1,22 @@
-import { accessSync, appendFileSync, constants, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { appendIgnoreEntries, resolveRepoConfigPath } from "@humwick/sdk/repo-config-file";
+import { accessSync, constants, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
 import { chmod, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { sanitizeFsName } from "@humwick/sdk/fs-name";
 import { spawnSyncBounded } from "./bounded-spawn-sync";
 
-const SCRATCH_DIR_NAME = ".agent-relay";
-// The local-ignore entry. Leading + trailing slash scopes it to the dir at the
-// base, matching git's gitignore semantics.
-const EXCLUDE_ENTRY = "/.agent-relay/";
+const SCRATCH_DIR_NAME = ".humwick";
+const SCRATCH_GENERATIONS = [SCRATCH_DIR_NAME, ".agent-relay"];
 const LAUNCHER_DIR = join(tmpdir(), `agent-relay-launchers-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
 const DEFAULT_LAUNCHER_SWEEP_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 
 export interface SessionScratchLayout {
-  baseDir: string; // dir that contains .agent-relay (cwd, or fallback base dir)
-  rootDir: string; // <base>/.agent-relay
-  sessionsDir: string; // <base>/.agent-relay/sessions
-  sessionDir: string; // <base>/.agent-relay/sessions/<id>
-  tmpDir: string; // <base>/.agent-relay/sessions/<id>/tmp
+  baseDir: string; // dir that contains .humwick (cwd, or fallback base dir)
+  rootDir: string; // <base>/.humwick
+  sessionsDir: string; // <base>/.humwick/sessions
+  sessionDir: string; // <base>/.humwick/sessions/<id>
+  tmpDir: string; // <base>/.humwick/sessions/<id>/tmp
   replyFile: string; // <tmp>/reply.md
 }
 
@@ -55,8 +54,8 @@ export function resolveScratchBase(cwd: string, fallbackBaseDir?: string): strin
   return cwd;
 }
 
-function sessionScratchLayout(baseDir: string, agentId: string): SessionScratchLayout {
-  const rootDir = join(baseDir, SCRATCH_DIR_NAME);
+function sessionScratchLayout(baseDir: string, agentId: string, directory = dirname(resolveRepoConfigPath(baseDir, `${SCRATCH_DIR_NAME}/sessions`))): SessionScratchLayout {
+  const rootDir = join(baseDir, directory);
   const sessionsDir = join(rootDir, "sessions");
   const sessionDir = join(sessionsDir, agentId);
   const tmpDir = join(sessionDir, "tmp");
@@ -80,38 +79,26 @@ function gitExcludePath(baseDir: string): string | null {
   }
 }
 
-// Idempotently append EXCLUDE_ENTRY to an ignore file (grep-before-write).
-function appendIgnoreEntry(file: string): void {
-  let existing = "";
-  try {
-    existing = readFileSync(file, "utf8");
-  } catch {}
-  const wanted = EXCLUDE_ENTRY.trim();
-  if (existing.split("\n").some((line) => line.trim() === wanted)) return;
-  mkdirSync(dirname(file), { recursive: true });
-  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  appendFileSync(file, `${prefix}${EXCLUDE_ENTRY}\n`);
-}
-
-// Ensure `.agent-relay/` is locally ignored. Prefers .git/info/exclude (git's
+// Ensure session and browser tool scratch are locally ignored. Prefers .git/info/exclude (git's
 // local, uncommitted ignore list) so no tracked file is ever modified; falls
 // back to .gitignore only when baseDir is not a git repo. Returns which file was
 // used (for logging/tests).
 export function ensureScratchIgnored(baseDir: string): "exclude" | "gitignore" {
+  const entries = [`/${resolveRepoConfigPath(baseDir, `${SCRATCH_DIR_NAME}/sessions`)}/`, ".playwright-cli/"];
   const excludePath = gitExcludePath(baseDir);
   if (excludePath) {
-    appendIgnoreEntry(excludePath);
+    appendIgnoreEntries(excludePath, entries);
     return "exclude";
   }
-  appendIgnoreEntry(join(baseDir, ".gitignore"));
+  appendIgnoreEntries(join(baseDir, ".gitignore"), entries);
   return "gitignore";
 }
 
 // SessionStart: create the session tmp dir and ensure local ignore. Dir
 // creation is the load-bearing part; ignore setup is best-effort.
 //
-// #2310 P1 — this dir can hold sensitive spilled content (an over-cap memory/continuation
-// injection's full text, #1935's monitor over-limit handling), so it's session-private: 0700, not
+// P1 — this dir can hold sensitive spilled content (an over-cap memory/continuation
+// injection's full text, the monitor over-limit handling), so it's session-private: 0700, not
 // the default (umask-dependent, typically 0755/0775). `mode` here is safe from umask stripping it
 // back down: umask can only CLEAR bits from the requested mode, and 0700 already has none of the
 // group/other bits a realistic umask would clear — so this always lands exactly on 0700, with no
@@ -139,7 +126,7 @@ export function launcherScriptPathForSession(sessionName: string, launcherDir?:
 }
 
 // Named-pipe path the launcher script blocks on before exec'ing the real provider
-// command (#1317) — lets the caller attach `tmux pipe-pane` while the pane is still
+// command — lets the caller attach `tmux pipe-pane` while the pane is still
 // idle, so a process that exits within milliseconds can't slip output past it.
 export function launcherGatePathForSession(sessionName: string, launcherDir?: string): string {
   return `${launcherScriptPathForSession(sessionName, launcherDir)}.gate`;
@@ -181,8 +168,8 @@ function dedupePaths(paths: Array<string | undefined>): string[] {
 
 // SessionEnd: remove this session's dir from every candidate base.
 export function reapSessionScratch(target: SessionScratchTarget): void {
-  for (const base of dedupeBases([target.cwd, target.fallbackBaseDir])) {
-    const { sessionDir } = sessionScratchLayout(base, target.agentId);
+  for (const { base, generation } of dedupeBases([target.cwd, target.fallbackBaseDir]).flatMap(base => SCRATCH_GENERATIONS.map(generation => ({ base, generation })))) {
+    const { sessionDir } = sessionScratchLayout(base, target.agentId, generation);
     try {
       rmSync(sessionDir, { recursive: true, force: true });
     } catch {}
@@ -226,7 +213,7 @@ interface SweepOptions {
 
 interface LauncherSweepOptions {
   // Agent ids to keep (currently-known agents + self). Launcher scripts embed
-  // AGENT_RELAY_ID, so a stale sweep can safely remove only scripts whose agent
+  // HUMWICK_ID, so a stale sweep can safely remove only scripts whose agent
   // is no longer live.
   keepAgentIds: Set<string>;
   launcherDir?: string;
@@ -243,7 +230,7 @@ function maybeShellUnquote(value: string): string {
 
 async function launcherAgentId(scriptPath: string): Promise<string | null> {
   try {
-    const match = (await Bun.file(scriptPath).text()).match(/^export AGENT_RELAY_ID=(.+)$/m);
+    const match = (await Bun.file(scriptPath).text()).match(/^export (?:HUMWICK|AGENT_RELAY)_ID=(.+)$/m);
     if (!match) return null;
     const agentId = maybeShellUnquote(match[1] ?? "");
     return agentId || null;
@@ -259,8 +246,8 @@ export async function sweepStaleSessionsAsync(opts: SweepOptions): Promise<strin
   const minAge = opts.minAgeMs ?? 60 * 60 * 1000;
   const maxEntries = opts.maxEntries ?? 100;
   const removed: string[] = [];
-  for (const base of dedupeBases([opts.cwd, opts.fallbackBaseDir])) {
-    const sessionsDir = join(base, SCRATCH_DIR_NAME, "sessions");
+  for (const { base, generation } of dedupeBases([opts.cwd, opts.fallbackBaseDir]).flatMap(base => SCRATCH_GENERATIONS.map(generation => ({ base, generation })))) {
+    const sessionsDir = join(base, generation, "sessions");
     let ids: string[];
     try { ids = await readdir(sessionsDir); } catch { continue; }
     for (const id of ids.slice(0, maxEntries)) {

package/src/spawn-input.ts

@@ -8,13 +8,13 @@ export interface RunnerCliOptions {
   provider: SpawnProvider;
   model?: string;
   effort?: string;
-  /** #2595 — effective-catalog window resolved server-side; preferred over the static manifest. */
+  /** effective-catalog window resolved server-side; preferred over the static manifest. */
   contextWindowTokens?: number;
-  /** #2599 — the full server-resolved model record (protocol ≥ 2); precedence payload > manifest. */
+  /** the full server-resolved model record (protocol ≥ 2); precedence payload > manifest. */
   modelRecord?: ResolvedModelRecord;
   headless: boolean;
   interactive: boolean;
-  /** #2773 — interactive|headless driver; absent keeps the provider's legacy selection. */
+  /** interactive|headless driver; absent keeps the provider's legacy selection. */
   launchMode?: LaunchMode;
   cwd?: string;
   rig?: string;
@@ -64,7 +64,7 @@ export function parseRunnerCliArgs(
   let model: string | undefined;
   let effort: string | undefined;
   let contextWindowTokens: number | undefined;
-  // #2599 — raw --model-record-* fields, assembled then parsed ONCE through the shared parser
+  // raw --model-record-* fields, assembled then parsed ONCE through the shared parser
   // (the same parser the orchestrator uses), so CLI parsing can never drift from the payload seam.
   const modelRecordRaw: Record<string, unknown> = {};
   let cwd: string | undefined;
@@ -91,13 +91,13 @@ export function parseRunnerCliArgs(
     }
     else if (arg === "--model" && ownArgs[i + 1]) model = ownArgs[++i];
     else if (arg === "--effort" && ownArgs[i + 1]) effort = ownArgs[++i];
-    // #2595 — server-resolved effective-catalog window; positive-integer gate keeps a malformed
+    // server-resolved effective-catalog window; positive-integer gate keeps a malformed
     // value from ever becoming a fabricated denominator (openCodeContextState would clamp anyway).
     else if (arg === "--context-window-tokens" && ownArgs[i + 1]) {
       const parsed = Number(ownArgs[++i]);
       contextWindowTokens = Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
     }
-    // #2599 — full-record fields (protocol ≥ 2). Values ride raw; the shared parser at the end
+    // full-record fields (protocol ≥ 2). Values ride raw; the shared parser at the end
     // applies the SAME gates as the orchestrator seam. --model-record-threshold carries a JSON
     // threshold object; a malformed JSON is untrusted and drops the whole record field set to
     // the parser's verdict (never a fabricated threshold).

package/src/startup-config-fetch.ts

@@ -1,4 +1,4 @@
-import { ReconnectionManager, RELAY_TOKEN_HEADER, errMessage } from "@humwick/sdk";
+import { ReconnectionManager, HUMWICK_TOKEN_HEADER, errMessage } from "@humwick/sdk";
 import type { SettingEntry } from "@humwick/sdk";
 import { isRetryableTransportError } from "./transport-errors";
 
@@ -16,7 +16,7 @@ function transient(error: unknown): boolean {
     || (error instanceof Error && error.name === "TimeoutError");
 }
 
-// Use registration's backoff and initial-handshake budget for managed bootstrap reads (#3326).
+// Use registration's backoff and initial-handshake budget for managed bootstrap reads.
 export async function fetchStartupConfig(url: URL, token: string | undefined, timeoutMs: number, deps: Partial<StartupFetchDeps> = {}) {
   const d = { now: Date.now, sleep: Bun.sleep, reconnect: new ReconnectionManager(), ...deps };
   const deadline = d.deadlineAt ?? d.now() + timeoutMs;
@@ -24,7 +24,7 @@ export async function fetchStartupConfig(url: URL, token: string | undefined, ti
     if (d.deadlineAt !== undefined && d.now() >= deadline) throw new Error("provider config retry budget expired");
     try {
       const response = await fetch(url, {
-        headers: token ? { [RELAY_TOKEN_HEADER]: token } : undefined,
+        headers: token ? { [HUMWICK_TOKEN_HEADER]: token } : undefined,
         signal: AbortSignal.timeout(timeoutMs > 0 ? Math.max(1, Math.min(5_000, deadline - d.now())) : 5_000),
       });
       if (response.status >= 500) {
@@ -40,7 +40,7 @@ export async function fetchStartupConfig(url: URL, token: string | undefined, ti
       const remaining = deadline - d.now();
       if (!transient(error) || remaining <= 0) throw error;
       const delay = Math.min(d.reconnect.nextDelay(), remaining);
-      console.warn(`[agent-relay] provider config relay read failed (${errMessage(error)}); retrying in ${delay}ms.`);
+      console.warn(`[humwick] provider config relay read failed (${errMessage(error)}); retrying in ${delay}ms.`);
       await d.sleep(delay);
       if (d.now() >= deadline) throw error;
     }

package/src/subreaper.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dlopen } from "bun:ffi";
-import { SYSTEMD_MANAGED_SESSION_PREFIX } from "@humwick/sdk/systemd-unit";
+import { isManagedSessionUnit } from "@humwick/sdk/systemd-unit";
 
 const REAP_INTERVAL_MS = 5_000;
 const ZOMBIE_GRACE_MS = 5_000;
@@ -9,9 +9,7 @@ let reaperStarted = false;
 export function hasSystemdSessionOwner(cgroup: string, parentComm: string): boolean {
   if (parentComm.trim() !== "systemd") return false;
   return cgroup.split("\n").some((line) => line.startsWith("0::/") && line.slice(4).split("/").some((part) =>
-    part.startsWith(SYSTEMD_MANAGED_SESSION_PREFIX)
-    && part.length > SYSTEMD_MANAGED_SESSION_PREFIX.length + ".service".length
-    && part.endsWith(".service")));
+    isManagedSessionUnit(part)));
 }
 
 function zombieChildren(): Map<number, string> {
@@ -39,7 +37,7 @@ function zombieChildren(): Map<number, string> {
 }
 
 // Dedicated systemd sessions already own descendant teardown via KillMode=control-group.
-// Let their manager promptly reap orphans (#2858); only unsupervised runners need
+// Let their manager promptly reap orphans; only unsupervised runners need
 // to adopt them here. Darwin has no process-local equivalent; launchd remains the reaper.
 export function enableRunnerSubreaper(): boolean {
   if (process.platform !== "linux") return false;

package/src/test-run-dedup.ts

@@ -1,5 +1,5 @@
 import { relayEnv } from "@humwick/sdk/env";
-// #3754 — the lease owns launch-time replacement. The sweep only deduplicates
+// the lease owns launch-time replacement. The sweep only deduplicates
 // unleased runs with the same captured checkout/revision; ancestry proves ownership,
 // but cannot prove two commands tested the same tree. Live leases protect whole runs.
 import { execFile } from "node:child_process";
@@ -12,7 +12,7 @@ import { GATE_RUN_AGENT_ENV, GATE_RUN_CONTEXT_ENV, GATE_RUN_HELD_ENV, readLiveGa
 import type { ManagedProcess } from "./adapter";
 
 // Re-exported so the sweep and both lease front doors share ONE definition of "is this a test run".
-// It moved to the sdk in #2461 because the orchestrator (a separate workspace that cannot import
+// It moved to the sdk in because the orchestrator (a separate workspace that cannot import
 // runner/) needs the same rule; keeping the name exported here keeps every existing caller intact.
 export { isTestRunCommand };
 
@@ -55,7 +55,7 @@ function validPid(pid: unknown): pid is number {
  * Most providers expose that child as both `process.pid` and `pid`. Interactive
  * Codex is intentionally different: `pid` is the visible remote TUI, while
  * `process` is the App Server that owns Codex turns and their command children.
- * Rooting at the TUI made #2142 a no-op for exactly those Codex sessions. Prefer
+ * Rooting at the TUI made a no-op for exactly those Codex sessions. Prefer
  * the runner-owned execution child, then retain the historical managed-pid and
  * adapter-specific fallbacks for tmux-backed providers.
  */
@@ -104,7 +104,7 @@ export function parseProcessTable(text: string): ProcessRow[] {
 
 /**
  * Pids whose ENVIRONMENT names `agentId` as their owner — the half of ownership that ancestry
- * cannot express (#2461). A `relay_run` gate run is a child of the orchestrator daemon, not of this
+ * cannot express. A `humwick_run` gate run is a child of the orchestrator daemon, not of this
  * agent's provider pane, so it is reachable only through the tag the orchestrator stamps on it.
  *
  * Linux reads `/proc/<pid>/environ` directly: no subprocess, and unreadable entries (another user's
@@ -144,7 +144,7 @@ export async function collectAgentTaggedPids(agentId: string, platform: string =
       const match = line.match(/^\s*(\d+)\s+(.*)$/);
       if (!match) continue;
       // `ps -E` renders the environment space-separated, so a whole-token test is the analogue of
-      // the NUL split above: `AGENT_RELAY_ID=x` must not match agent `xy`.
+      // the NUL split above: `HUMWICK_ID=x` must not match agent `xy`.
       if (!match[2]!.split(/\s+/).includes(needle)) continue;
       const pid = Number(match[1]);
       if (Number.isInteger(pid) && pid > 1) pids.push(pid);
@@ -177,7 +177,7 @@ const EMPTY_PLAN: TestRunDedupPlan = { staleRoots: [], killPids: [] };
  *    single healthy run presents exactly one root and is never touched.
  */
 export interface TestRunDedupScope {
-  /** Pids proven to belong to this agent by their ENVIRONMENT rather than by ancestry (#2461).
+  /** Pids proven to belong to this agent by their ENVIRONMENT rather than by ancestry.
    *  These extend the scope; they are never used as tree roots, because a tagged process is
    *  usually INSIDE the run rather than above it. */
   ownedPids?: readonly number[];
@@ -227,7 +227,7 @@ export function planTestRunDedup(
   };
 
   // Ownership is the UNION of the two proofs: descended from this session's provider process, or
-  // carrying this agent's id in its environment. Neither alone covers both launch paths (#2461).
+  // carrying this agent's id in its environment. Neither alone covers both launch paths.
   const sessionPids = new Set<number>(byPid.has(rootPid) ? subtree(rootPid) : []);
   for (const pid of ownedInTable) sessionPids.add(pid);
   const candidates = new Set<number>();
@@ -255,7 +255,7 @@ export function planTestRunDedup(
   if (runRoots.length < 2) return EMPTY_PLAN;
 
   // A lease may belong to a child of the outer shell. Spare the WHOLE run, including
-  // ancestors and descendants, rather than signalling its owner indirectly (#3754).
+  // ancestors and descendants, rather than signalling its owner indirectly.
   const leased = new Set(scope.leasedPids ?? []);
   const groups = new Map<string, number[]>();
   const leasedRoots = new Set<number>();
@@ -315,7 +315,7 @@ export async function readProcessTable(timeoutMs: number = PROCESS_TABLE_TIMEOUT
   return stdout;
 }
 
-/** Only launch-time metadata can distinguish revisions; today's HEAD cannot (#3754). */
+/** Only launch-time metadata can distinguish revisions; today's HEAD cannot. */
 export function readTestRunContext(pid: number): { context?: string; leased?: boolean } {
   try {
     const env = Object.fromEntries(readFileSync(`/proc/${pid}/environ`, "utf8").split("\0").map((entry) => {
@@ -329,7 +329,7 @@ export function readTestRunContext(pid: number): { context?: string; leased?: bo
 export interface TestRunDedupDeps {
   /** Resolve this session's provider pid. undefined ⇒ ancestry proves nothing; the env tag may. */
   rootPid: () => number | undefined;
-  /** This agent's id, for the env-tag ownership proof (#2461). Absent ⇒ ancestry-only, as before. */
+  /** This agent's id, for the env-tag ownership proof. Absent ⇒ ancestry-only, as before. */
   agentId?: () => string | undefined;
   /** The repo's configured gate commands, so a foreign gate runner is classified exactly rather
    *  than left to the argv-shape heuristic. */
@@ -353,7 +353,7 @@ export async function runTestRunDedupSweep(deps: TestRunDedupDeps): Promise<numb
   const resolvedRoot = deps.rootPid();
   const rootPid = resolvedRoot !== undefined && Number.isInteger(resolvedRoot) && resolvedRoot > 1 ? resolvedRoot : 0;
   const agentId = deps.agentId?.() ?? "";
-  // #2461 — either proof of ownership is enough, but at least one is required. With neither, the
+  // either proof of ownership is enough, but at least one is required. With neither, the
   // sweep cannot show any process is ours and must do nothing at all.
   const ownedPids = agentId ? await (deps.collectOwnedPids ?? collectAgentTaggedPids)(agentId) : [];
   if (rootPid === 0 && ownedPids.length === 0) return [];
@@ -387,7 +387,7 @@ export async function runTestRunDedupSweep(deps: TestRunDedupDeps): Promise<numb
   const kill = deps.kill ?? killPid;
   const waitForExit = deps.waitForExit ?? waitForPidsExit;
   deps.log(
-    `test-run dedup (#2142): a newer test run started, killing ${plan.staleRoots.length} superseded run(s) ` +
+    `test-run dedup: a newer test run started, killing ${plan.staleRoots.length} superseded run(s) ` +
       `[roots ${plan.staleRoots.join(", ")}; ${plan.killPids.length} pid(s)]` +
       `${plan.keptPid !== undefined ? `; keeping ${plan.keptPid}` : ""}`,
   );
@@ -401,7 +401,7 @@ export async function runTestRunDedupSweep(deps: TestRunDedupDeps): Promise<numb
 
 /** True unless the operator has explicitly turned dedup off for this session. */
 export function testRunDedupEnabled(env: Record<string, string | undefined> = process.env): boolean {
-  const raw = (relayEnv(env, "AGENT_RELAY_TEST_DEDUP") ?? "").trim().toLowerCase();
+  const raw = (relayEnv(env, "HUMWICK_TEST_DEDUP") ?? "").trim().toLowerCase();
   return raw !== "0" && raw !== "false" && raw !== "off";
 }
 

package/src/transcript-context.ts

@@ -2,14 +2,14 @@ import { readFileSync, statSync } from "node:fs";
 import type { ContextState } from "@humwick/sdk";
 import type { ProviderContextUsage } from "./adapter";
 
-// #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 (no new process,
 // so the probe file stops advancing while the agent keeps taking turns). The
 // transcript — handed to the runner every turn by the Stop hook — carries the
 // same per-turn token usage, so the runner derives fresh context from it here as
 // a probe-independent fallback that keeps context.lastUpdatedAt advancing across
 // those in-process generation bumps. Kept out of runner-core to hold that giant's
-// line budget (epic #291); runner-core just threads its per-session cache through.
+// line budget; runner-core just threads its per-session cache through.
 
 export interface TranscriptContextCache {
   path: string;

package/src/transport-errors.ts

@@ -41,7 +41,7 @@ export function classifyTransportError(error: unknown): TransportErrorClass {
 }
 
 // Back-compat: a failure is "retryable transport" if it is either connect-phase or ambiguous (the old
-// single-class predicate #1790 exposed). The retry DECISION now also weighs idempotency for the
+// single-class predicate exposed). The retry DECISION now also weighs idempotency for the
 // ambiguous class — see forwardWithConnectionRetry.
 export function isRetryableTransportError(error: unknown): boolean {
   return classifyTransportError(error) !== "fatal";

package/src/turn-opener.ts

@@ -6,7 +6,7 @@ import { receivesTurnResponseAutomatically } from "./response-routing";
 
 type ReplyRoute = NonNullable<ProviderSessionEvent["replyRoute"]>;
 
-// #2840 — binds the delivered message that OPENS a provider turn to that turn; only its final answers it.
+// binds the delivered message that OPENS a provider turn to that turn; only its final answers it.
 // Armed before the input is offered (OpenCode runs the whole turn inside deliver, Codex starts it
 // synchronously), bound at the next turn-start edge, consumed by the final with that turn id. A turn
 // that starts with nothing armed clears the binding, so a later timer turn never inherits a question.

package/src/turn-reconcile-event.ts

@@ -13,7 +13,7 @@ export interface RunnerTimelineEvent {
 }
 
 /**
- * #1621 — the announcement for a provider-turn claim the busy backstop force-cleared.
+ * the announcement for a provider-turn claim the busy backstop force-cleared.
  *
  * Reconciliation is a real state change, not bookkeeping repair: the turn the coordinator is
  * waiting on is over and produced no reply, and `busy` is exactly the signal it used to decide
@@ -48,7 +48,7 @@ export function reconciledTurnTimelineEvent(input: {
 }
 
 /**
- * #1980 — the announcement for a live provider turn the busy backstop is HOLDING (not cancelling)
+ * the announcement for a live provider turn the busy backstop is HOLDING (not cancelling)
  * past its prolonged-hold threshold: a frozen-active `shell` gate, or a pane-scrape-only long tool
  * the runner cannot positively prove idle. In contrast to {@link reconciledTurnTimelineEvent} the
  * turn is NOT ended and the card stays busy — this only surfaces "still working, held by the