@humwick/runner 0.130.5 → 0.130.6

package/src/adapters/codex.ts

@@ -26,7 +26,7 @@ import { codexWebToolsConfigArgs, launchWebTools } from "../web-tools";
 import { codexMcpOutputRedactor } from "./codex-tool-output";
 
 /** Relay context prepended to a Codex agent's first turn: the standard relay
- * blurb plus, when running in an isolated workspace, the deps caveat (#159). */
+ * blurb plus, when running in an isolated workspace, the deps caveat. */
 function codexRelayContextBlock(process: ManagedProcess): string {
   const config = process.meta?.config as RunnerSpawnConfig | undefined;
   return [resolveRelayContext({
@@ -70,13 +70,13 @@ type PendingCodexCompact = {
 
 const CODEX_COMPACT_TIMEOUT_MS = 10 * 60 * 1000;
 
-// #2539 Phase A — bounded memory of clientUserMessageIds POSITIVELY accepted by the app-server
+// Phase A — bounded memory of clientUserMessageIds POSITIVELY accepted by the app-server
 // (observed via the userMessage item echo). Insertion-ordered, oldest evicted; the reconcile
 // path only needs recent turns' ids.
 const CODEX_STEER_ACCEPTED_CLIENT_CAP = 128;
 
 /**
- * #2539 Phase A — classify a rejected `turn/steer` RPC so the fallback matches the refusal.
+ * Phase A — classify a rejected `turn/steer` RPC so the fallback matches the refusal.
  * The app-server refuses steer against a turn that cannot take additive input (review/compact)
  * and against a turn id that is no longer active (ended under us / expected-id mismatch); both
  * are expected flow control, distinct from transport faults (socket, 30s timeout — an AMBIGUOUS
@@ -110,9 +110,9 @@ export class CodexAdapter implements ProviderAdapter {
   readonly provider = "codex";
   readonly reportsContextResets = true;
   readonly supportsMidTurnSteer = true;
-  // #2569 — clearContext starts a FRESH thread and compact rewrites the current one, both via an
+  // clearContext starts a FRESH thread and compact rewrites the current one, both via an
   // awaited app-server handshake. That await confirms the new generation is ready but does NOT
-  // settle the predecessor turn (the model calls relay_compact_and_resume from within its own live
+  // settle the predecessor turn (the model calls humwick_compact_and_resume from within its own live
   // turn). Without a fence, that turn keeps writing the worktree on the old thread while the
   // successor generation writes on the new one. The runner therefore interrupts + settles the
   // predecessor turn before compact/clearContext (interrupt-then-settle, via the primitives below).
@@ -127,42 +127,42 @@ export class CodexAdapter implements ProviderAdapter {
   private activeTurnId?: string;
   private lastCompactionKey?: string;
   private turnFailure?: ReturnType<typeof codexTurnFailure>;
-  // #1339: the turn id we last logged a delivery-deferral for, so the once-per-turn "held
+  // the turn id we last logged a delivery-deferral for, so the once-per-turn "held
   // behind active turn" notice isn't repeated on every ~1s runner retry during that turn.
   private deferredForTurnId?: string;
-  // #2539 Phase A — the turn id whose steer the app-server REJECTED as not steerable
+  // Phase A — the turn id whose steer the app-server REJECTED as not steerable
   // (review/compact). Once set for a turn id, mid-turn offers silently defer until the turn id
   // changes, instead of re-attempting the RPC on every ~1s drain only to be refused again.
   private steerDeniedForTurnId?: string;
-  // #2539 Phase A — clientUserMessageIds POSITIVELY accepted by the app-server (the userMessage
+  // Phase A — clientUserMessageIds POSITIVELY accepted by the app-server (the userMessage
   // item echoes the steered input's clientId). The reconcile path reads this to settle an
   // accepted-but-response-lost steer instead of re-steering (which could duplicate the input).
   private readonly acceptedSteerClientIds = new Set<string>();
-  // #653: monotonic id for a turn we synthesize from live item activity when a real
+  // monotonic id for a turn we synthesize from live item activity when a real
   // turn/started never reached us — so a working Codex agent isn't reported `idle`.
   private syntheticTurnSeq = 0;
-  // #2543: monotonic clientUserMessageId sequence for prompt injections steered into a live
+  // monotonic clientUserMessageId sequence for prompt injections steered into a live
   // turn — per-attempt unique (the app-server echoes it back; no reconcile reads it).
   private injectionSteerSeq = 0;
   private tokenUsageReporter?: ProviderTokenUsageReporter;
   private readonly agentMessageCapture = new CodexAgentMessageCapture();
   private readonly itemTextBuffers = new Map<string, string>();
   private readonly itemTextBufferTypes = new Map<string, string>();
-  // #183/#184: the normalized session-event log for the current process lifetime, fed
+  // the normalized session-event log for the current process lifetime, fed
   // from the same completed-item stream that drives the chat mirror. The runner slices
   // this per-segment (since the last compact/clear/restart) via its own cursor, so we
   // accumulate and never clear mid-session; spawn() resets it for a fresh process. Soft
   // cap below keeps a runaway session from growing memory unbounded.
   private sessionEvents: SessionEvent[] = [];
   private static readonly SESSION_EVENTS_CAP = 50_000;
-  // #3411 — the session cwd a fileChange's relative paths resolve against.
+  // the session cwd a fileChange's relative paths resolve against.
   private sessionCwd?: string;
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
   }
 
-  // §4.1 contract verdict (#746). Codex reference (#724): a Codex provider-turn can wedge
+  // §4.1 contract verdict. Codex reference: a Codex provider-turn can wedge
   // while a long-running subprocess child (a `bun test` / build gate) is still alive and
   // making real progress. That subprocess is tracked as a non-`provider-turn` work-kind, so
   // `hasLiveWork` stays true and the turn is never mis-read as stuck; app-server item events
@@ -178,7 +178,7 @@ export class CodexAdapter implements ProviderAdapter {
 
   private resetProcessState(): void {
     this.resetThreadState();
-    this.sessionEvents = []; // fresh process -> fresh segment cursor (#184)
+    this.sessionEvents = []; // fresh process -> fresh segment cursor
   }
 
   private resetThreadState(): void {
@@ -208,9 +208,9 @@ export class CodexAdapter implements ProviderAdapter {
     const client = process.meta?.client as CodexAppClient | undefined;
     if (!client?.isConnected()) return "unknown";
     const threadId = typeof process.meta?.threadId === "string" ? process.meta.threadId : "";
-    // #651: when no local activeTurnId, don't short-circuit to idle — query the app-server.
+    // when no local activeTurnId, don't short-circuit to idle — query the app-server.
     // turn/started can arrive after processing begins (or be missed entirely); a stale-idle
-    // probe would make a busy agent appear idle to the coordinator. Same fallback as #653's
+    // probe would make a busy agent appear idle to the coordinator. Same fallback as the
     // ensureMainTurnActive path, but for the pull (probe) direction, not the push (event) one.
     if (!this.activeTurnId) {
       if (!threadId) return "idle";
@@ -341,7 +341,7 @@ export class CodexAdapter implements ProviderAdapter {
     return { threadId };
   }
 
-  /** #3398 — every compaction of the main thread is a context reset, whether or not compact() still waits for it. */
+  /** every compaction of the main thread is a context reset, whether or not compact still waits for it. */
   private onThreadCompacted(process: ManagedProcess, threadId: string, turnId: string | undefined, compactTrigger: "manual" | "auto"): void {
     if (threadId !== process.meta?.threadId) return;
     // thread/compacted and the compaction item report the same compaction.
@@ -401,15 +401,15 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   async deliverInitialPrompt(process: ManagedProcess, prompt: string, options?: PromptOfferOptions): Promise<void> {
-    const text = sanitizeLaunchText(prompt, "initial prompt").trim(); // options.readyTimeoutMs (#329) is a Claude-TUI concern; ignored here
+    const text = sanitizeLaunchText(prompt, "initial prompt").trim(); // options.readyTimeoutMs is a Claude-TUI concern; ignored here
     if (!text) return;
     const threadId = await ensureCodexThread(process);
-    // #1228: only a genuine first turn gets the initial-prompt label — a mid-session
+    // only a genuine first turn gets the initial-prompt label — a mid-session
     // dashboard continue/injection (isInitial: false) is delivered as a plain turn.
     const isInitial = options?.isInitial !== false;
-    // #2543 — the last provider-input path without an active-turn guard: a non-initial injection
+    // the last provider-input path without an active-turn guard: a non-initial injection
     // (dashboard continue/hard-redirect, AskUserQuestion answer, empty-turn nudge) offered while
-    // a turn is ACTIVE must never issue turn/start (#1339: the app-server silently drops it).
+    // a turn is ACTIVE must never issue turn/start (the app-server silently drops it).
     // Fold it into the live turn via the same additive turn/steer channel deliverMidTurn uses; a
     // refusal defers by throwing the shared turn-in-progress signal, which the runner's injection
     // paths translate into a bounded wait-for-turn-clear + re-offer. A genuine initial prompt
@@ -420,10 +420,10 @@ export class CodexAdapter implements ProviderAdapter {
     }
     let input = [
       codexLaunchContext(process),
-      ...(isInitial ? ["[agent-relay initial prompt from dashboard]"] : []),
+      ...(isInitial ? ["[humwick initial prompt from dashboard]"] : []),
       text,
     ].filter(Boolean).join("\n\n");
-    // #2542 — transactional first-delivery context (#2539 design C applied to this start path):
+    // transactional first-delivery context (design C applied to this start path):
     // stage the relay-context block but commit relayContextSent ONLY after turn/start is
     // positively accepted, so a failed first turn/start (ready-signal retry, spawn retry) still
     // carries the context instead of silently losing it.
@@ -438,7 +438,7 @@ export class CodexAdapter implements ProviderAdapter {
     const started = await client.turnStart(threadId, input);
     options?.inputObserver?.consumed();
     if (relayContextPending) process.meta = { ...(process.meta ?? {}), relayContextSent: true };
-    // #1565 F1 — claim the turn from the RESPONSE, the same hardening deliver() has: without it,
+    // F1 — claim the turn from the RESPONSE, the same hardening deliver has: without it,
     // a second input in the notification lag read activeTurnId as undefined and issued a
     // concurrent turn/start the app-server silently dropped. A later turn/started overwrites
     // this id; the completion/interrupt/probeActivity paths clear it, so it cannot wedge.
@@ -446,8 +446,8 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2543 — fold a non-initial prompt injection into the ACTIVE turn via the additive
-   * `turn/steer` channel (the #2539 Phase A channel, shared with deliverMidTurn). The relay
+   * fold a non-initial prompt injection into the ACTIVE turn via the additive
+   * `turn/steer` channel (the Phase A channel, shared with deliverMidTurn). The relay
    * context is not re-prepended: an active turn can only exist if its own accepted start already
    * carried (and committed) the first-delivery context. Refusals DEFER — the shared
    * turn-in-progress signal makes the runner's injection paths wait for the turn to clear and
@@ -485,16 +485,16 @@ export class CodexAdapter implements ProviderAdapter {
 
   async deliver(process: ManagedProcess, messages: Message[], ctx?: ProviderDeliverContext): Promise<void | number[]> {
     const threadId = await ensureCodexThread(process);
-    // #2539 Phase A — a mid-turn offer goes through the adapter-owned steer contract: the
+    // Phase A — a mid-turn offer goes through the adapter-owned steer contract: the
     // steerable subset folds into the in-flight turn (soft-steer is the codex default), while
     // boundary-only classes stay un-acked for the runner to requeue toward turn-end. An idle
     // offer takes the WHOLE ordered batch as one fresh turn/start — NEVER turn/start while a
-    // turn is active (#1339: the app-server would drop it).
+    // turn is active (the app-server would drop it).
     if (this.activeTurnId !== undefined) {
       return this.deliverMidTurn(process, messages, ctx);
     }
     const client = process.meta?.client as CodexAppClient;
-    // #2542 — transactional formatting state on the IDLE turn/start path (#2539 design C, the
+    // transactional formatting state on the IDLE turn/start path (design C, the
     // same fix deliverMidTurn already has): stage the first-delivery
     // relay context, and commit BOTH only after turn/start is positively accepted — a failed
     // start must not consume the first-delivery context, so the runner's requeue re-offers WITH
@@ -510,7 +510,7 @@ export class CodexAdapter implements ProviderAdapter {
     const started = await client.turnStart(threadId, text);
     ctx?.inputObserver?.consumed();
     if (relayContextPending) process.meta = { ...(process.meta ?? {}), relayContextSent: true };
-    // #1565 F1 — claim the turn from the RESPONSE, not from the later `turn/started` notification.
+    // F1 — claim the turn from the RESPONSE, not from the later `turn/started` notification.
     // The guard above is only as good as the state it reads: with the turn id arriving a few ms
     // later over the event stream, a second delivery in that window passed the guard and issued a
     // concurrent turn/start on the same thread, which the app-server silently drops — while its
@@ -522,7 +522,7 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   /**
-   * #2539 Phase A — the codex implementation of the shared mid-turn steer contract (see
+   * Phase A — the codex implementation of the shared mid-turn steer contract (see
    * {@link ProviderAdapter.deliverMidTurn}). Steerable messages fold into the in-flight turn via
    * the ADDITIVE app-server `turn/steer`: the running tool/response step finishes untouched, and
    * the injected input is drained before the next model request — never an abort, never a
@@ -577,7 +577,7 @@ export class CodexAdapter implements ProviderAdapter {
       logger.info("codex", `steer for Codex turn ${steerTurnId} was already accepted (clientId ${clientUserMessageId}); settling ${eligible.length} message${eligible.length === 1 ? "" : "s"} without re-steering`);
       return eligible.map((message) => message.id);
     }
-    // Transactional formatting state (#2539 design C): prepare the Relay context, send,
+    // Transactional formatting state: prepare the Relay context, send,
     // and commit it ONLY on positive acceptance.
     let steerText = [codexLaunchContext(process), providerMessageText(eligible)].filter(Boolean).join("\n\n");
     let relayContextPending = false;
@@ -670,14 +670,14 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   buildSpawnArgs(config: RunnerSpawnConfig, providerConfig: ProviderConfig): SpawnArgs {
-    // #2719 — the fallback listen port is allocated, never derived: `controlPort + 1000`
+    // the fallback listen port is allocated, never derived: `controlPort + 1000`
     // overflowed 65535 on a high ephemeral control port (macOS), which the app-server does not
     // report as a bad port — it binds elsewhere and the client then polls a dead URL.
     const appServerUrl = String(config.appServerUrl || process.env.CODEX_APP_SERVER_URL || `ws://127.0.0.1:${allocateLoopbackPort()}`);
     // Create + bootstrap the isolated CODEX_HOME (no-op for host base) so the assembler's
     // materialize step has somewhere to write the provisioned skills.
     prepareCodexProfileHome(config);
-    // #557 — ONE assembler owns the provisioning/vanilla surface (skills.config, relay +
+    // ONE assembler owns the provisioning/vanilla surface (skills.config, relay +
     // provisioned -c mcp_servers.*, project_doc_max_bytes); profile-projection describes the
     // SAME assembled result, so report == launch. The adapter only adds core launch config the
     // assembler does not own: app-server wiring, model/approval/tool-output, managed flags, --listen.
@@ -704,11 +704,11 @@ export class CodexAdapter implements ProviderAdapter {
       cwd: config.cwd,
       env: writeChildEnv({}, {
         ...config.env,
-        // #557 — the assembler owns the isolated config-home env (CODEX_HOME).
+        // the assembler owns the isolated config-home env (CODEX_HOME).
         ...assembled.env,
         CODEX_APP_SERVER_URL: appServerUrl,
-        AGENT_RELAY_PROVIDER: "codex",
-      }),
+        HUMWICK_PROVIDER: "codex",
+      }, []),
     });
   }
 
@@ -716,7 +716,7 @@ export class CodexAdapter implements ProviderAdapter {
     if (event.type === "server-request" && process) {
       const approval = codexApprovalFromServerRequest(event.message);
       if (approval) {
-        // #435/#723 ordering invariant: mirror every reasoning/narrative step of the turn
+        // ordering invariant: mirror every reasoning/narrative step of the turn
         // BEFORE the approval form surfaces — the same guarantee Claude makes by pre-flushing
         // the transcript at its hook seam, here enforced from the Codex app-server mechanism.
         // approval.view.reasoningSettled === true asserts this flush has run.
@@ -730,7 +730,7 @@ export class CodexAdapter implements ProviderAdapter {
             state: "blocked",
             reason: "permissionRequest",
             label: approval.view.title,
-            recommendedAction: "Review the permission request in Agent Relay.",
+            recommendedAction: "Review the permission request in Humwick.",
             source: "codex",
             pendingApproval: approval.view,
             updatedAt: Date.now(),
@@ -744,12 +744,12 @@ export class CodexAdapter implements ProviderAdapter {
         // managed agent has no human to answer it; the old -32601 reject makes codex resolve
         // the elicitation as `Decline`, so the MCP tool call dies with "user rejected MCP tool
         // call" — stranding read-only recon/reviewer workers with no egress to report back
-        // over the bus (#395). The agent is already bounded by its scoped relay token + the
+        // over the bus. The agent is already bounded by its scoped relay token + the
         // codex sandbox, so auto-accept (spec-compliant `{ action: "accept" }`, not codex's
         // legacy `{ decision: "approved" }`) so the agent's reporting/recon MCP tools run.
         const client = process.meta?.client as CodexAppClient | undefined;
         const serverName = isRecord(event.message.params) ? stringValue(event.message.params.serverName) : undefined;
-        logger.info("codex", `auto-accepting headless MCP elicitation from ${serverName ?? "unknown server"} so the agent's MCP tools can run (#395)`);
+        logger.info("codex", `auto-accepting headless MCP elicitation from ${serverName ?? "unknown server"} so the agent's MCP tools can run`);
         client?.respondToServerRequest(event.message.id, codexHeadlessElicitationResponse());
       } else {
         const client = process.meta?.client as CodexAppClient | undefined;
@@ -844,7 +844,7 @@ export class CodexAdapter implements ProviderAdapter {
   // Turn one completed Codex thread item into a session-mirror event. agentMessage text is
   // mirrored as narration as it lands; the captured turn-final response repeats only the
   // TRAILING agentMessage run — the segment after the last tool/file-change/reasoning
-  // boundary (design #1079 §3.2) — never earlier mid-work narration, which was already
+  // boundary — never earlier mid-work narration, which was already
   // mirrored live. The rest (user prompt echo, reasoning, tool steps) is surfaced as it lands.
   private handleCodexItem(item: Record<string, unknown> | undefined): void {
     if (!item) return;
@@ -856,11 +856,11 @@ export class CodexAdapter implements ProviderAdapter {
     // buffered reasoning first so it lands in transcript order, ahead of this tool/message.
     if (type !== "reasoning") this.flushBufferedReasoning();
     if (type === "agentMessage") {
-      this.agentMessageCapture.completeItem(itemId, stringValue(item.text), (body) => this.emitAgentNarration(body), { phase: item.phase });
+      this.agentMessageCapture.completeItem(itemId, typeof item.text === "string" ? item.text : undefined, (body) => this.emitAgentNarration(body), { phase: item.phase });
       return;
     }
     if (type === "userMessage") {
-      // #2539 Phase A — the app-server echoes a steered input's clientUserMessageId as the
+      // Phase A — the app-server echoes a steered input's clientUserMessageId as the
       // item's clientId. Observing it is the POSITIVE acceptance evidence that reconciles an
       // accepted-but-response-lost steer: the next offer of the same composition settles by
       // correlation instead of re-steering.
@@ -891,7 +891,7 @@ export class CodexAdapter implements ProviderAdapter {
       if (codexItemFailed(item)) this.recordInsightEvent({ type: "tool_error" });
       // stepId = the app-server item id: the server upserts the running step emitted on
       // item/started into this terminal state IN PLACE, so the tool persists as ONE row.
-      // #2354 — a FAILED item was previously hardcoded to status:"completed", so a tool that
+      // a FAILED item was previously hardcoded to status:"completed", so a tool that
       // errored rendered identical to one that succeeded. `codexItemFailed` is the same
       // failed-outcome predicate used for the insight proxy above; map it through to the shared
       // `failed` status so every provider agrees on the contract.
@@ -923,7 +923,7 @@ export class CodexAdapter implements ProviderAdapter {
     }
   }
 
-  // #183/#184: append to the session-event log with a soft cap. On overflow we drop the
+  // append to the session-event log with a soft cap. On overflow we drop the
   // oldest half; the runner detects the resulting length shrink and resets its segment
   // cursor (worst case: one slightly-truncated datapoint on a pathologically long session).
   private recordInsightEvent(event: SessionEvent): void {
@@ -933,14 +933,14 @@ export class CodexAdapter implements ProviderAdapter {
     }
   }
 
-  // Whole-session event stream for the Insights context-ratio signal (#184). Codex learns
+  // Whole-session event stream for the Insights context-ratio signal. Codex learns
   // about activity through app-server item events, not a transcript, so we replay the log
   // accumulated since this process started. The runner owns per-segment slicing.
   async collectSessionEvents(): Promise<SessionEvent[] | null> {
     return [...this.sessionEvents];
   }
 
-  // #653: Codex busy-state normally flips on turn/started, but the app-server can stream
+  // Codex busy-state normally flips on turn/started, but the app-server can stream
   // item activity (which already drives the dashboard chat mirror) before — or without —
   // a turn/started reaching us, leaving a visibly-working agent reported `idle` (a reap
   // hazard). Derive busy from that SAME live activity: any in-flight item event with no
@@ -997,12 +997,12 @@ export class CodexAdapter implements ProviderAdapter {
     if (method.includes("outputDelta") || method.includes("output_delta") || method.includes("progress")) return;
   }
 
-  // A turn-final capture is emitted ONLY for a genuine `completed` turn (design #1079 §3.2):
+  // A turn-final capture is emitted ONLY for a genuine `completed` turn:
   // failed/interrupted turns must never produce a turn-final. Every "response"-type
   // ProviderSessionEvent is unconditionally dual-stamped turnFinal/final downstream
   // (publishCapturedResponse's provider-agnostic stamp), so the only way to keep a
   // failed/interrupted partial OUT of D's work-final ring is to never emit it as a
-  // "response" event at all (#1083 Finding 1). The partial text was already mirrored live
+  // "response" event at all. The partial text was already mirrored live
   // as narration by the `emit` callback inside agentMessageCapture.finish(), so it's still
   // visible in the dashboard.
   private flushTurnResponse(endedBy: MessageTurnEndReason): void {
@@ -1086,10 +1086,10 @@ function codexDeltaText(params: Record<string, unknown> | undefined): string {
   const delta = params?.delta;
   if (typeof delta === "string") return delta;
   if (isRecord(delta)) {
-    const text = stringValue(delta.text) ?? stringValue(delta.value) ?? stringValue(delta.content);
-    if (text) return text;
+    for (const key of ["text", "value", "content"]) if (typeof delta[key] === "string") return delta[key];
   }
-  return stringValue(params?.text) ?? stringValue(params?.chunk) ?? stringValue(params?.content) ?? "";
+  for (const key of ["text", "chunk", "content"]) if (typeof params?.[key] === "string") return params[key];
+  return "";
 }
 
 function codexItemTypeFromMethod(method: string): string | undefined {
@@ -1098,12 +1098,12 @@ function codexItemTypeFromMethod(method: string): string | undefined {
 }
 
 // Codex forwards MCP elicitation (incl. its per-tool-call approval gate) to the app-server
-// client under this server-request method (#395). See handleCodexEvent for why a headless
+// client under this server-request method. See handleCodexEvent for why a headless
 // agent must answer it instead of rejecting it.
 export const CODEX_MCP_ELICITATION_METHOD = "mcpServer/elicitation/request";
 
 // A managed agent with no attended TUI (the spawn intent, `config.headless`) has no human to
-// resolve an elicitation. Such agents are the #395 case; interactive (TUI) sessions leave the
+// resolve an elicitation. Such agents are the case; interactive (TUI) sessions leave the
 // elicitation to the human in the attached terminal.
 function isCodexHeadless(process: ManagedProcess): boolean {
   return (process.meta?.config as RunnerSpawnConfig | undefined)?.headless === true;
@@ -1151,7 +1151,7 @@ export function codexReasoningText(item: Record<string, unknown>): string {
 }
 
 /** Build a compact { label, body } activity summary for a Codex tool item. */
-// Canonical tool name for the #184 gathering/action classifier. Codex item types map to
+// Canonical tool name for the gathering/action classifier. Codex item types map to
 // names the shared classifier already understands: commandExecution executes (→ Bash, an
 // action), fileChange mutates (→ Edit), webSearch gathers (→ WebSearch, in the set), and
 // MCP/dynamic calls carry their real tool name so name-shape classification applies.
@@ -1168,7 +1168,7 @@ export function codexInsightToolName(type: string | undefined, item: Record<stri
   }
 }
 
-// #1498: Codex app-server item types → the provider-independent category taxonomy. Codex has
+// Codex app-server item types → the provider-independent category taxonomy. Codex has
 // no MCP-tool-search or native read/ask-user-question item, so it simply never emits those
 // categories; webSearch and any other/future item type fall to "generic" rather than being
 // force-fit — the fallback exists precisely so nothing is hidden from the activity trace.
@@ -1196,7 +1196,7 @@ export function codexItemFailed(item: Record<string, unknown>): boolean {
 
 export function codexToolSummary(type: string | undefined, item: Record<string, unknown>, cwd?: string): { label: string; body: string; params?: unknown; paths?: string[] } | null {
   // One-line + redact + clip is the shared `tool-summary.ts` primitive (Claude/OpenCode parity);
-  // only Codex's per-item-type field mapping lives here. `params` (#2437) reuses the same raw
+  // only Codex's per-item-type field mapping lives here. `params` reuses the same raw
   // field each branch already extracted for its one-line body, redacted+capped separately for
   // the trace's expandable detail — the one-line label stays exactly as it was.
   const oneLine = oneLineText, clip = clipToolSummary, params = redactAndCapParams;
@@ -1207,7 +1207,7 @@ export function codexToolSummary(type: string | undefined, item: Record<string,
   if (type === "fileChange") {
     const changes = Array.isArray(item.changes) ? item.changes.filter(isRecord) : [];
     const files = changes.map((c) => stringValue(c.path) ?? stringValue(c.file) ?? "").filter(Boolean);
-    const paths = absoluteToolPaths(files, cwd); // #3411 — from the raw changes, never the capped params
+    const paths = absoluteToolPaths(files, cwd); // from the raw changes, never the capped params
     return { label: "Edit", body: clip(files.length ? files.join(", ") : "file changes"), params: params(item.changes), ...(paths ? { paths } : {}) };
   }
   if (type === "mcpToolCall" || type === "dynamicToolCall") {
@@ -1248,7 +1248,7 @@ function codexApprovalMethod(method: string): boolean {
 
 // Build the normalized InteractivePrompt for a Codex app-server approval request.
 // reasoningSettled is stamped `true` because handleCodexEvent flushes buffered reasoning +
-// any open narration segment BEFORE this view is emitted as pendingApproval (#435/#723). No
+// any open narration segment BEFORE this view is emitted as pendingApproval. No
 // `provider` tag — the server reads the typed contract, not provider identity.
 function codexApprovalView(id: string, method: string, params: Record<string, unknown>): InteractivePrompt {
   const command = typeof params.command === "string" ? params.command
@@ -1326,7 +1326,7 @@ async function ensureCodexThread(process: ManagedProcess): Promise<string> {
 export function codexDeliveryNotice(messages: Message[], threadId: string): string {
   const ids = messages.map((message) => `#${message.id}`).join(", ");
   const senders = [...new Set(messages.map((message) => message.from))].join(", ");
-  return `[agent-relay] received ${messages.length} relay message${messages.length === 1 ? "" : "s"} ${ids} from ${senders}; injecting into Codex thread ${threadId}`;
+  return `[humwick] received ${messages.length} relay message${messages.length === 1 ? "" : "s"} ${ids} from ${senders}; injecting into Codex thread ${threadId}`;
 }
 
 export function codexProviderStateFromThreadStatus(status: unknown, params?: Record<string, unknown>, now = Date.now()): ProviderState | undefined {
@@ -1413,7 +1413,7 @@ function activeFlags(value: unknown): string[] {
   return value.activeFlags.filter((flag): flag is string => typeof flag === "string" && flag.length > 0);
 }
 
-// #557 — bundledCodexSkillDirs + bundledSkillConfigArgs now live in ../launch-assembly
+// bundledCodexSkillDirs + bundledSkillConfigArgs now live in ../launch-assembly
 // (the single launch-arg home, shared with the assembler); re-exported so existing
 // codex.ts consumers + tests keep their import path. tomlString likewise from ../relay-mcp.
 export { bundledCodexSkillDirs, bundledSkillConfigArgs };
@@ -1426,7 +1426,7 @@ function codexRelayContextEnabled(process: ManagedProcess): boolean {
   return resolveRelayContext({ slug: "relay.context.codex", config }).available;
 }
 
-// Exported for integration coverage (#462): Codex has no `--append-system-prompt`
+// Exported for integration coverage: Codex has no `--append-system-prompt`
 // flag — the composed systemPromptAppend rides in as the launch-context message
 // prepended to the first turn. This is the Codex twin of Claude's append arg.
 export function codexLaunchContext(process: ManagedProcess): string | undefined {
@@ -1435,7 +1435,7 @@ export function codexLaunchContext(process: ManagedProcess): string | undefined
   if (!text || process.meta?.systemPromptAppendSent) return undefined;
   process.meta = { ...(process.meta ?? {}), systemPromptAppendSent: true };
   return [
-    "[agent-relay launch context]",
+    "[humwick launch context]",
     "The following context was attached when this provider session was launched. Treat it as background context, not as a user request and not as your own prior actions.",
     text,
   ].join("\n");

package/src/adapters/opencode-api.ts

@@ -21,7 +21,7 @@ export class OpenCodeApiBudget {
   private heartbeat?: ReturnType<typeof setInterval>;
 
   constructor(config: RunnerSpawnConfig) {
-    this.ledger = new ApiBudgetAccounting("openai-api", (action, body) => this.ledger.transport(config, action, { ...body, ...(action === "reserve" && relayEnv(config.env, "AGENT_RELAY_SPAWN_REQUEST_ID") ? { spawnRequestId: relayEnv(config.env, "AGENT_RELAY_SPAWN_REQUEST_ID") } : {}) }));
+    this.ledger = new ApiBudgetAccounting("openai-api", (action, body) => this.ledger.transport(config, action, { ...body, ...(action === "reserve" && relayEnv(config.env, "HUMWICK_SPAWN_REQUEST_ID") ? { spawnRequestId: relayEnv(config.env, "HUMWICK_SPAWN_REQUEST_ID") } : {}) }));
   }
 
   async start(sessionId: string): Promise<void> {

package/src/adapters/opencode-context.ts

@@ -1,10 +1,10 @@
 import type { ContextState } from "@humwick/sdk";
 import { providerContextState } from "../transcript-context";
 
-// #2355 — OpenCode's `/session/:id/message` response (and its `message.updated` SSE echo) carries
+// OpenCode's `/session/:id/message` response (and its `message.updated` SSE echo) carries
 // a per-assistant-message `tokens` object once the message finalizes: `{ input, output, reasoning,
 // cache: { read, write} }`, confirmed live against a real captured v1.18.21 session's SQLite
-// `message` table (issue #2355 investigation) — and, when present, a `total` leaf that is already
+// `message` table — and, when present, a `total` leaf that is already
 // the sum of all of those (`input + output + reasoning + cache.read + cache.write`). Unlike Codex's
 // `thread/tokenUsage/updated` (which also carries `modelContextWindow`), OpenCode's wire never
 // reports the model's context-window size anywhere — so the window has to come from the static,
@@ -17,9 +17,9 @@ import { providerContextState } from "../transcript-context";
 // confirms turn-to-turn. `confidence: "estimated"` (not "reported") makes that partial provenance
 // visible downstream instead of presenting the whole reading as fully API-confirmed.
 //
-// #2355 review (MED-1) — `tokensUsed === 0` is treated as NO SIGNAL, same as `undefined`, not as a
+// review (MED-1) — `tokensUsed === 0` is treated as NO SIGNAL, same as `undefined`, not as a
 // genuine zero-usage reading. `send()` calls this on EVERY completion, including a positively-parsed
-// EMPTY completion (`openCodeCompletion`'s `empty: true` path — #2389's deterministic-close path,
+// EMPTY completion (`openCodeCompletion`'s `empty: true` path — the deterministic-close path,
 // which reports `tokens: 0`). A finalized assistant message that actually engaged the model always
 // has `input > 0` (the prompt itself is never zero tokens), so a `total` of exactly 0 only ever
 // means "no usable token reading for this turn" — never "the context is now empty". Returning a real
@@ -46,7 +46,7 @@ export interface OpenCodeRelayContextInput {
 }
 
 /**
- * #2534 — proof-of-acceptance watcher for one context-carrying outbound prompt. Armed at
+ * proof-of-acceptance watcher for one context-carrying outbound prompt. Armed at
  * dispatch and consumed by the SSE `message.part.updated` door (or the bounded persisted-message
  * reconciliation) the moment OpenCode positively persists the prompt as a user message —
  * BEFORE the synchronous turn-completion await resolves, which on a long turn may only do so
@@ -58,7 +58,7 @@ export interface OpenCodeContextAcceptance {
   readonly emitsRelayContext: boolean;
   readonly emitsLaunchContext: boolean;
   /**
-   * #2534 review round 2 (MED-2) — epoch ms when THIS arm was dispatched. Every arm of send()'s
+   * review round 2 (MED-2) — epoch ms when THIS arm was dispatched. Every arm of send's
    * retry/re-roll loop dispatches the SAME immutable text into the SAME session, so the
    * reconciliation's persisted match needs a per-arm discriminator beyond text equality: a
    * persisted user message only proves THIS arm if it was created at or after this arm's
@@ -66,7 +66,7 @@ export interface OpenCodeContextAcceptance {
    */
   readonly dispatchedAt: number;
   /**
-   * #2534 review (MED-2) — accepted verdict for THIS dispatch arm, set only by this arm's own
+   * review (MED-2) — accepted verdict for THIS dispatch arm, set only by this arm's own
    * door or reconciliation. The durable first-turn markers are process-scoped and the prepared
    * context input is immutable across send()'s retry/re-roll loop, so a later arm that fails
    * PRE-acceptance must never inherit an earlier arm's acceptance: keying the verdict to the
@@ -82,15 +82,11 @@ function openCodeLaunchContext(process: ManagedProcess): string | undefined {
   const config = process.meta?.config as RunnerSpawnConfig | undefined;
   const text = config?.systemPromptAppend?.trim();
   if (!text || process.meta?.launchContextSent) return undefined;
-  return [
-    "[agent-relay launch context]",
-    "The following context was attached when this provider session was launched. Treat it as background context, not as a user request and not as your own prior actions.",
-    text,
-  ].join("\n");
+  return text;
 }
 
 /**
- * Prepare exactly one OpenCode turn with Relay context before its retry loop begins.
+ * Prepare one OpenCode turn and its native-instruction acceptance markers before retries.
  *
  * This deliberately does not mutate `relayContextSent`: a missing client/session, or a client
  * that throws before accepting a request, has not emitted the block and must leave the next
@@ -102,7 +98,9 @@ export function prepareOpenCodeRelayContext(process: ManagedProcess, text: strin
   const emitsRelayContext = context.available && !process.meta?.relayContextSent;
   const launchContext = openCodeLaunchContext(process);
   return {
-    text: [emitsRelayContext ? context.text : undefined, launchContext, text].filter(Boolean).join("\n\n"),
+    // Context is loaded through opencode.json instructions at system level. Keep first-turn
+    // acceptance bookkeeping, but never duplicate those instructions in user messages.
+    text,
     emitsRelayContext,
     emitsLaunchContext: launchContext !== undefined,
   };
@@ -126,7 +124,7 @@ export async function sendOpenCodeRelayMessage<T>(client: { sendMessage(sessionI
 }
 
 /**
- * #2534 — arm the acceptance watcher just before a context-carrying POST is dispatched. A
+ * arm the acceptance watcher just before a context-carrying POST is dispatched. A
  * prompt that emits no first-turn context has nothing to protect and never arms one, so
  * ordinary mid-session deliveries stay watcher-free.
  */
@@ -147,7 +145,7 @@ export function clearOpenCodeContextAcceptance(process: ManagedProcess): void {
 }
 
 /**
- * #2534 — consume the watcher from an observed persisted user text part. Identity is matched to
+ * consume the watcher from an observed persisted user text part. Identity is matched to
  * THIS launch incarnation on three axes, all of which must hold:
  * 1. the echo's session id equals the session the prompt was dispatched to, AND
  * 2. that session is still the process's ACTIVE session (a stale-session echo from a superseded
@@ -174,13 +172,13 @@ export function consumeOpenCodeContextAcceptance(process: ManagedProcess | undef
 }
 
 /**
- * #2534 — does the `GET /session/:id/message` body positively contain a persisted USER message
+ * does the `GET /session/:id/message` body positively contain a persisted USER message
  * whose text part equals `text` exactly AND that was created at or after `dispatchedAt`? The
  * outbound launch-carrying prompt (role/memory/gate briefing prepended to the assignment) is its
  * own fingerprint: a same-session prompt typed by the operator can never collide with it, so
  * exact equality is the identity match. But equality alone is not per-arm: every arm of send()'s
  * retry loop dispatches the SAME text into the SAME session, so an earlier arm's persisted
- * message would match a later arm's pre-acceptance failure (#2534 review round 2, MED-2) — the
+ * message would match a later arm's pre-acceptance failure (review round 2, MED-2) — the
  * real envelope's `info.time.created` (epoch ms, verified live against v1.18.21) is the
  * discriminator: only messages created at or after THIS arm's dispatch can prove THIS arm.
  * The response shape is parsed defensively — an unparsable body, or a match candidate with no
@@ -208,18 +206,18 @@ function sessionPersistsUserText(body: unknown, text: string, dispatchedAt: numb
 }
 
 /**
- * #2534 — best-effort acceptance proof for a failed completion await. The SSE door has usually
+ * best-effort acceptance proof for a failed completion await. The SSE door has usually
  * already marked by now (proof 1); if not, read the session's persisted messages once, on the
  * client's own short deadline, and consume the markers on an exact persisted-text match. Any
  * reconciliation failure is swallowed: an unreachable server cannot confirm acceptance, so the
  * markers stay false and the next attempt retries the launch text (fail-closed).
  *
- * #2534 review (MED-2) — the accepted short-circuit reads THIS dispatch arm's consumed flag,
+ * review (MED-2) — the accepted short-circuit reads THIS dispatch arm's consumed flag,
  * never the durable first-turn markers: the markers are process-scoped and survive across the
  * send() retry/re-roll loop's arms, so keying to them would make any later arm that fails
  * PRE-acceptance inherit an earlier arm's acceptance and report the assignment delivered.
  *
- * #2534 review round 2 (MED-2) — the persisted match is likewise arm-scoped: the reconciliation
+ * review round 2 (MED-2) — the persisted match is likewise arm-scoped: the reconciliation
  * runs with THIS arm's dispatch timestamp, so an earlier arm's identical persisted user message
  * (same immutable text, same session) can never prove a later arm's failed dispatch. Without a
  * pending arm there is nothing to prove — fail closed.
@@ -243,7 +241,7 @@ async function reconcileOpenCodeContextAcceptance(client: { sessionMessages?(ses
 }
 
 /**
- * #2534 — dispatch one attempt of the prepared turn, keeping first-turn marker consumption
+ * dispatch one attempt of the prepared turn, keeping first-turn marker consumption
  * keyed to PROMPT ACCEPTANCE rather than to the completion await's return. OpenCode's
  * `/message` POST is synchronous: it is ACCEPTED and its prompt persisted within moments of
  * dispatch, but the await only resolves when the whole assistant turn ends — so on a long turn