@humwick/runner 0.130.5 → 0.130.6

package/src/control-server.ts

@@ -13,22 +13,22 @@ import { bestEffortDeletePendingPermissionRequest, bestEffortListPendingPermissi
 // decision before the provider abandons the hook.
 const PERMISSION_WAIT_MS = 880_000;
 // Distinct from a human dismissal ("Dismissed/Denied from Humwick dashboard") so the
-// agent can tell "nobody answered in time" (retriable) from "the human said no" (#693).
+// agent can tell "nobody answered in time" (retriable) from "the human said no".
 function permissionTimeoutReason(view?: Pick<InteractivePrompt, "toolName" | "title">): string {
   const tool = view?.toolName?.trim() || view?.title?.replace(/^Approve\s+/i, "").trim() || "provider tool";
   return `Permission request for ${tool} timed out after ~15 minutes without a coordinator decision; the tool was denied (timeout, not a dismissal). Re-ask if you still need it.`;
 }
 const PERMISSION_STOP_REASON = "The runner restarted while this permission request was pending; the original hook is no longer connected.";
 const RESOLVED_APPROVAL_LIMIT = 1024;
-// #1173: the immediate PreToolUse response for a "questions" prompt (see the deny-then-hold
+// the immediate PreToolUse response for a "questions" prompt (see the deny-then-hold
 // branch in handlePermissionRequest below). Bridges the hand-off so the model doesn't read a
 // bare denial and re-ask — the real answer follows shortly as an injected user prompt.
 const PENDING_QUESTION_DENY_REASON =
-  "The user is answering this question directly via Agent Relay, not through this tool call — do not re-ask it. Their answer will follow as your next message; wait for it and continue from there.";
+  "The user is answering this question directly via Humwick, not through this tool call — do not re-ask it. Their answer will follow as your next message; wait for it and continue from there.";
 
 // A hook that failed in a way it could not handle itself reports here so the
-// failure is never silent (#198 item 5). Phase 1 logs it FATAL to the per-agent
-// log; Phase 2 (#196) will additionally route it through the runner outbox to the
+// failure is never silent. Phase 1 logs it FATAL to the per-agent
+// log; Phase 2 will additionally route it through the runner outbox to the
 // server.
 export interface HookFatalReport {
   hook: string;
@@ -58,7 +58,7 @@ export interface ControlServer {
 export interface ControlServerOptions {
   onStatus(status: ProviderStatusEvent): void;
   onTerminalAttachSpec?(): Promise<TerminalAttachSpec>;
-  // #2459 — the CURRENT non-secret attachment generation (derived from the provider's active
+  // the CURRENT non-secret attachment generation (derived from the provider's active
   // session id), read by the orchestrator before terminal input and on stream connect/
   // reconnect to detect a session rotation. Returns ONLY that digest — never the session id,
   // never a credential. Absent handler ⇒ endpoint reports no generation, which the
@@ -72,25 +72,25 @@ export interface ControlServerOptions {
   onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown; promptId?: string; isPreFlush?: boolean; toolName?: string; toolInput?: unknown }): Promise<{ reasoningSettled: boolean; toolUseOccurredAt?: number } | void>;
   onPermissionResolved?(input: ResolvedPermissionPrompt): Promise<void> | void;
   onPermissionAbandoned?(input: PendingPermissionRequestRecord & { reason: string; decisionReason: ProviderPermissionDecisionReason }): Promise<void> | void;
-  // #1173: a "questions" (AskUserQuestion) prompt's own PreToolUse hook is answered with `deny`
+  // a "questions" (AskUserQuestion) prompt's own PreToolUse hook is answered with `deny`
   // immediately (see the branch in handlePermissionRequest) instead of held open for the human,
   // so there is no live HTTP request left to answer once the decision resolves. This delivers
   // that resolution instead: `text` is the prompt to inject as a normal user turn.
   onAnswerInject?(input: { approvalId: string; text?: string }): Promise<void> | void;
-  // #2914: files a "questions" prompt as a durable operator decision; undefined = not filed, so the
+  // files a "questions" prompt as a durable operator decision; undefined = not filed, so the
   // question falls back to the live deny-then-hold relay above.
   onQuestionDecision?(input: OperatorDecisionFileInput): Promise<{ id: number } | undefined>;
   // A provider user-prompt hook hands over text typed directly into the session
   // so the runner can mirror it into dashboard chat.
   onUserPrompt?(input: { prompt: string; transcriptPath?: string; promptId?: string; firedAt?: number }): Promise<void>;
-  // A session-start hook checks in with its fire time, proving the hook path works (#2664).
+  // A session-start hook checks in with its fire time, proving the hook path works.
   onHookCheck?(input: { firedAt?: number }): void;
   onToolUse?(input: unknown, signal: AbortSignal): Promise<string>;
   // A provider session-boundary hook signals an imminent context reset or
   // termination so the runner can run end-of-session work before the operation.
   onSessionBoundary?(input: { reason?: string; transcriptPath?: string }): Promise<void>;
   onSessionStart?(input: { source?: string; providerSessionId?: string }): string | undefined;
-  // Phase 1 observability (#198): a hook reporting an unhandled failure. The
+  // Phase 1 observability: a hook reporting an unhandled failure. The
   // control server already logs it FATAL; this is the seam for Phase 2 to also
   // surface it to the server via the runner outbox.
   onHookFatal?(report: HookFatalReport): void;
@@ -100,7 +100,7 @@ export interface ControlServerOptions {
   instanceId?: string;
   pendingPermissionStore?: PendingPermissionStore;
   permissionPromptHandler?: ProviderPermissionPromptHandler;
-  // #3648 — the agent runs in `open` approval mode: answer every permission request at once.
+  // the agent runs in `open` approval mode: answer every permission request at once.
   autoApprovePermissions?: boolean;
   providerSourceId?: string;
   stopObligationPath?: string;
@@ -115,7 +115,7 @@ export function startControlServer(options: ControlServerOptions): ControlServer
   const pendingPermissionRequests = new Map<string, PendingPermissionWaiter>();
   // approvalIds already resolved, so a duplicate decision (e.g. bus replay after a
   // reconnect, or both the PreToolUse and PermissionRequest hooks racing one answer)
-  // is an idempotent no-op instead of a silent command failure (#693).
+  // is an idempotent no-op instead of a silent command failure.
   const resolvedApprovals = new Set<string>();
   let server!: Server<MonitorSocketData>;
   recoverStoredPermissionRequests(options);
@@ -133,7 +133,7 @@ export function startControlServer(options: ControlServerOptions): ControlServer
       if (url.pathname === "/terminal/attach-spec" && req.method === "GET") {
         if (!options.onTerminalAttachSpec) return Response.json({ error: "terminal attach is unavailable" }, { status: 404 });
         return options.onTerminalAttachSpec()
-          // #2459 round 1 (review A) — strip any credential-bearing env record from the body:
+          // round 1 (review A) — strip any credential-bearing env record from the body:
           // credentials travel ONLY by runner-staged env file (spec.envFile), so nothing
           // secret ever serializes into this HTTP response.
           .then((spec) => {
@@ -144,7 +144,7 @@ export function startControlServer(options: ControlServerOptions): ControlServer
           .catch((error) => Response.json({ error: errMessage(error) }, { status: 409 }));
       }
       if (url.pathname === "/terminal/generation" && req.method === "GET") {
-        // #2459 — deliberately returns ONLY the non-secret generation digest. No session id,
+        // deliberately returns ONLY the non-secret generation digest. No session id,
         // no password, no attach detail: this endpoint exists so the orchestrator can detect
         // staleness, and anything more would widen the secret surface for no benefit.
         if (!options.onTerminalGeneration) return Response.json({});
@@ -279,7 +279,7 @@ export function startControlServer(options: ControlServerOptions): ControlServer
       const pending = pendingPermissionRequests.get(input.approvalId);
       if (!pending) {
         // Idempotent: a duplicate decision for an already-resolved approval is a
-        // benign no-op, not a dropped answer that fails the command (#693).
+        // benign no-op, not a dropped answer that fails the command.
         return resolvedApprovals.has(input.approvalId);
       }
       clearTimeout(pending.timer);
@@ -323,14 +323,14 @@ function replyObligationSummary(obligations: ReplyObligation[]): Record<string,
     pending: true,
     count: obligations.length,
     obligation,
-    reason: `Pending Agent Relay response for message #${obligation.messageId} from ${obligation.from}${subject}. If it still needs an answer, use ${relayReplyActionText(obligation.messageId)}. If multiple delivered messages are part of one current request, answer once to the latest relevant message. If the useful response was already delivered through Relay, do not send a separate status-only confirmation.`,
+    reason: `Pending Humwick response for message #${obligation.messageId} from ${obligation.from}${subject}. If it still needs an answer, use ${relayReplyActionText(obligation.messageId)}. If multiple delivered messages are part of one current request, answer once to the latest relevant message. If the useful response was already delivered through Relay, do not send a separate status-only confirmation.`,
   };
 }
 
 function replyObligationStopDecision(obligations: ReplyObligation[]): Record<string, unknown> {
-  // #418 — never block the turn to nag for a `user` obligation: the operator already receives
+  // never block the turn to nag for a `user` obligation: the operator already receives
   // this turn via the session mirror, so an explicit /reply double-delivers. Only agent↔agent /
-  // spawner obligations (#413) gate the turn here; the mirror's replyTo-linking clears the user
+  // spawner obligations gate the turn here; the mirror's replyTo-linking clears the user
   // one. (The /reply-obligations summary endpoint is left unfiltered — the obligation IS pending
   // until the mirror lands, so observability stays accurate.)
   const enforceable = obligations.filter(obligationNagEligible);
@@ -402,12 +402,12 @@ async function handlePermissionRequest(
   const { decision } = await awaitPermissionDecision({
     options, pendingPermissionRequests, handler, approvalId, body, occurredAt, transcriptPath, toolName, toolInput,
     blockedReason: "permissionRequest",
-    recommendedAction: "Review the permission request in Agent Relay.",
+    recommendedAction: "Review the permission request in Humwick.",
   });
   return Response.json(handler.buildHookResponse(decision, body));
 }
 
-// #3648 — bypass mode does not cover every provider check (Claude's dangerous-rm check on a variable
+// bypass mode does not cover every provider check (Claude's dangerous-rm check on a variable
 // target still asks). An open agent has no one to answer, so the request is approved, not held.
 const OPEN_MODE_APPROVAL_REASON = "Auto-approved: the agent runs in open approval mode.";
 
@@ -442,7 +442,7 @@ async function fileQuestionDecision(options: ControlServerOptions, handler: Prov
 }
 
 function decisionFiledReason(id: number): string {
-  return `Agent Relay filed this as operator decision #${id}; the user answers it on the Relay dashboard. Do not re-ask it and do not wait in this turn: the answer arrives later as a Relay message ("Decision #${id} answered"). Continue other work or end your turn. Next time, file questions with relay_decision directly.`;
+  return `Humwick filed this as operator decision #${id}; the user answers it on the Relay dashboard. Do not re-ask it and do not wait in this turn: the answer arrives later as a Relay message ("Decision #${id} answered"). Continue other work or end your turn. Next time, file questions with humwick_decision directly.`;
 }
 
 function holdQuestionWithImmediateDeny(params: {
@@ -457,7 +457,7 @@ function holdQuestionWithImmediateDeny(params: {
   toolInput?: unknown;
 }): Response {
   const { options, pendingPermissionRequests, handler, approvalId, body, occurredAt, transcriptPath, toolName, toolInput } = params;
-  // #1173/#1194: a fresh "questions" prompt (the provider's AskUserQuestion) must not block
+  // a fresh "questions" prompt (the provider's AskUserQuestion) must not block
   // its own hook response while the human answers. Denying immediately makes the provider persist
   // the buffered turn plus rejected tool_result, so the pre-flush harvest below can publish the
   // reasoning before the dashboard form appears. The eventual answer is injected as a normal prompt.
@@ -468,21 +468,21 @@ function holdQuestionWithImmediateDeny(params: {
   void awaitPermissionDecision({
     options, pendingPermissionRequests, handler, approvalId, body, occurredAt, transcriptPath, toolName, toolInput,
     blockedReason: "pendingQuestion",
-    recommendedAction: "Answer the question in Agent Relay.",
+    recommendedAction: "Answer the question in Humwick.",
     suppressResolvedStatus: true,
   }).then(({ decision, view }) => decision.decision === "answer" && decision.answers && Object.keys(decision.answers).length
     ? handler.buildAnswerInjectionPrompt!(view, decision, body)
     : pendingQuestionDismissalPrompt(decision),
   ).then(
     (text) => options.onAnswerInject?.({ approvalId, text }),
-    // #2913: the inject is the only release of the runner's question hold — never skip it.
+    // the inject is the only release of the runner's question hold — never skip it.
     () => options.onAnswerInject?.({ approvalId }),
   ).catch(() => {});
   return response;
 }
 
-// Shared by both the traditional block-until-decided flow and the #1173 deny-then-hold flow:
-// pre-flushes narrative (#435/#1116), builds+persists the interactive view, publishes the
+// Shared by both the traditional block-until-decided flow and the deny-then-hold flow:
+// pre-flushes narrative, builds+persists the interactive view, publishes the
 // blocked providerState, and resolves once a decision arrives (or the wait times out). Callers
 // differ only in what happens with the resolved decision (build a hook response vs. inject an
 // answer prompt), so that part is left to them.
@@ -501,12 +501,12 @@ async function awaitPermissionDecision(params: {
   suppressResolvedStatus?: boolean;
 }): Promise<{ decision: ProviderPermissionDecisionInput; view: InteractivePrompt }> {
   const { options, pendingPermissionRequests, handler, approvalId, body, occurredAt, transcriptPath, toolName, toolInput, blockedReason, recommendedAction, suppressResolvedStatus } = params;
-  // #435/#1116: flush any un-mirrored narrative before the blocking form appears in
+  // flush any un-mirrored narrative before the blocking form appears in
   // chat. The adapter owns how to settle its capture source; the transport only
   // forwards the hook payload as an anchor and stamps the returned truth value.
   let reasoningSettled = true;
   // Defaults to the hook's own wall-clock receipt time; refined below to the transcript's own
-  // tool_use event time when the pre-flush harvest can resolve it (#1185) — the hook can receive
+  // tool_use event time when the pre-flush harvest can resolve it — the hook can receive
   // before the provider flushes/timestamps that entry, which otherwise sorts the resolved prompt
   // ahead of the narration that led up to it.
   let resolvedOccurredAt = occurredAt;
@@ -584,7 +584,7 @@ async function handleSessionTurn(req: Request, options: ControlServerOptions): P
   const promptId = isRecord(body) && typeof body.promptId === "string" && body.promptId ? body.promptId : undefined;
   // transcriptPath is the primary source, but it can be absent (known CC Stop edge case).
   // lastAssistantMessage is the fallback for exactly that — accept either; reject only when
-  // both are missing so the turn still reaches the dashboard chat (#264).
+  // both are missing so the turn still reaches the dashboard chat.
   if (!transcriptPath && lastAssistantMessage === undefined) {
     return Response.json({ ok: false, reason: "transcriptPath or lastAssistantMessage required" }, { status: 400 });
   }
@@ -599,7 +599,7 @@ async function handleSessionTurn(req: Request, options: ControlServerOptions): P
   }
 }
 
-/** `?firedAt=<epoch ms>`: when the hook ran, stamped by the hook itself (#2664). */
+/** `?firedAt=<epoch ms>`: when the hook ran, stamped by the hook itself. */
 function hookFiredAt(url: URL): { firedAt?: number } {
   const raw = url.searchParams.get("firedAt") ?? "";
   const firedAt = /^\d{1,16}$/.test(raw) ? Number(raw) : NaN;
@@ -664,7 +664,7 @@ async function handleStatus(req: Request, options: ControlServerOptions): Promis
   const isWorkKind = (item: unknown): item is "provider-turn" | "subagent" | "background-script" =>
     item === "provider-turn" || item === "subagent" || item === "background-script";
   const clear = Array.isArray(body?.clear) ? body.clear.filter(isWorkKind) : undefined;
-  // #650: optional pids the runner reconciles against process liveness so a tracked
+  // optional pids the runner reconciles against process liveness so a tracked
   // command/shell killed out-of-band clears the busy marker instead of stranding it.
   const pidsInput = Array.isArray((body as { pids?: unknown })?.pids) ? (body as { pids: unknown[] }).pids : undefined;
   const pids = pidsInput
@@ -688,7 +688,7 @@ async function handleStatus(req: Request, options: ControlServerOptions): Promis
   return Response.json({ ok: true, ...update });
 }
 
-// #286: the stop-failure hook reports a usage/rate-limit stall here. Build the
+// the stop-failure hook reports a usage/rate-limit stall here. Build the
 // provider-neutral `blocked` state (reason rate_limit) so the dashboard shows it
 // distinctly (never as idle/available) and the relay's resume sweep can lift it
 // at reset. The agent stays `idle` underneath (the turn truly ended); the runner

package/src/delivery-result.ts

@@ -8,7 +8,7 @@ export function normalizeDeliverResult(
 ): { acknowledgedIds: number[]; terminalFailureIds: number[]; awaitingConsumptionIds: number[]; providerHeldIds: number[] } {
   if (result === undefined) return { acknowledgedIds: deliverable.map((message) => message.id), terminalFailureIds: [], awaitingConsumptionIds: [], providerHeldIds: [] };
   if (Array.isArray(result)) return { acknowledgedIds: result, terminalFailureIds: [], awaitingConsumptionIds: [], providerHeldIds: [] };
-  // #2397 round 4 review (F5) — adapter.ts documents terminalFailureIds as a subset of the ids NOT
+  // round 4 review (F5) — adapter.ts documents terminalFailureIds as a subset of the ids NOT
   // in acknowledgedIds, but that's only true because every adapter today always reports both
   // together. Enforce it here too: a future adapter that reports only terminalFailureIds (omitting
   // acknowledgedIds) must not have this default silently ack its own failures.
@@ -18,7 +18,7 @@ export function normalizeDeliverResult(
     acknowledgedIds: result.acknowledgedIds ?? deliverable.filter((message) => !terminalFailureIds.includes(message.id) && !providerHeldIds.includes(message.id)).map((message) => message.id),
     providerHeldIds,
     terminalFailureIds,
-    // #2539 Phase B — accepted-but-unconsumed soft-steer ids: recorded, not settled (see settleMessageDelivery).
+    // Phase B — accepted-but-unconsumed soft-steer ids: recorded, not settled (see settleMessageDelivery).
     awaitingConsumptionIds: result.awaitingConsumptionIds ?? [],
   };
 }

package/src/effort-command.ts

@@ -3,7 +3,7 @@ import type { ManagedProcess, ProviderAdapter } from "./adapter";
 import { fireAndForget } from "./async-guard";
 import type { ProviderInputTicket } from "./provider-input-queue";
 
-/** #2950 — this process can switch effort: the adapter can switch and its launch allows it. */
+/** this process can switch effort: the adapter can switch and its launch allows it. */
 export function runnerEffortSwitch(adapter: ProviderAdapter, process: ManagedProcess | undefined): boolean {
   return Boolean(adapter.setEffort) && process?.meta?.effortSwitch === true;
 }
@@ -44,7 +44,7 @@ export function isEffortNotice(eventType: string, data: unknown): boolean {
 }
 
 /**
- * #2984 — converges the provider on Relay's desired effort version between turns. Triggered by the
+ * converges the provider on Relay's desired effort version between turns. Triggered by the
  * runner's existing edges (adoption, registration, the HTTP liveness pass, a bus notice, turn end);
  * a failed read or report leaves the version pending for the next trigger. No timers of its own.
  */

package/src/empty-turn.ts

@@ -1,6 +1,6 @@
-// #2389 — an empty provider turn is a failure, not a clean idle.
+// an empty provider turn is a failure, not a clean idle.
 //
-// Observed live (blackbox, OpenCode via OpenRouter): the spawn prompt was delivered and
+// Observed live (worker-b, OpenCode via OpenRouter): the spawn prompt was delivered and
 // persisted, the model was dispatched a real turn, and the assistant message came back
 // `finish=stop` with NO text part, NO tool part and ZERO tokens. Twice in a row. The runner logged
 // `turn ended via provider idle` and left the agent reporting healthy and idle, so the spawning
@@ -68,6 +68,7 @@ export interface EmptyTurnVerdict {
   empty: boolean;
   /** How many empty turns in a row, counting this one. */
   consecutiveEmpty: number;
+  inputOfferedAt?: number;
   turnAgeMs: number;
   /** Deliver the nudge now. At most once per user-originated input. */
   nudge: boolean;
@@ -240,7 +241,7 @@ export class EmptyTurnLedger {
    *
    * KNOWN RESIDUAL, argued not fixed: this drops an obligation armed by input that arrived DURING
    * the interrupted/restarted turn, which is a discharge by something other than the input's own
-   * turn — the shape every blocking finding on #2389 has had. It is kept because a post-restart
+   * turn — the shape every blocking finding on has had. It is kept because a post-restart
    * ledger cannot honestly judge a pre-restart obligation, and because the outcome is not silent:
    * the interrupt command and forceClearProviderTurn both route `agent.turn_interrupted` to the
    * spawn parent. The auto-restart path is weaker — `restartProvider` emits a
@@ -295,7 +296,7 @@ export class EmptyTurnLedger {
    * seams on purpose: a turn that only ran tools, or one whose narration is suppressed by
    * `reasoningCapture: false`, must never be misread as empty.
    *
-   * Claude's transcript tail runs whatever `reasoningCapture` says (#3411), so its tool and
+   * Claude's transcript tail runs whatever `reasoningCapture` says, so its tool and
    * narration steps count here even when the mirror keeps them out of chat.
    */
   noteOutput(turnId?: string, occurredAt?: number, isWork = false): EmptyTurnOutput {
@@ -351,7 +352,7 @@ export class EmptyTurnLedger {
     this.turn = undefined;
     const turnAgeMs = Math.max(0, turn.endedAt - turn.startedAt);
     if (turn.outputs > 0) {
-      // A turn already in flight can consume coalesced input without starting a new turn (#2691).
+      // A turn already in flight can consume coalesced input without starting a new turn.
       if (this.answers(turn)) {
         this.dischargeOutput();
       }
@@ -395,7 +396,7 @@ export class EmptyTurnLedger {
    * still the reason the input has not been picked up — provider input is buffered behind the live
    * turn — so escalating on it would page the parent about an agent that is visibly working. This
    * defers; it never discharges. A turn that is wedged forever is the provider-turn watchdog's
-   * (#1980) to report, not this one's.
+   * to report, not this one's.
    */
   escalateOnTimeout(): "escalate" | "retry" | "done" {
     if (this.undischargedInputAt === undefined || this.escalated) return "done";
@@ -404,7 +405,7 @@ export class EmptyTurnLedger {
     return "escalate";
   }
 
-  /** In-flight work needs correlated consumption, or stamped tool/response evidence (#2691). */
+  /** In-flight work needs correlated consumption, or stamped tool/response evidence. */
   private answers(turn: TurnRecord): boolean {
     const evidence = this.evidence;
     const inputAt = evidence?.offeredAt;
@@ -431,6 +432,10 @@ export class EmptyTurnLedger {
     this.ladderExempt = false;
   }
 
+  inputOfferedAt(): number | undefined {
+    return this.evidence?.offeredAt;
+  }
+
   /** Whether input is still outstanding — nothing has produced output since it was delivered. */
   hasUndischargedInput(): boolean {
     return this.undischargedInputAt !== undefined;
@@ -454,19 +459,19 @@ export class EmptyTurnLedger {
  * original spawn prompt the moment a human typed "hello" at it hours later. This says only "your
  * last turn produced nothing, go look at what you already have".
  *
- * Prefixed with `[agent-relay` so `isRunnerInjectedPrompt` suppresses its prompt echo and it is
+ * Prefixed with `[humwick` so `isRunnerInjectedPrompt` suppresses its prompt echo and it is
  * never mirrored into chat as if a human had typed it.
  */
 export const EMPTY_TURN_NUDGE =
-  "[agent-relay] Your previous turn ended without producing any output — no text, no tool calls. " +
+  "[humwick] Your previous turn ended without producing any output — no text, no tool calls. " +
   "That was a provider-side empty completion, not an instruction to stop. Nothing was lost: the " +
   "work you were given is already in this session's history above. Re-read it and carry on now; do " +
   "not wait for it to be re-sent.";
 
 /**
- * #2389 — the announcement for a turn that ended clean and produced nothing.
+ * the announcement for a turn that ended clean and produced nothing.
  *
- * Emitted (not silently logged) for the same reason #1621 emits its reconcile: `idle` is exactly
+ * Emitted (not silently logged) for the same reason emits its reconcile: `idle` is exactly
  * the signal a coordinator uses to decide the agent is fine, so an empty turn that only ever
  * reached a log file leaves the coordinator reading health it does not have. Pure builder so the
  * payload the parent's notice derives from is unit-testable in isolation.
@@ -474,6 +479,7 @@ export const EMPTY_TURN_NUDGE =
 export function emptyTurnTimelineEvent(input: {
   turnId: string;
   consecutiveEmpty: number;
+  inputOfferedAt?: number;
   turnAgeMs: number;
   nudged: boolean;
   escalated: boolean;
@@ -510,6 +516,7 @@ export function emptyTurnTimelineEvent(input: {
     metadata: {
       eventType: PROVIDER_TURN_EMPTY_TIMELINE_STATUS,
       emptyKind: stalled ? "input-stalled" : "empty-turn",
+      inputOfferedAt: input.inputOfferedAt,
       turnId: input.turnId,
       consecutiveEmptyTurns: input.consecutiveEmpty,
       turnAgeMs: input.turnAgeMs,
@@ -596,7 +603,7 @@ export class EmptyTurnWatch {
   }
 
   /**
-   * #2389 — arming ALSO starts the timed backstop, not just the strike ladder. Without this the
+   * arming ALSO starts the timed backstop, not just the strike ladder. Without this the
    * ladder is the only detector, and it can only ever fire on a turn that actually ran: an input
    * that provokes no turn at all, and every watch-only continuation, would go undetected forever.
    */
@@ -653,9 +660,9 @@ export class EmptyTurnWatch {
 
   /**
    * Evidence the model produced something. A `prompt` event is the user's own text echoing back.
-   * `diagnostic: true` (#2397 round 3) is an adapter narrating its OWN retry/failure mechanics —
+   * `diagnostic: true` is an adapter narrating its OWN retry/failure mechanics —
    * e.g. OpenCode's "retrying in Ns…" hold — never the model's own output; crediting it would let a
-   * retry storm that ends in terminal failure cancel the #2389 escalation that wakes the spawn
+   * retry storm that ends in terminal failure cancel the escalation that wakes the spawn
    * parent for a turn that never actually produced anything.
    */
   noteOutput(event?: { type?: string; body?: string; turnId?: string; occurredAt?: number; diagnostic?: boolean }): void {
@@ -788,6 +795,7 @@ export class EmptyTurnWatch {
       this.ports.log(`no output ${Math.round(deadlineMs / 1000)}s after ${nudged ? "the empty-turn nudge" : "input was delivered"} — escalating to spawn parent`);
       this.ports.publishTimeline(emptyTurnTimelineEvent({
         turnId,
+        inputOfferedAt: this.ledger.inputOfferedAt(),
         consecutiveEmpty: this.ledger.consecutiveEmptyTurns(),
         turnAgeMs: 0,
         nudged,

package/src/free-port.ts

@@ -1,4 +1,4 @@
-// #2719 — the ONE free-loopback-port allocator for provider launches.
+// the ONE free-loopback-port allocator for provider launches.
 //
 // A provider serve port must never be derived from another port: the runner control port
 // comes from the OS (`bind :0`), and `controlPort + 1000` overflows 65535 whenever the OS

package/src/gate-run-config.ts

@@ -1,8 +1,8 @@
-// #2461 — resolve the repo's CONFIGURED gate commands for a runner session's cwd.
+// resolve the repo's CONFIGURED gate commands for a runner session's cwd.
 //
 // The backstop sweep used to classify a gate run by argv shape alone, which is why a foreign repo's
-// own runner (`pnpm tier:run static fast` — observed live on wbox) was invisible to it. Relay
-// already knows every repo's real gate commands from `.agent-relay/land-gates.json`; this is the
+// own runner (`pnpm tier:run static fast` — observed live on worker-a) was invisible to it. Relay
+// already knows every repo's real gate commands from `.humwick/land-gates.json`; this is the
 // runner-side reader for them. Mirrors orchestrator/src/gate-run-guard.ts's `gateCommandsForCwd` —
 // the two workspaces cannot import each other, and the shared piece that matters (the matching
 // rule) lives in sdk/src/gate-run-classify.ts, so only this four-line projection is repeated.

package/src/host-asset-plan.ts

@@ -1,12 +1,11 @@
-import { CLAUDE_OWNED_PLUGIN_IDS, selectClaudePluginDirs } from "./provider-integration";
-import { runnerMcpGeneration } from "./relay-mcp";
-// #3387 — the host half of a launch plan. Every runner-managed profiled launch runs in a Relay-owned
+import { canonicalIntegrationAssetName, CLAUDE_OWNED_PLUGIN_IDS, selectClaudePluginDirs } from "./provider-integration";
+// the host half of a launch plan. Every runner-managed profiled launch runs in a Relay-owned
 // provider home; this module decides, per host asset class, what that home receives from the real
 // host home, and materializes exactly that (removing what an opted-out class left behind on reuse).
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { effectiveHostSources, isRecord, type HostSourceClass, type HostSourceSelection, type ToolGeneration } from "@humwick/sdk";
+import { effectiveHostSources, isRecord, type HostSourceClass, type HostSourceSelection } from "@humwick/sdk";
 import type { RunnerSpawnConfig } from "./adapter";
 
 export type HostSourceDisposition = "applied" | "selected-empty" | "disabled" | "unsupported";
@@ -90,7 +89,7 @@ export interface ClaudeHostPluginRegistry {
  * Project), their host enablement (a disabled plugin stays disabled) and their marketplaces.
  * Payload paths stay absolute; only the registry files are private copies.
  */
-export function selectClaudeHostPlugins(sourceHome: string, hostSettings: Record<string, unknown> | undefined, bridge?: { generation: ToolGeneration; ownedProvided: boolean }): ClaudeHostPluginRegistry {
+export function selectClaudeHostPlugins(sourceHome: string, hostSettings: Record<string, unknown> | undefined, bridge?: { ownedProvided: boolean }): ClaudeHostPluginRegistry {
   const installedPath = join(sourceHome, "plugins", "installed_plugins.json");
   const knownPath = join(sourceHome, "plugins", "known_marketplaces.json");
   const installed = readSelectedJson("plugins", installedPath);
@@ -108,7 +107,7 @@ export function selectClaudeHostPlugins(sourceHome: string, hostSettings: Record
     }
   }
   if (bridge) {
-    const preferred = bridge.generation === "humwick" ? CLAUDE_OWNED_PLUGIN_IDS[1]! : CLAUDE_OWNED_PLUGIN_IDS[0]!;
+    const preferred = CLAUDE_OWNED_PLUGIN_IDS[1]!;
     const candidates = [preferred, ...CLAUDE_OWNED_PLUGIN_IDS].filter(id => keptPlugins[id]);
     const selected = bridge.ownedProvided ? undefined : candidates.find(id => enabled[id] === true) ?? candidates[0];
     for (const id of CLAUDE_OWNED_PLUGIN_IDS) if (id !== selected) delete keptPlugins[id];
@@ -305,8 +304,8 @@ export function claudeHostPlan(config: RunnerSpawnConfig, sourceHome: string, pr
   const selection = hostSourcesFor(config);
   const settingsClass: HostSourceClass | undefined = selection.plugins ? "plugins" : selection.settings ? "settings" : undefined;
   const hostSettings = settingsClass ? claudeHostSettingsSnapshot(config, sourceHome, settingsClass) : undefined;
-  const ownedProvided = !config.agentProfile || Boolean(config.agentProfile.provisioning?.plugins.some(plugin => plugin.name === "agent-relay-claude-plugin"));
-  const registry = selection.plugins ? selectClaudeHostPlugins(sourceHome, hostSettings, { generation: runnerMcpGeneration(config.env), ownedProvided }) : undefined;
+  const ownedProvided = !config.agentProfile || Boolean(config.agentProfile.provisioning?.plugins.some(plugin => canonicalIntegrationAssetName(plugin.name) === "humwick-claude-plugin"));
+  const registry = selection.plugins ? selectClaudeHostPlugins(sourceHome, hostSettings, { ownedProvided }) : undefined;
   const files = [
     ...(registry?.installed ? [{ target: join("plugins", "installed_plugins.json"), content: JSON.stringify(registry.installed, null, 2) }] : []),
     ...(registry?.known ? [{ target: join("plugins", "known_marketplaces.json"), content: JSON.stringify(registry.known, null, 2) }] : []),
@@ -317,7 +316,7 @@ export function claudeHostPlan(config: RunnerSpawnConfig, sourceHome: string, pr
     files,
     settings: { ...(selection.settings ? claudeHostSettingsFor(hostSettings, "settings") : {}), ...(registry?.settings ?? {}) },
     pluginIds: registry?.ids ?? [],
-    pluginDirs: selection.plugins ? selectClaudePluginDirs(providerConfig.pluginDirs, runnerMcpGeneration(config.env), ownedProvided || Boolean(registry?.ids.some(id => CLAUDE_OWNED_PLUGIN_IDS.includes(id) && (registry.settings.enabledPlugins as Record<string, unknown> | undefined)?.[id] === true))) : [],
+    pluginDirs: selection.plugins ? selectClaudePluginDirs(providerConfig.pluginDirs, ownedProvided || Boolean(registry?.ids.some(id => CLAUDE_OWNED_PLUGIN_IDS.includes(id) && (registry.settings.enabledPlugins as Record<string, unknown> | undefined)?.[id] === true))) : [],
   };
 }
 
@@ -366,7 +365,7 @@ export interface CodexHostPlan {
   settings: Record<string, unknown>;
 }
 
-export function codexHostPlan(config: RunnerSpawnConfig, sourceHome: string, userHome = homedir()): CodexHostPlan {
+export function codexHostPlan(config: RunnerSpawnConfig, sourceHome: string, userHome = process.env.HOME || homedir()): CodexHostPlan {
   const selection = hostSourcesFor(config);
   const ambient = codexAmbientSkillRoots(userHome).flatMap(skillDirsUnder);
   let settings: Record<string, unknown> = {};
@@ -404,15 +403,23 @@ export function codexHostReport(plan: CodexHostPlan, applied: { mcp: boolean; ho
   };
 }
 
-const CODEX_SETTINGS_BEGIN = "# >>> agent-relay host settings (generated; edits are replaced)";
-const CODEX_SETTINGS_END = "# <<< agent-relay host settings";
+const CODEX_SETTINGS_BEGIN = "# >>> humwick host settings (generated; edits are replaced)";
+const CODEX_SETTINGS_END = "# <<< humwick host settings";
 
 function withoutCodexSettingsRegion(text: string): string {
-  const begin = text.indexOf(CODEX_SETTINGS_BEGIN);
-  if (begin < 0) return text;
-  const end = text.indexOf(CODEX_SETTINGS_END, begin);
-  if (end < 0) return text;
-  return (text.slice(0, begin) + text.slice(end + CODEX_SETTINGS_END.length)).replace(/^\n+/, "");
+  // recorded homes can retain the previous generated region until reuse.
+  for (const [beginMarker, endMarker] of [
+    [CODEX_SETTINGS_BEGIN, CODEX_SETTINGS_END],
+    ["# >>> agent-relay host settings (generated; edits are replaced)", "# <<< agent-relay host settings"],
+  ] as const) {
+    let begin: number;
+    while ((begin = text.indexOf(beginMarker)) >= 0) {
+      const end = text.indexOf(endMarker, begin);
+      if (end < 0) break;
+      text = (text.slice(0, begin) + text.slice(end + endMarker.length)).replace(/^\n+/, "");
+    }
+  }
+  return text;
 }
 
 /**

package/src/host-claude-config-worker.ts

@@ -12,12 +12,12 @@ const task: OffloadWorkerTask<{ path: string; kind?: "config" | "settings" }, Re
     try {
       parsed = JSON.parse(await file.text());
     } catch (error) {
-      // #3387 — a selected host class must fail loudly on a malformed settings.json, never launch as if empty.
+      // a selected host class must fail loudly on a malformed settings.json, never launch as if empty.
       if (kind === "settings") return { [READ_ERROR]: (error as Error).message };
       throw error;
     }
     if (!isRecord(parsed)) return kind === "settings" ? { [READ_ERROR]: "not a JSON object" } : undefined;
-    // settings.json is small; the launch partitions it per host class (#3387).
+    // settings.json is small; the launch partitions it per host class.
     if (kind === "settings") return parsed;
     // Keep only the three host-level launch inputs. Returning Claude's entire history/session
     // object would transfer tens of MB back to the runner and recreate the same event-loop stall.

package/src/host-sources.ts

@@ -6,8 +6,8 @@ import { claudeHostSettingsSnapshot } from "./host-asset-plan";
 import { providerSourceHome } from "./profile-home";
 
 /** Host Claude hooks are stored in the host settings.json, not .claude.json; a host that set
- * `disableAllHooks` carries none, so a managed home never re-enables them (#3387).
- * #2513 — keyed by provider id so a dedicatedHome claude-family provider (claude-b)
+ * `disableAllHooks` carries none, so a managed home never re-enables them.
+ * keyed by provider id so a dedicatedHome claude-family provider (claude-b)
  * reads ITS OWN source home's settings, never ~/.claude's. */
 export function hostClaudeHooks(config: Pick<RunnerSpawnConfig, "hostClaudeSettings">, provider: string = "claude"): ProvisioningHookSet {
   const settings = claudeHostSettingsSnapshot(config, providerSourceHome(provider), "hooks");