@humwick/runner 0.130.5 → 0.130.6

package/src/relay-mcp.ts

@@ -1,4 +1,4 @@
-import { mcpServerInfo, parseToolGeneration, isRelayMcpServerName, type ToolGeneration } from "@humwick/sdk";
+import { MCP_SERVER_INFO, isRelayMcpServerName } from "@humwick/sdk";
 import { relayEnv, writeChildEnv } from "@humwick/sdk/env";
 import { codexVaultMcpEnv } from "./mcp-vault-env";
 // Single home for the relay HTTP MCP endpoint descriptor + per-provider injection
@@ -6,35 +6,35 @@ import { codexVaultMcpEnv } from "./mcp-vault-env";
 // server name, and token-handling rules live in exactly one place.
 //
 // Token handling: the bearer token is NEVER placed in argv (it would leak via `ps`
-// and the agent's own process inspection). Claude expands `${AGENT_RELAY_SESSION_TOKEN}`
+// and the agent's own process inspection). Claude expands `${HUMWICK_SESSION_TOKEN}`
 // from the env at MCP-config parse time; Codex reads it from the named env var.
 //
-// Why a dedicated var and NOT `AGENT_RELAY_TOKEN`: a managed session inherits the
+// Why a dedicated var and NOT `HUMWICK_TOKEN`: a managed session inherits the
 // runner's scoped, identity-bearing session token, but Claude Code applies a rig/user
 // `settings.json` `env` block OVER the inherited env. A rig that sets
-// `env.AGENT_RELAY_TOKEN` (e.g. to the admin token, for interactive CLI use) would
+// `env.HUMWICK_TOKEN` (e.g. to the admin token, for interactive CLI use) would
 // clobber the scoped token at parse time, so the relay MCP connection authenticates as
-// the `server` actor with no agent identity — `relay_whoami` returns null and
-// `relay_send_message` demands a `from` it can't supply (#233). The runner exports the
+// the `server` actor with no agent identity — `humwick_whoami` returns null and
+// `humwick_send_message` demands a `from` it can't supply. The runner exports the
 // scoped token under this dedicated name that rigs don't set, so nothing on the host can
 // hijack the managed agent's identity.
-export const RELAY_MCP_SERVER_NAME = mcpServerInfo("relay").name;
+export const RELAY_MCP_SERVER_NAME = MCP_SERVER_INFO.name;
 export { isRelayMcpServerName };
 export const RELAY_MCP_PATH = "/api/mcp";
-export const RELAY_MCP_TOKEN_ENV = "AGENT_RELAY_SESSION_TOKEN";
+export const RELAY_MCP_TOKEN_ENV = "HUMWICK_SESSION_TOKEN";
 
-// #672 — shared host-listener MCP. The agent connects to ONE orchestrator-owned shared
+// shared host-listener MCP. The agent connects to ONE orchestrator-owned shared
 // `callmux` listener via a per-agent `callmux bridge`, fronting the host's NON-IDENTITY MCP
 // (tokenlean, github). The bridge is a stdio child (auto-reconnect + retry-once on a
 // listener/downstream hiccup; `--cwd` injects `x-callmux-cwd` for per-worktree session-cwd
 // isolation), so it rides the SAME provider injection as any provisioned stdio server. The
-// identity-bearing relay endpoint is NEVER routed here — it stays per-agent on #215.
+// identity-bearing relay endpoint is NEVER routed here — it stays per-agent.
 export { SHARED_MCP_SERVER_NAME };
 // callmux's documented manual-listener endpoint (`callmux --listen 4860`, Streamable HTTP at
 // /mcp). In managed launches the orchestrator owns the real listener URL and passes it through
-// AGENT_RELAY_SHARED_MCP_URL; this fallback is for direct runner/manual-listener use.
+// HUMWICK_SHARED_MCP_URL; this fallback is for direct runner/manual-listener use.
 export const DEFAULT_SHARED_MCP_URL = "http://localhost:4860/mcp";
-export const SHARED_MCP_URL_ENV = "AGENT_RELAY_SHARED_MCP_URL";
+export const SHARED_MCP_URL_ENV = "HUMWICK_SHARED_MCP_URL";
 export { runnerManagedToolDeferralRoute } from "./mcp-tool-deferral";
 
 /** Resolve the shared-listener URL: explicit runner option → env → documented default. */
@@ -42,22 +42,11 @@ export function resolveSharedMcpUrl(explicit?: string): string {
   return explicit ?? relayEnv(process.env, SHARED_MCP_URL_ENV) ?? DEFAULT_SHARED_MCP_URL;
 }
 
-export function runnerMcpGeneration(env: Record<string, string | undefined>): ToolGeneration {
-  return parseToolGeneration(relayEnv(env, "AGENT_RELAY_MCP_TOOLS"));
+export function relayMcpEndpoint(relayUrl: string): string {
+  return `${relayUrl.replace(/\/+$/, "")}${RELAY_MCP_PATH}`;
 }
 
-function generationEndpoint(endpoint: string, generation: ToolGeneration): string {
-  const url = new URL(endpoint);
-  if (generation === "humwick") url.searchParams.set("tools", generation);
-  else url.searchParams.delete("tools");
-  return url.toString();
-}
-
-export function relayMcpEndpoint(relayUrl: string, generation: ToolGeneration = "relay"): string {
-  return generationEndpoint(`${relayUrl.replace(/\/+$/, "")}${RELAY_MCP_PATH}`, generation);
-}
-
-// #1248 — per-server Codex MCP overrides. Default `tool_timeout_sec` (60s) and
+// per-server Codex MCP overrides. Default `tool_timeout_sec` (60s) and
 // `startup_timeout_ms` are too short for our long-running tools (tests/releases run
 // 5+ min), forcing agents to poll/sleep instead of just waiting on the call. Verified
 // against the installed codex-cli binary (0.144.0): both fields live on the
@@ -77,12 +66,12 @@ function codexTimeoutConfigArgs(key: string): string[] {
 
 // Codex: `-c mcp_servers.<name>.*` overrides. `bearer_token_env_var` tells Codex to
 // read the token from the env var itself → transport resolves to streamable_http.
-// `endpoint` overrides the target URL (runner-local proxy, Stage 2 #215) — see above.
-export function relayMcpCodexConfigArgs(relayUrl: string, endpoint?: string, generation: ToolGeneration = "relay"): string[] {
-  const key = `mcp_servers.${mcpServerInfo(generation).name}`;
+// `endpoint` overrides the target URL (runner-local proxy, Stage 2) — see above.
+export function relayMcpCodexConfigArgs(relayUrl: string, endpoint?: string): string[] {
+  const key = `mcp_servers.${MCP_SERVER_INFO.name}`;
   return [
     "-c",
-    `${key}.url=${tomlString(generationEndpoint(endpoint ?? relayMcpEndpoint(relayUrl), generation))}`,
+    `${key}.url=${tomlString(endpoint ?? relayMcpEndpoint(relayUrl))}`,
     "-c",
     `${key}.bearer_token_env_var=${tomlString(RELAY_MCP_TOKEN_ENV)}`,
     ...codexTimeoutConfigArgs(key),
@@ -154,8 +143,8 @@ function codexNativeMcpToml(server: ProvisioningMcpServer): { root: string[]; ne
   return { root, nested };
 }
 
-// #555 — compose the launch MCP set from (the relay endpoint, if relay.mcp) PLUS the
-// profile's relay-provisioned servers, PLUS (#662) the host USER-scope servers for an
+// compose the launch MCP set from (the relay endpoint, if relay.mcp) PLUS the
+// profile's relay-provisioned servers, PLUS the host USER-scope servers for an
 // `mcp.mode:"host"` profile. One `--mcp-config` JSON carries them all. `strict` adds
 // `--strict-mcp-config` so ONLY these load — Claude reads no on-disk config, so the
 // project-cwd `.mcp.json` is never discovered (its enable modal can't wedge a headless
@@ -168,11 +157,11 @@ import { SHARED_MCP_SERVER_NAME, sharedCallmuxToolCallTimeoutMsFromEnv, type Pro
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// #1301 — a bare `command: "callmux"` resolves off PATH, which can drift from the version
+// a bare `command: "callmux"` resolves off PATH, which can drift from the version
 // this package pins (root/runner/orchestrator all pin the same `callmux` dependency). npm
 // (and bun/pnpm workspaces) always link a dependency's declared bin to `node_modules/.bin/<name>`
 // at whichever ancestor directory it resolves/hoists to — the same layout-agnostic-bin
-// invariant #1305/#1222 rely on for the humwick CLI itself — so walk up from this
+// invariant rely on for the humwick CLI itself — so walk up from this
 // module's own location to find the PINNED bridge binary instead of trusting PATH. Falls
 // back to the bare name (old behavior) only if no bundled bin is found anywhere above.
 export function resolveCallmuxBin(startDir: string = __dirname): string {
@@ -188,7 +177,7 @@ export function resolveCallmuxBin(startDir: string = __dirname): string {
 
 // The shared-listener bridge as a provider-neutral stdio server descriptor: a `callmux bridge`
 // child fronting the host's shared listener, with per-agent `--cwd "$WORKTREE"` for session-cwd
-// isolation (#672). It flows through the existing claude/codex stdio injection unchanged.
+// isolation. It flows through the existing claude/codex stdio injection unchanged.
 export function sharedMcpBridgeServer(url: string, cwd: string): ProvisioningMcpServer {
   return {
     command: resolveCallmuxBin(),
@@ -196,7 +185,7 @@ export function sharedMcpBridgeServer(url: string, cwd: string): ProvisioningMcp
   };
 }
 
-// #1575 — the per-agent metaOnly callmux for Codex workers. The header callmux reads to scope
+// the per-agent metaOnly callmux for Codex workers. The header callmux reads to scope
 // session-cwd stdio downstreams (tokenlean) per worktree; the shared bridge injects it dynamically,
 // and here we pin it statically because a stdio callmux has no incoming request headers to forward.
 const CALLMUX_CWD_HEADER = "x-callmux-cwd";
@@ -205,20 +194,20 @@ const CALLMUX_CWD_HEADER = "x-callmux-cwd";
 // materializer (writes it) so disk == launch.
 export const SHARED_MCP_METAONLY_CONFIG_FILENAME = "callmux-metaonly.json";
 
-// #1450 — the request header the per-agent metaOnly callmux sets on its relay downstream. The runner
+// the request header the per-agent metaOnly callmux sets on its relay downstream. The runner
 // proxy reads it to decide which relay tools/list view to serve: WITHOUT it (the agent's DIRECT relay
 // client) the proxy hides the on-demand set so only the eager hot-path set boots; WITH it (this
 // callmux, fronting the on-demand set) the proxy serves the FULL set the relay already returned so
 // callmux can route callmux_call to any of them. It can only ever widen the LIST back to that
-// relay-returned set — never authorization: tools/call stays scope-gated regardless (#215 / capability
+// relay-returned set — never authorization: tools/call stays scope-gated regardless (/ capability
 // neutrality). Kept out of `forward` so the relay itself never sees it.
-const RELAY_MCP_ONDEMAND_SURFACE_HEADER = "x-agent-relay-ondemand-front";
+const RELAY_MCP_ONDEMAND_SURFACE_HEADER = "x-humwick-ondemand-front";
 export const RELAY_MCP_ONDEMAND_SURFACE_VALUE = "1";
 
-// #1450 — a Codex worker's relay downstream inside the per-agent metaOnly callmux. It points at the
+// a Codex worker's relay downstream inside the per-agent metaOnly callmux. It points at the
 // runner-LOCAL proxy (never the relay directly): the proxy injects the live relay token, so identity
-// rides through and the agent/callmux never hold the real token on disk (#215). `authSecret` is the
-// per-session PROXY secret (which the agent already holds in AGENT_RELAY_SESSION_TOKEN — writing it to
+// rides through and the agent/callmux never hold the real token on disk. `authSecret` is the
+// per-session PROXY secret (which the agent already holds in HUMWICK_SESSION_TOKEN — writing it to
 // this 0600 config adds no exposure, and it is NOT the relay token). cachePolicy denies every tool:
 // relay ops are identity-bearing/mutating and must never be served from cache.
 export interface MetaOnlyRelayDownstream {
@@ -226,18 +215,17 @@ export interface MetaOnlyRelayDownstream {
   endpoint: string;
   /** The per-session proxy secret the agent authenticates to the local proxy with. */
   authSecret: string;
-  generation?: ToolGeneration;
 }
 
 function metaOnlyRelayServerConfig(relay: MetaOnlyRelayDownstream): Record<string, unknown> {
   return {
-    url: generationEndpoint(relay.endpoint, relay.generation ?? "relay"),
+    url: relay.endpoint,
     transport: "streamable-http",
     headers: {
       Authorization: `Bearer ${relay.authSecret}`,
       [RELAY_MCP_ONDEMAND_SURFACE_HEADER]: RELAY_MCP_ONDEMAND_SURFACE_VALUE,
     },
-    // #1450 — never cache relay ops (identity-bearing/mutating). Wildcard-deny is explicit belt-and-
+    // never cache relay ops (identity-bearing/mutating). Wildcard-deny is explicit belt-and-
     // suspenders on top of the config's disabled global cache TTL.
     cachePolicy: { denyTools: ["*"] },
     callTimeoutMs: sharedCallmuxToolCallTimeoutMsFromEnv(),
@@ -246,13 +234,13 @@ function metaOnlyRelayServerConfig(relay: MetaOnlyRelayDownstream): Record<strin
 
 // The per-agent metaOnly callmux config: streamable-http downstreams exposing ONLY the callmux
 // meta-tools (callmux_search_tools/callmux_call/…). A Codex worker boots with ~11 meta-tool schemas
-// instead of the flat downstream schemas (#1570 dominant lever) and reaches the real tools on demand
+// instead of the flat downstream schemas and reaches the real tools on demand
 // through callmux_call.
 //   • The shared listener (SHARED_MCP_SERVER_NAME): the worktree cwd is a STATIC downstream header —
 //     the per-agent callmux runs over stdio (no incoming headers to forwardHeaders) and the worktree
 //     is fixed per agent, so a fixed x-callmux-cwd routes the shared listener's session-cwd tools to
 //     this worktree exactly as the dynamic bridge header did.
-//   • #1450 — when `relay` is given, the identity-bearing relay endpoint is added as a SECOND
+//   • — when `relay` is given, the identity-bearing relay endpoint is added as a SECOND
 //     downstream (via the runner-local proxy) so the on-demand relay set loads through callmux_call.
 // Timeouts mirror the bridge's SHARED_CALLMUX_TOOL_CALL_TIMEOUT_MS floor so nested calls keep the same
 // call-timeout budget.
@@ -272,7 +260,7 @@ export function sharedMcpMetaOnlyConfig(url: string, cwd: string, relay?: MetaOn
         cachePolicy: { denyTools: ["*"] },
         callTimeoutMs,
       },
-      ...(relay ? { [mcpServerInfo(relay.generation ?? "relay").name]: metaOnlyRelayServerConfig(relay) } : {}),
+      ...(relay ? { [MCP_SERVER_INFO.name]: metaOnlyRelayServerConfig(relay) } : {}),
     },
   };
 }
@@ -288,22 +276,22 @@ export function sharedMcpMetaOnlyServer(configPath: string): ProvisioningMcpServ
 }
 
 // Materialize the per-agent metaOnly config `sharedMcpMetaOnlyServer(configPath)` points at. The
-// shared-listener URL is non-secret. #1450 — when a `relay` downstream is given, the config carries
-// the per-session PROXY secret (NOT the relay token — the proxy injects that; #215). The agent
-// already holds the proxy secret in AGENT_RELAY_SESSION_TOKEN, so the 0600 file adds no exposure.
+// shared-listener URL is non-secret. When a `relay` downstream is given, the config carries
+// the per-session PROXY secret (NOT the relay token — the proxy injects that). The agent
+// already holds the proxy secret in HUMWICK_SESSION_TOKEN, so the 0600 file adds no exposure.
 export function writeSharedMcpMetaOnlyConfig(configPath: string, url: string, cwd: string, relay?: MetaOnlyRelayDownstream): void {
   mkdirSync(dirname(configPath), { recursive: true });
   writeFileSync(configPath, JSON.stringify(sharedMcpMetaOnlyConfig(url, cwd, relay), null, 2) + "\n", { mode: 0o600 });
 }
 
-// #1292 — shared by the Claude JSON payload builder and the Codex TOML materializer, so
+// shared by the Claude JSON payload builder and the Codex TOML materializer, so
 // both projections merge `configEnv` (non-secret, allowlisted literals) into `env` the
 // same way instead of re-deriving the merge twice.
 export function mergedConfigEnv(server: ProvisioningMcpServer): ProvisioningMcpServer {
   if (!server.configEnv || Object.keys(server.configEnv).length === 0) return server;
   return {
     ...server,
-    env: writeChildEnv({}, { ...server.configEnv, ...(server.env ?? {}) }),
+    env: writeChildEnv({}, { ...server.configEnv, ...(server.env ?? {}) }, []),
   };
 }
 
@@ -323,16 +311,15 @@ export interface ClaudeMcpConfigOpts {
   relayUrl: string;
   endpoint?: string;
   includeRelay: boolean;
-  generation?: ToolGeneration;
   servers?: Record<string, ProvisioningMcpServer>;
-  /** #662 — host USER-scope MCP servers (`~/.claude.json` `mcpServers`), re-injected for
+  /** host USER-scope MCP servers (`~/.claude.json` `mcpServers`), re-injected for
    *  `mcp.mode:"host"` so `--strict-mcp-config` PRESERVES them instead of dropping the
    *  ambient host MCP a host-base agent loaded before strict. Lowest precedence: the relay
    *  endpoint and relay-provisioned servers win on a name collision (relay decides). */
   hostServers?: Record<string, ProvisioningMcpServer>;
 }
 
-// #1292 — the `{ mcpServers: {...} }` object Claude parses, extracted so both the launch
+// the `{ mcpServers: {...} }` object Claude parses, extracted so both the launch
 // assembler (decides whether it's written to argv or a file) and the materializer (writes
 // the file) build the IDENTICAL payload from the same inputs.
 export function claudeMcpConfigPayload(opts: ClaudeMcpConfigOpts): Record<string, unknown> {
@@ -345,9 +332,9 @@ export function claudeMcpConfigPayload(opts: ClaudeMcpConfigOpts): Record<string
     if (Object.keys(entry).length) mcpServers[name] = entry;
   }
   if (opts.includeRelay) {
-    mcpServers[mcpServerInfo(opts.generation ?? "relay").name] = {
+    mcpServers[MCP_SERVER_INFO.name] = {
       type: "http",
-      url: generationEndpoint(opts.endpoint ?? relayMcpEndpoint(opts.relayUrl), opts.generation ?? "relay"),
+      url: opts.endpoint ?? relayMcpEndpoint(opts.relayUrl),
       headers: { Authorization: `Bearer \${${RELAY_MCP_TOKEN_ENV}}` },
     };
   }
@@ -400,7 +387,6 @@ export interface OpenCodeMcpConfigOpts {
   relayUrl: string;
   endpoint?: string;
   includeRelay: boolean;
-  generation?: ToolGeneration;
   servers?: Record<string, ProvisioningMcpServer>;
 }
 
@@ -408,9 +394,9 @@ export interface OpenCodeMcpConfigOpts {
 export function openCodeMcpConfigPayload(opts: OpenCodeMcpConfigOpts): Record<string, unknown> {
   const mcp: Record<string, unknown> = {};
   if (opts.includeRelay) {
-    mcp[mcpServerInfo(opts.generation ?? "relay").name] = {
+    mcp[MCP_SERVER_INFO.name] = {
       type: "remote",
-      url: generationEndpoint(opts.endpoint ?? relayMcpEndpoint(opts.relayUrl), opts.generation ?? "relay"),
+      url: opts.endpoint ?? relayMcpEndpoint(opts.relayUrl),
       headers: { Authorization: `Bearer {env:${RELAY_MCP_TOKEN_ENV}}` },
       oauth: false,
       timeout: OPENCODE_MCP_TIMEOUT_MS,
@@ -426,7 +412,7 @@ export function openCodeMcpConfigPayload(opts: OpenCodeMcpConfigOpts): Record<st
 
 export function claudeMcpLaunchArgs(opts: ClaudeMcpConfigOpts & {
   strict?: boolean;
-  /** #1292 — when set, `--mcp-config` points at this path instead of carrying the JSON
+  /** when set, `--mcp-config` points at this path instead of carrying the JSON
    *  inline. Inline JSON lands verbatim in argv, which is world-readable via `ps`/
    *  `/proc/<pid>/cmdline`; a provisioned server's `env`/`headers` can carry a literal
    *  secret, so any launch with a relay-owned scratch dir to write into (see
@@ -442,8 +428,8 @@ export function claudeMcpLaunchArgs(opts: ClaudeMcpConfigOpts & {
   return ["--mcp-config", configArg, ...(opts.strict ? ["--strict-mcp-config"] : [])];
 }
 
-// #555 (Codex) — `-c mcp_servers.<name>.*` overrides for each relay-provisioned server, the
-// same shape relayMcpCodexConfigArgs uses for the relay endpoint. #1292 — this puts a
+// (Codex) — `-c mcp_servers.<name>.*` overrides for each relay-provisioned server, the
+// same shape relayMcpCodexConfigArgs uses for the relay endpoint. This puts a
 // provisioned server's literal `env`/`headers` secret material in argv (world-readable via
 // `ps`/`/proc/<pid>/cmdline`), so it's ONLY safe to use when there is no isolated CODEX_HOME
 // to materialize `codexProvisionedMcpToml` into instead (host-base Codex reuses the real
@@ -464,12 +450,12 @@ export function codexProvisionedMcpArgs(servers?: Record<string, ProvisioningMcp
       args.push("-c", `${key}.env.${envKey}=${tomlString(envVal)}`);
     }
     if (server.disabled_tools?.length) args.push("-c", `${key}.disabled_tools=${tomlValue(server.disabled_tools)}`);
-    args.push(...codexTimeoutConfigArgs(key)); // #1248
+    args.push(...codexTimeoutConfigArgs(key));
   }
   return args;
 }
 
-// #1292 — the non-secret half of the provisioned-server `-c` overrides (per-server
+// the non-secret half of the provisioned-server `-c` overrides (per-server
 // tool/startup timeouts only). Pairs with `codexProvisionedMcpToml`, which carries
 // command/args/url/env into CODEX_HOME/config.toml instead of argv.
 export function codexProvisionedMcpTimeoutArgs(servers?: Record<string, ProvisioningMcpServer>): string[] {
@@ -481,7 +467,7 @@ export function codexProvisionedMcpTimeoutArgs(servers?: Record<string, Provisio
   return args;
 }
 
-// #1292 — renders provisioned servers as `[mcp_servers.<name>]` / `[mcp_servers.<name>.env]`
+// renders provisioned servers as `[mcp_servers.<name>]` / `[mcp_servers.<name>.env]`
 // TOML tables for CODEX_HOME/config.toml, mirroring the `-c mcp_servers.<name>.*` dotted-key
 // shape `codexProvisionedMcpArgs` uses, so command/args/url/env never touch argv. Table/key
 // names are always TOML-quoted (server + env-var names aren't guaranteed bare-key safe).
@@ -544,7 +530,7 @@ export function upsertTomlTable(config: string, header: string, bodyLines: strin
   return lines.join("\n");
 }
 
-// #1292 — idempotently upsert provisioned MCP servers' command/args/url/env into
+// idempotently upsert provisioned MCP servers' command/args/url/env into
 // CODEX_HOME/config.toml, the isolated per-instance home Codex actually reads. Pairs with
 // `codexProvisionedMcpTimeoutArgs` (the non-secret `-c` overrides that stay in argv). Only
 // safe to call for an ISOLATED CODEX_HOME (host-base reuses the real `~/.codex`, which relay
@@ -553,7 +539,7 @@ export function writeCodexMcpServersToml(codexHome: string, servers: Record<stri
   const relevant = Object.entries(servers ?? {}).filter(([name]) => !isRelayMcpServerName(name));
   const configPath = join(codexHome, "config.toml");
   const existing = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
-  // #3387 — every mcp_servers table in a managed CODEX_HOME is Relay-written: drop the previous
+  // every mcp_servers table in a managed CODEX_HOME is Relay-written: drop the previous
   // launch's set first, so a host MCP class switched off on reuse leaves no stale server behind.
   let config = withoutTomlTables(existing, "mcp_servers.");
   if (!relevant.length) {

package/src/reply-obligation-cache.ts

@@ -4,9 +4,9 @@ import { latestReplyableMessage, type ProviderSessionEvent } from "./adapter";
 import { logger } from "./logger";
 import { receivesTurnResponseAutomatically } from "./response-routing";
 
-// Phase 2 (#196) — the crux. The Claude Stop hook used to ask the server, synchronously
+// Phase 2 — the crux. The Claude Stop hook used to ask the server, synchronously
 // and in the hot path, "does this agent owe a reply?" before clearing the turn. A slow
-// server answer (the unindexed reply_to scan, #199) blew the hook's timeout and wedged the
+// server answer (the unindexed reply_to scan) blew the hook's timeout and wedged the
 // agent in `busy` forever. The fix: the hook asks the Runner, the Runner answers instantly
 // from this local snapshot, and the snapshot is refreshed from the server only in the
 // background — never on the path that ends a turn.
@@ -23,13 +23,13 @@ export function obligationRequiresExplicitReply(obligation: ReplyObligation): bo
   return !receivesTurnResponseAutomatically(obligation.from);
 }
 
-// #2831 — automatic nags (Stop-hook block, idle re-injection) skip an obligation the server marked
-// deferred: its owner is waiting on its own relay_run. The obligation itself stays open.
+// automatic nags (Stop-hook block, idle re-injection) skip an obligation the server marked
+// deferred: its owner is waiting on its own humwick_run. The obligation itself stays open.
 export function obligationNagEligible(obligation: ReplyObligation): boolean {
   return obligationRequiresExplicitReply(obligation) && obligation.nagDeferral === undefined;
 }
 
-// #2335 (P1 privacy) — does this obligation's originator sit behind a CHANNEL-EGRESS bridge
+// (P1 privacy) — does this obligation's originator sit behind a CHANNEL-EGRESS bridge
 // (`telegram:<account>`, …)? A bridge forwards what it receives to a real human's DM, so the runner's
 // auto-captured turn narration must never be ADDRESSED at one; the obligation itself still stands and
 // still requires an EXPLICIT reply (obligationRequiresExplicitReply is deliberately untouched).
@@ -72,14 +72,14 @@ export function responseCaptureReplyRoute(
 
 type ReplyObligationFetch = () => Promise<ReplyObligation[]>;
 
-/** The route a turn opened by this delivered batch answers (#2840): its latest replyable message that could
+/** The route a turn opened by this delivered batch answers: its latest replyable message that could
  * carry an obligation — never the agent's own run/timer wake (sent to itself) nor a system/control notice. */
 export function deliveredBatchReplyRoute(messages: Message[], selfId?: string): NonNullable<ProviderSessionEvent["replyRoute"]> | null {
   const replyable = latestReplyableMessage(messages.filter((m) => m.from !== m.to && m.from !== selfId && !isMechanicalMessageKind(m.kind)));
   return replyable ? { to: replyable.from, replyToMessageId: replyable.id, channelTarget: obligationOriginatesFromChannel(replyable), replyExpected: replyable.replyExpected === true } : null;
 }
 
-/** #2840 — the server's "answered" rule (annotateAnsweredMessages): the agent replied to it or later in
+/** the server's "answered" rule (annotateAnsweredMessages): the agent replied to it or later in
  * its thread with a live (non-suppressed) message, or acknowledged it with an ack reaction. */
 export function threadAnswers(thread: Message[], askedId: number, agentId: string): boolean {
   const asked = thread.find((m) => m.id === askedId);
@@ -93,7 +93,7 @@ function repliesTo(thread: Message[], askedId: number, agentId: string): boolean
   return thread.some((m) => m.from === agentId && m.kind !== "session" && m.replyTo === askedId && (isHumanAgentId(m.to) || m.payload?.reportSuppression === undefined));
 }
 
-// Peer chat has no obligation row and can be acknowledged without a reply, so the thread decides: relay_reply
+// Peer chat has no obligation row and can be acknowledged without a reply, so the thread decides: humwick_reply
 // (or 👍) followed by a native final stays single. A route backed by an obligation row (a reply-expected
 // message, or `fromObligationRow`) follows the server's settle rule and is already proven open when unreadable.
 export async function submittedResponseReplyRoute(
@@ -175,7 +175,7 @@ export class ReplyObligationCache {
     this.dirtyTimer.unref?.();
   }
 
-  // #2831 — a nag (Stop-hook block, idle re-injection) decided on a stale snapshot can miss a relay_run
+  // a nag (Stop-hook block, idle re-injection) decided on a stale snapshot can miss a humwick_run
   // started this turn, or one that just settled. Re-read once, bounded well under the Stop hook's 2s
   // curl budget, but only when an explicit-reply obligation is in play; otherwise serve the snapshot.
   async freshForNag(timeoutMs = NAG_REFRESH_TIMEOUT_MS): Promise<ReplyObligation[]> {

package/src/response-capture-report.ts

@@ -14,7 +14,7 @@ type SessionPublisher = (input: {
   replyTo?: number;
 }) => void | Promise<void>;
 
-/** The turn-final capture's addressing, after the #2335 channel guard has had its say. */
+/** The turn-final capture's addressing, after the channel guard has had its say. */
 interface CaptureRoute {
   to: string;
   replyTo?: number;
@@ -29,13 +29,13 @@ interface CapturedResponseInput {
   session: MessageSessionMeta;
   replyTo?: number;
   /**
-   * #2335 — the reply route resolved to a CHANNEL-EGRESS bridge (see obligationOriginatesFromChannel,
+   * the reply route resolved to a CHANNEL-EGRESS bridge (see obligationOriginatesFromChannel,
    * runner/src/reply-obligation-cache.ts). Set by the caller; absent means "not a channel".
    */
   channelTarget?: boolean;
 }
 
-// #1086: dual-stamp the Part A (#1082) turn-finality field alongside the legacy
+// dual-stamp the Part A turn-finality field alongside the legacy
 // `final` alias so old consumers keep working while new ones can key off the
 // typed `turnFinal` flag directly instead of every writer's own `final: true`.
 function finalSession(session: MessageSessionMeta): MessageSessionMeta {
@@ -43,7 +43,7 @@ function finalSession(session: MessageSessionMeta): MessageSessionMeta {
 }
 
 /**
- * #2335 (P1 privacy) — the runner-side half of "auto-captured narration NEVER reaches a channel".
+ * (P1 privacy) — the runner-side half of "auto-captured narration NEVER reaches a channel".
  *
  * What this function captures is the agent's raw terminal narration at turn end: its own running
  * commentary, written for its operator's scrollback. Whenever a reply obligation was open, that text
@@ -59,10 +59,10 @@ function finalSession(session: MessageSessionMeta): MessageSessionMeta {
  * stamp and the channel-recipient poll (isDisallowedChannelContent, src/db/channel-egress-allowlist.ts),
  * which is what still holds when the sender is a stale runner, an automation, or a raw POST.
  *
- * The capture is not discarded — #1083 requires a turn-final capture to ALWAYS be mirrored. It is
+ * The capture is not discarded — requires a turn-final capture to ALWAYS be mirrored. It is
  * re-addressed to the `user` dashboard-mirror sink with the reply link dropped, exactly the shape an
  * autonomous turn with no eligible obligation already produces. Dropping `replyTo` is the point, not a
- * side effect: the channel obligation stays OPEN and still demands an explicit `relay_reply` /
+ * side effect: the channel obligation stays OPEN and still demands an explicit `humwick_reply` /
  * `relay_egress_to_channel`, so a channel gets a deliberate, addressed answer or none at all.
  */
 function captureRoute(input: CapturedResponseInput): CaptureRoute {
@@ -74,10 +74,10 @@ export async function publishCapturedResponse(input: CapturedResponseInput & {
   publishSessionEvent: SessionPublisher;
 }): Promise<void> {
   const route = captureRoute(input);
-  // #2844 — the enqueued chat report IS the parent delivery, so the mirror stays
+  // the enqueued chat report IS the parent delivery, so the mirror stays
   // transcript-only (`user` sink): at most one parent-addressed row per turn-final. (Before,
   // the mirror ALSO went to the parent, doubling opener-answered turns and splitting the
-  // #2831/#2840 suppression decision.) The mirror keeps replyTo + turn stamp for lineage.
+  // suppression decision.) The mirror keeps replyTo + turn stamp for lineage.
   const reported = input.replyTo !== undefined && !receivesTurnResponseAutomatically(input.to) && input.channelTarget !== true;
   await input.publishSessionEvent({
     from: input.from,
@@ -90,7 +90,7 @@ export async function publishCapturedResponse(input: CapturedResponseInput & {
 }
 
 export function enqueueCapturedResponseReport(input: CapturedResponseInput): void {
-  // #2335 — `to === "user"` is kept (the dashboard mirror already carries the turn; a report would
+  // `to === "user"` is kept (the dashboard mirror already carries the turn; a report would
   // double it) but is NO LONGER the only skip: a channel-egress target is dropped outright, whether
   // it arrived here pre-rewritten by captureRoute or straight from a caller that never consulted it.
   if (!input.replyTo || receivesTurnResponseAutomatically(input.to) || input.channelTarget === true) return;

package/src/response-routing.ts

@@ -1,6 +1,6 @@
 import { isHumanAgentId } from "@humwick/sdk/types/users";
 // The runner mirrors every completed turn to the dashboard's user sink, regardless of role.
-// Keep header/nag policy and capture-report routing on the same recipient rule (#3346).
+// Keep header/nag policy and capture-report routing on the same recipient rule.
 export function receivesTurnResponseAutomatically(recipient: string): boolean {
   return isHumanAgentId(recipient);
 }