@humwick/runner 0.130.4 → 0.130.6

package/src/agent-runner/registration.ts

@@ -13,7 +13,7 @@ import { logger } from "../logger";
 import { providerTerminalSession, providerTerminalSocket } from "../process-meta";
 import type { RunnerLaunchOptions } from "./runner-context";
 
-// #2095 test rig — fallback window used to derive tokensUsed for the forced synthetic context when
+// test rig — fallback window used to derive tokensUsed for the forced synthetic context when
 // neither the process context nor the probe reports a tokensMax yet. The absolute value is immaterial
 // (only utilization drives the server thresholds); 200k matches the common Claude window.
 const FORCED_CONTEXT_DEFAULT_WINDOW_TOKENS = 200_000;
@@ -30,7 +30,7 @@ interface RegistrationDeps {
 }
 
 export class Registration {
-  // #2095 self-compact e2e test rig — the one-shot forced-context latch. `forceContextPct` is the
+  // self-compact e2e test rig — the one-shot forced-context latch. `forceContextPct` is the
   // synthetic utilization to report (undefined = feature off, production behavior unchanged);
   // `forceContextArmed` is disarmed after the FIRST forced compaction/clear command this runner
   // handles, so exactly one trigger→compact→resume cycle runs (no repeat-compaction loop).
@@ -40,13 +40,13 @@ export class Registration {
   constructor(private readonly deps: RegistrationDeps) {}
 
   disarmForcedContext(type: string): void {
-    // #2095 test rig — one-shot latch: the FIRST forced compaction/clear this runner handles disarms
+    // test rig — one-shot latch: the FIRST forced compaction/clear this runner handles disarms
     // the synthetic forced context, so the next heartbeat reports the real (post-clear, low)
     // utilization and no second cycle is triggered. Equivalent to "once lastCompactedAt advances".
-    // No-op unless AGENT_RELAY_FORCE_CONTEXT_PCT armed the latch, so production is untouched.
+    // No-op unless HUMWICK_FORCE_CONTEXT_PCT armed the latch, so production is untouched.
     if (this.forceContextArmed && (type === "agent.compact" || type === "agent.clearContext")) {
       this.forceContextArmed = false;
-      this.deps.sessionLog("AGENT_RELAY_FORCE_CONTEXT_PCT one-shot latch disarmed by forced compaction/clear command");
+      this.deps.sessionLog("HUMWICK_FORCE_CONTEXT_PCT one-shot latch disarmed by forced compaction/clear command");
       // Flush a heartbeat NOW so the server's stored context drops to the real (sub-threshold) value
       // immediately. Without this, the ~30s heartbeat cadence lets the stale forced utilization
       // survive several 10s lifecycle ticks and fire a SECOND forced compaction — breaking the strict
@@ -55,12 +55,12 @@ export class Registration {
     }
   }
 
-  // #2095 self-compact e2e test rig — synthesize a ContextState at the forced utilization while the
+  // self-compact e2e test rig — synthesize a ContextState at the forced utilization while the
   // one-shot latch is armed. lifecycleState is pinned to "working" (a "compacting"/"hibernating"
   // state makes the server's handleContextPressure early-return, so the trigger would never fire),
   // and source/confidence marked estimate/estimated so the origin of the synthetic value is honest.
   // Everything downstream (advisory, forced clear-inject, clear-commit barrier, resume) is the REAL
-  // path — only the reported utilization is fabricated. No-op unless AGENT_RELAY_FORCE_CONTEXT_PCT set.
+  // path — only the reported utilization is fabricated. No-op unless HUMWICK_FORCE_CONTEXT_PCT set.
   applyForcedContext(context: ContextState | undefined): ContextState | undefined {
     if (!this.forceContextArmed || this.forceContextPct === undefined) return context;
     const pct = this.forceContextPct;
@@ -147,7 +147,7 @@ export function runnerIdentityMeta(options: RunnerLaunchOptions, snapshot: Ident
     model: options.model ?? null,
     ...(isOpenAiApiModel(options.provider, options.model) ? { apiAuthMode: "apiKey", apiBackend: "openai", apiBudgetId: "openai-api", billing: "api" } : {}),
     effort: options.effort ?? null,
-    // #557 — project the same assembled launch; the pure assembler ignores env/controlPort.
+    // project the same assembled launch; the pure assembler ignores env/controlPort.
     agentProfile: options.agentProfile ? appliedAgentProfileMetadata(options.provider, options.agentProfile, { ...options, ...options.launchConfig, agentId: snapshot.agentId, env: {}, controlPort: 0 } as RunnerSpawnConfig, options.providerConfig) : null,
     ...identity,
     runnerManaged: true,

package/src/agent-runner/runner-context.ts

@@ -1,6 +1,3 @@
-import { resolveEnvLayers, selectProviderConfigEnv } from "@humwick/sdk/child-env";
-import { runnerMcpGeneration } from "../relay-mcp";
-import { hostSourcesFor } from "../host-asset-plan";
 import type { AgentLifecycle, AgentProfile, LaunchMode, ProjectToolchain, WorkspaceMetadata } from "@humwick/sdk";
 import { errMessage, HumwickBusClient, HumwickHttpClient, type BusClientOptions, type HttpClientOptions } from "@humwick/sdk";
 import type { ProviderAdapter, ProviderConfig, RunnerSpawnConfig } from "../adapter";
@@ -13,9 +10,9 @@ export interface RunnerOptions {
   provider: string;
   model?: string;
   effort?: string;
-  /** #2595 — effective-catalog window from the spawn payload; threaded into the adapter config. */
+  /** effective-catalog window from the spawn payload; threaded into the adapter config. */
   contextWindowTokens?: number;
-  /** #2599 — the full server-resolved model record (protocol ≥ 2); threaded into the adapter config. */
+  /** the full server-resolved model record (protocol ≥ 2); threaded into the adapter config. */
   modelRecord?: import("@humwick/sdk/provider-catalog").ResolvedModelRecord;
   runnerId: string;
   instanceId: string;
@@ -40,7 +37,7 @@ export interface RunnerOptions {
   tags: string[];
   capabilities: string[];
   providerArgs: string[];
-  /** #2773 — the interactive|headless driver this process was launched with. */
+  /** the interactive|headless driver this process was launched with. */
   launchMode?: LaunchMode;
   toolchain?: ProjectToolchain;
   policyName?: string;
@@ -54,7 +51,7 @@ export interface RunnerOptions {
   /** Provider-owned snapshot loaded before registration for truthful synchronous projection. */
   launchConfig?: Pick<RunnerSpawnConfig, "hostClaudeConfig" | "hostClaudeSettings">;
   adapter: ProviderAdapter;
-  // #2443 — `reason`, when present, is a human-readable diagnosis of a terminal provider
+  // `reason`, when present, is a human-readable diagnosis of a terminal provider
   // failure (e.g. "model-unavailable: APIError 404 ..."), passed through so the caller can print
   // it before the process actually exits — see handleAdapterStatusChange's call site.
   onProviderExit?: (code: number | null, reason?: string) => void;
@@ -73,7 +70,6 @@ interface RunnerContextDeps {
 export class RunnerContext {
   readonly options: RunnerLaunchOptions;
   readonly agentId: string;
-  readonly mcpToolGeneration: ReturnType<typeof runnerMcpGeneration>;
   http!: HumwickHttpClient;
   bus!: HumwickBusClient;
   private readonly sessionDebugVerbose = sessionDebugEnabled();
@@ -81,7 +77,6 @@ export class RunnerContext {
   constructor(options: RunnerOptions, private readonly deps: RunnerContextDeps) {
     const { token, tokenJti, tokenProfileId, tokenExpiresAt, ...launch } = options;
     this.options = Object.freeze(launch);
-    this.mcpToolGeneration = runnerMcpGeneration(resolveEnvLayers([process.env, selectProviderConfigEnv(options.providerConfig.env, hostSourcesFor(options).settings)]));
     this.agentId = options.agentId ?? options.runnerId;
   }
 
@@ -96,7 +91,7 @@ export class RunnerContext {
 
   initializeHttp(token: string | undefined): void {
     // Enrolled over registration only; never part of launch options or provider config.
-    this.http = (this.options.ports?.http ?? ((opts) => new HumwickHttpClient(opts)))({ baseUrl: this.options.relayUrl, token });
+    this.http = (this.options.ports?.http ?? ((opts) => new HumwickHttpClient(opts)))({ baseUrl: this.options.relayUrl, token, clientKind: "runner" });
   }
 
   initializeBus(options: BusClientOptions): void {
@@ -121,14 +116,14 @@ export class RunnerContext {
     this.deps.publishStatus();
   }
 
-  // (#1617) — the reporting half of a guarded fire-and-forget call. Bun exits(1) on an unhandled
+  // the reporting half of a guarded fire-and-forget call. Bun exits(1) on an unhandled
   // rejection and the runner installs no `unhandledRejection` handler, so any `void this.foo()`
-  // whose target can reject takes the whole agent down — and nothing respawns it (#1618).
+  // whose target can reject takes the whole agent down — and nothing respawns it.
   //
   // Deliberately NOT a fire-and-forget wrapper: the `.catch` still has to be written out at every
   // call site, so adding one stays a visible decision rather than something a helper hides. All
   // this fixes is the SHAPE of the report — the same logger.error + publishRunnerTimelineEvent
-  // pair attemptInitialPromptDelivery and the #1614 obligation re-injection already use, so a
+  // pair attemptInitialPromptDelivery and the obligation re-injection already use, so a
   // background operation that dies is loud on the agent's own timeline instead of vanishing.
   reportBackgroundRejection(scope: string, status: string, title: string, error: unknown): void {
     const body = errMessage(error);
@@ -151,7 +146,7 @@ export class RunnerContext {
   }
 
   // Verbose, high-frequency lines (per-probe, per-emit) — surfaced only at log
-  // level "debug" (AGENT_RELAY_LOG_LEVEL=debug, or flip live via /log-level).
+  // level "debug" (HUMWICK_LOG_LEVEL=debug, or flip live via /log-level).
   sessionDebug(message: string): void {
     logger.debug("mirror", message);
   }

package/src/agent-runner/session-mirror.ts

@@ -28,17 +28,17 @@ interface SessionMirrorDeps {
 const SESSION_MIRROR_BATCH_MAX = 100;
 
 export class SessionMirror {
-  // #332: a fast-lane outbox for display-only session-mirror trace events. Routing them through
+  // a fast-lane outbox for display-only session-mirror trace events. Routing them through
   // their own FIFO queue stops one transient trace failure from head-of-line blocking real-message
   // delivery (and vice versa); its backoff is capped low since a stale live-mirror frame is cheap.
   private readonly sessionOutbox: Outbox;
   /** In-flight asynchronous turn captures — the settle waits these out before judging a turn empty. */
   private turnCapturesInFlight = 0;
   private sessionBatchSeq = 0;
-  // #1512: mtime-keyed cache of the last transcript-derived context usage, so the
+  // mtime-keyed cache of the last transcript-derived context usage, so the
   // heartbeat's fallback parse doesn't re-read a large transcript that hasn't changed.
   private transcriptContextCache?: TranscriptContextCache;
-  // #1235 — true while a monitorless (hookless) provider turn is being mirrored natively:
+  // true while a monitorless (hookless) provider turn is being mirrored natively:
   // the adapter supplied a transcript path on the provider-turn busy edge, so the runner
   // drives the reasoning tail itself (start on busy, final-capture on idle) instead of via
   // Stop/UserPromptSubmit hooks the lean/isolated worker never installs.
@@ -49,11 +49,11 @@ export class SessionMirror {
       agentId: `${this.deps.agentId}-session`,
       dir: this.deps.outboxDir,
       send: (record) => this.deliverOutboxEvent(record),
-      // Ephemeral trace frames: cap the per-row stall low. #2433 — transient (connect-class /
+      // Ephemeral trace frames: cap the per-row stall low. Transient (connect-class /
       // 5xx / 429) failures never burn this budget; it now only bounds unknown-class failures.
       maxBackoffMs: 5_000,
       maxAttempts: 12,
-      // #2433 — a poisoned session row is REAL loss (report-up chat rides this queue), so
+      // a poisoned session row is REAL loss (report-up chat rides this queue), so
       // surface it in-session via the mirror-drop notice seam instead of only a FATAL host log.
       onPoison: (record, reason) => emitSessionPoisonNotice({ record, http: this.deps.http }, reason),
     });
@@ -82,10 +82,10 @@ export class SessionMirror {
   // the dashboard can render the live provider session faithfully. Display-only:
   // session messages are never delivered back into a provider.
   publishSessionEvent(input: { from: string; to: string; body: string; session: MessageSessionMeta; replyTo?: number; occurredAt?: number }): void {
-    // Durable, ordered, timestamped (#196/#1115): the actual POST happens in
+    // Durable, ordered, timestamped: the actual POST happens in
     // deliverOutboxEvent, retried until it lands. An explicit occurredAt preserves the
     // provider-native event time; otherwise the outbox stamps enqueue time. Routed through
-    // the fast-lane sessionOutbox (#332) so a transient trace failure can't head-of-line
+    // the fast-lane sessionOutbox so a transient trace failure can't head-of-line
     // block real messages.
     // A stepId-bearing step (tool running to completed, streamed reasoning/response) uses a
     // STABLE idempotency key so the server upserts the row in place instead of appending a dup.
@@ -221,7 +221,7 @@ export class SessionMirror {
     this.deps.adapter.stopSessionTrace?.();
   }
 
-  // #1235 — start the transcript reasoning tail for a hookless (monitorless) turn. Reuses the
+  // start the transcript reasoning tail for a hookless (monitorless) turn. Reuses the
   // exact adapter capture path the UserPromptSubmit hook drives for hooked agents; only the
   // trigger differs (native turn-start vs hook). A missing/old transcript makes the tail a
   // graceful no-op (poll finds nothing), so this can never crash a turn.
@@ -234,11 +234,11 @@ export class SessionMirror {
     }
   }
 
-  // #1235 — capture the final assistant response for a hookless turn (the Stop hook's job for
+  // capture the final assistant response for a hookless turn (the Stop hook's job for
   // hooked agents), then tear down the tail. captureSessionTurn drains the tail, reads the
   // closing turn text from the transcript, and emits the final `response` session event.
   async finishNativeSessionCapture(transcriptPath: string | undefined, ctx: ProviderSessionTurnContext): Promise<void> {
-    // #2389 — this publishes the closing `response` event AFTER the idle edge; the empty-turn
+    // this publishes the closing `response` event AFTER the idle edge; the empty-turn
     // settle must not judge the turn until it has finished.
     this.turnCapturesInFlight += 1;
     try {
@@ -253,14 +253,14 @@ export class SessionMirror {
     }
   }
 
-  // #2491 — the ONE terminal-settle seam for both capture paths: a monitorless (native) turn
+  // the ONE terminal-settle seam for both capture paths: a monitorless (native) turn
   // discovers its transcript on the provider-turn busy/idle edge; a hooked turn (Stop/
   // UserPromptSubmit) discovers it via publishSessionTurn/handleUserPrompt. Both write the
   // same `lastTranscriptPath`, so gating on that path alone (previously also required
   // `nativeSessionCaptureSeen`, set ONLY by the native busy/idle edge) is what makes this
   // fire for hooked agents too — without it every hooked turn's one-shot Stop-hook capture
   // pass raced Claude's own JSONL flush with nothing to settle it.
-  // #2484 round 2 review (MED-1) — the transcript-presence bail used to live HERE, so an
+  // round 2 review (MED-1) — the transcript-presence bail used to live HERE, so an
   // adapter with no transcript file to tail (OpenCode's capture is event-sourced off the
   // message.updated SSE door, not a JSONL tail) silently never reached its
   // `captureFinalTokenUsage` hook on any of this seam's three call sites (stop(),

package/src/agent-runner/task-claims.ts

@@ -26,7 +26,7 @@ interface TaskClaimsDeps {
 export class TaskClaims {
   private claimRenewTimer?: Timer;
   private readonly activeTaskClaims = new Map<number, ActiveTaskClaim>();
-  // #2619 — claimed Task messages whose provider-turn idle arrived while their own batch was still
+  // claimed Task messages whose provider-turn idle arrived while their own batch was still
   // delivering; completed at settle only if the provider accepted them (see completeObservedTaskClaims).
   private readonly completionDeferredTaskClaims = new Set<number>();
 
@@ -73,7 +73,7 @@ export class TaskClaims {
       if (claim.completionQueued) return false;
       if (acceptedIds) return acceptedIds.has(claim.messageId) && this.completionDeferredTaskClaims.delete(claim.messageId);
       if (!claim.observedProviderBusy) return false;
-      // #2619 — a claim still inside its own delivery batch: an idle here may belong to a SIBLING
+      // a claim still inside its own delivery batch: an idle here may belong to a SIBLING
       // message's turn, and this one may yet be refused. Whether it was accepted is only known at
       // settle (settleMessageDelivery), so defer instead of marking its Task done now.
       if (this.deps.isDrainingMessage(claim.messageId)) {

package/src/agent-runner/token-usage-coverage.ts

@@ -1,4 +1,4 @@
-// #3351 — the runner's view of provider usage it has observed but Relay has not stored yet.
+// the runner's view of provider usage it has observed but Relay has not stored yet.
 // Every adapter reports through this one seam, so a report that is in flight, or that failed
 // and was not yet replayed under the same dedupe key, is published as unreported spend
 // instead of looking like confirmed zero usage.

package/src/agent-runner/turn-report.ts

@@ -52,7 +52,7 @@ interface TurnReportDeps {
   sessionDebug(message: string): void;
 }
 
-// Bounded window to deliver the durable outbox before an exit-bound teardown (#183).
+// Bounded window to deliver the durable outbox before an exit-bound teardown.
 const OUTBOX_FLUSH_TIMEOUT_MS = 3_000;
 
 export class TurnReport {
@@ -79,8 +79,8 @@ export class TurnReport {
   async publishProviderResponse(event: ProviderSessionEvent, body: string, turnId: string | undefined): Promise<void> {
     // Dashboard prompt injection is already answered by this captured App Server
     // response. User obligations still belong to the session mirror; spawner
-    // obligations (#413) route to the spawn-parent with replyTo to clear the debt.
-    // #1083: a turn-final capture is ALWAYS mirrored, regardless of reply route — an
+    // obligations route to the spawn-parent with replyTo to clear the debt.
+    // a turn-final capture is ALWAYS mirrored, regardless of reply route — an
     // autonomous provider turn with no pending prompt and no eligible obligation used to
     // hit `if (!route) return` here and vanish before ever reaching publishCapturedResponse,
     // so it was neither shown in the dashboard nor eligible for report-up. The route only
@@ -89,16 +89,16 @@ export class TurnReport {
     // response (enqueueCapturedResponseReport's own `!replyTo` gate then correctly skips
     // report-up — there's no spawner obligation to report up against).
     let replyToMessageId: number | undefined, replyTarget = "user";
-    // #2335 — the route resolved to a channel-egress bridge; publishCapturedResponse re-addresses
+    // the route resolved to a channel-egress bridge; publishCapturedResponse re-addresses
     // the capture to the dashboard mirror rather than DM'ing this agent's narration to a human.
-    let channelTarget = false, answersMessageId: number | undefined; // #2840 — the delivered opener this final answers
+    let channelTarget = false, answersMessageId: number | undefined; // the delivered opener this final answers
     // A hookless capture finishes after its idle edge, so its opener was snapshotted there (event.opener).
     const pendingPrompt = this.pendingPromptMessageId, opener = event.opener !== undefined ? event.opener ?? undefined : this.takeTurnOpener(turnId);
     if (event.replyRoute !== undefined) {
       this.takePendingPrompt();
       const route = await submittedResponseReplyRoute(event.replyRoute, id => this.deps.http.getThread(id), this.deps.agentId);
       if (route) { replyToMessageId = answersMessageId = route.replyToMessageId; replyTarget = route.to; channelTarget = route.channelTarget === true; }
-    } else if (pendingPrompt && !this.deps.queuedTurnFollows()) { // #2919 — a prompt queued behind this turn is answered by its own turn
+    } else if (pendingPrompt && !this.deps.queuedTurnFollows()) { // a prompt queued behind this turn is answered by its own turn
       replyToMessageId = pendingPrompt;
       this.takePendingPrompt();
     } else {
@@ -109,13 +109,13 @@ export class TurnReport {
       answersMessageId = opener ? route?.replyToMessageId : undefined;
       if (route) { replyToMessageId = route.replyToMessageId; replyTarget = route.to; channelTarget = route.channelTarget === true; }
     }
-    await publishCapturedResponse({ publishSessionEvent: (sessionEvent) => this.deps.publishSessionEvent({ ...sessionEvent, ...(event.occurredAt ? { occurredAt: event.occurredAt } : {}) }), outbox: this.deps.reportOutbox, provider: this.deps.provider, from: this.deps.agentId, to: replyTarget, body, replyTo: replyToMessageId, channelTarget, session: { type: "response", origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}), ...(event.confidence ? { confidence: event.confidence } : {}), ...(event.endedBy ? { endedBy: event.endedBy } : {}), ...(answersMessageId ? { answersMessageId } : {}) } });
+    await publishCapturedResponse({ publishSessionEvent: (sessionEvent) => this.deps.publishSessionEvent({ ...sessionEvent, ...(event.occurredAt ? { occurredAt: event.occurredAt } : {}) }), outbox: this.deps.reportOutbox, provider: this.deps.provider, from: this.deps.agentId, to: replyTarget, body, replyTo: replyToMessageId, channelTarget, session: { type: "response", origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}), ...(event.stepId ? { stepId: event.stepId, status: "completed" as const } : {}), ...(event.confidence ? { confidence: event.confidence } : {}), ...(event.endedBy ? { endedBy: event.endedBy } : {}), ...(answersMessageId ? { answersMessageId } : {}) } });
     if (replyToMessageId) this.deps.dirtyObligations();
   }
 
   async publishSessionTurn(input: ProviderSessionTurnInput): Promise<{ reasoningSettled: boolean } | void> {
     if (input.transcriptPath) this.deps.noteTranscriptPath(input.transcriptPath);
-    // #2389 — a pre-flush capture IS a tool call in flight: independent proof the turn is doing
+    // a pre-flush capture IS a tool call in flight: independent proof the turn is doing
     // work, and the only such proof for a tools-only turn on an agent with reasoningCapture off.
     if (input.isPreFlush) this.deps.noteOutput();
     this.deps.beginTurnCapture();
@@ -166,7 +166,7 @@ export class TurnReport {
       this.deps.sessionDebug("user-prompt hook: skipped echo (runner-injected)");
     }
     await this.deps.adapter.handleUserPrompt?.(input, this.sessionTurnContext());
-    // #2664 — a late UserPromptSubmit hook is what releases an unconfirmed Claude submit.
+    // a late UserPromptSubmit hook is what releases an unconfirmed Claude submit.
     if (this.deps.deliverySubmitHold()) this.deps.tryRecoverProviderSubmitHold(false);
   }
 
@@ -198,7 +198,7 @@ export class TurnReport {
     }
   }
 
-  // The pre-session-destroy seam (#183): the single place end-of-session work runs before
+  // The pre-session-destroy seam: the single place end-of-session work runs before
   // an invasive transition (compact/clear/restart/shutdown/kill). Best-effort and
   // time-boxed so it never hangs teardown; concurrent calls for the same teardown coalesce
   // (a shutdown bus command and the SessionEnd hook can both fire). During the window the
@@ -214,7 +214,7 @@ export class TurnReport {
             Promise.all([
               this.deps.captureContextRatio(reason, opts),
               this.deps.captureContinuationArchive(reason, opts),
-              // #2491 review MED-2 — prefer the already-tracked lastTranscriptPath (what the
+              // review MED-2 — prefer the already-tracked lastTranscriptPath (what the
               // capture instance's byte-offset watermark is actually keyed to) over the hook-
               // supplied opts.transcriptPath: a mismatch resets the watermark to 0 and re-reads
               // + re-posts the whole transcript serially (safe — dedupe-keyed — but wasteful).
@@ -238,7 +238,7 @@ export class TurnReport {
     }
     if (!reasonExitsRunner(reason)) return record.capture;
     // Exit flushing is a separate once-per-incarnation obligation from capture. A shutdown hook
-    // coalesced onto a retained restart capture must still flush both durable outboxes (#1139),
+    // coalesced onto a retained restart capture must still flush both durable outboxes,
     // without repeating the expensive capture itself.
     record.exitFlush ??= record.capture.then(async () => {
       try {

package/src/api-budget-accounting.ts

@@ -1,5 +1,5 @@
 import { relayEnv } from "@humwick/sdk/env";
-import { RELAY_TOKEN_HEADER, resendOnRotatedToken, type ApiBudgetId, type ApiBudgetDecision, type ApiBudgetReservation, type ApiBudgetTokenUsage } from "@humwick/sdk";
+import { HUMWICK_TOKEN_HEADER, resendOnRotatedToken, type ApiBudgetId, type ApiBudgetDecision, type ApiBudgetReservation, type ApiBudgetTokenUsage } from "@humwick/sdk";
 import type { RunnerSpawnConfig } from "./adapter";
 import { ProviderSubmitFailure } from "./provider-submit-failure";
 
@@ -64,8 +64,8 @@ export class ApiBudgetAccounting {
   async transport(config: RunnerSpawnConfig, action: "reserve" | "report", body: Record<string, unknown>): Promise<ApiBudgetDecision> {
     let status: number | undefined;
     try {
-      const response = await resendOnRotatedToken(() => config.getRelayToken?.() ?? relayEnv(config.env, "AGENT_RELAY_TOKEN"), (token) => fetch(`${config.relayUrl}/api/agents/${encodeURIComponent(config.agentId)}/api-budget/${action}`, {
-        method: "POST", headers: { "content-type": "application/json", ...(token ? { [RELAY_TOKEN_HEADER]: token } : {}) },
+      const response = await resendOnRotatedToken(() => config.getRelayToken?.() ?? relayEnv(config.env, "HUMWICK_TOKEN"), (token) => fetch(`${config.relayUrl}/api/agents/${encodeURIComponent(config.agentId)}/api-budget/${action}`, {
+        method: "POST", headers: { "content-type": "application/json", ...(token ? { [HUMWICK_TOKEN_HEADER]: token } : {}) },
         body: JSON.stringify(this.budgetId === "claude-api" ? body : { ...body, budgetId: this.budgetId }), signal: AbortSignal.timeout(3_000),
       })).catch(error => { throw new ProviderSubmitFailure("API budget transport unavailable", true, error); });
       status = response.status;

package/src/area-memory.ts

@@ -1,6 +1,6 @@
-// #3411 — the runner's half of on-touch area memory (epic #3406). Every file a normalized tool event
-// names is matched to the repo's path areas (`.agent-relay/areas.json`); an area's first touch in a
-// context generation is reported to POST /api/agents/:id/area-entered (#3410), which selects the
+// the runner's half of on-touch area memory. Every file a normalized tool event
+// names is matched to the repo's path areas (`.humwick/areas.json`); an area's first touch in a
+// context generation is reported to POST /api/agents/:id/area-entered, which selects the
 // memories. Claude returns them through PostToolUse; other providers use `agent.injectContext`.
 
 import { relative, sep } from "node:path";
@@ -44,7 +44,7 @@ function checkoutGit(cwd: string): ProjectGit {
 }
 
 /** Never throws: the areas.json on the checkout's default branch, read through the same SDK reader
- *  the relay uses (#3635), so a worktree older than the file still tracks its areas. */
+ *  the relay uses, so a worktree older than the file still tracks its areas. */
 export async function loadAreas(cwd: string): Promise<AreasLookup> {
   try {
     const git = checkoutGit(cwd);
@@ -73,7 +73,7 @@ export class AreaMemoryTracker {
   private readonly servedAreas = new Set<string>();
   private readonly servedEntryIds = new Set<string>();
   private readonly failedReports = new Map<string, number>();
-  /** This generation's areas, read from the default branch (#3635); unset until loaded. */
+  /** This generation's areas, read from the default branch; unset until loaded. */
   private lookup?: AreasLookup;
   /** The generation a load runs for. */
   private loadingFor?: number;
@@ -97,7 +97,7 @@ export class AreaMemoryTracker {
     }
   }
 
-  /** Claude's hook owns file touches; transcript notifications must not claim them first (#3646). */
+  /** Claude's hook owns file touches; transcript notifications must not claim them first. */
   enableToolHook(): void { this.toolHook = true; this.prepare(); }
 
   /** Warm the default-branch snapshot while the provider starts, outside the hook budget. */

package/src/artifact-path-materialize.ts

@@ -2,7 +2,7 @@ import { maxArtifactBytesFromEnv, maxPathUploadRawBytes, type TokenConstraints }
 import { openArtifactPathSource } from "@humwick/sdk/artifact-path-roots";
 
 // The relay server reads `path` uploads from its own filesystem, so a path that
-// exists on this agent host is "not found" on a remote relay (#2857). The runner
+// exists on this agent host is "not found" on a remote relay. The runner
 // proxy runs beside the agent, reads the file here, and forwards bytes as base64
 // (agent→proxy stays a small path arg; only proxy→relay carries the bytes).
 export type PathMaterializeResult = { args?: Record<string, unknown>; error?: string };

package/src/async-guard.ts

@@ -1,12 +1,12 @@
-// #1665 — runner adapter over the SHARED async guards in `@humwick/sdk`.
+// runner adapter over the SHARED async guards in `@humwick/sdk`.
 //
-// The primitives themselves live in `sdk/src/async-guard.ts` because #1676 is the same
+// The primitives themselves live in `sdk/src/async-guard.ts` because is the same
 // defect class in the orchestrator: an unguarded `void <promise>` / async timer callback whose
 // rejection reaches the runtime and (in Bun) exits the process. One implementation, two
 // processes. Import from `@humwick/sdk` directly if you are outside this package.
 //
-// #2443 — `src/unguarded-async-ratchet.test.ts` has enforced the STRUCTURAL half of #1665 since
-// #1676 (no NEW unguarded site may appear in runner/src), but the actual process-level backstop
+// `src/unguarded-async-ratchet.test.ts` has enforced the STRUCTURAL half of since
+// (no NEW unguarded site may appear in runner/src), but the actual process-level backstop
 // (`installUnhandledRejectionGuard`) was never wired up here — only referenced by comments (see
 // runner-core.ts's `reportBackgroundRejection` doc). `runner/src/index.ts` installs it now.
 //
@@ -28,7 +28,7 @@ export function fireAndForget(label: string, work: Promise<unknown> | (() => Pro
   return sdkFireAndForget(`${PREFIX} ${label}`, work, log);
 }
 
-/** Install the non-fatal unhandled-rejection backstop for the runner daemon (#1665/#2443). See
+/** Install the non-fatal unhandled-rejection backstop for the runner daemon. See
  *  the SDK function for the "log and survive" reasoning and why `uncaughtException` stays fatal. */
 export function installUnhandledRejectionGuard(log?: GuardLog): () => void {
   return sdkInstallUnhandledRejectionGuard(PREFIX, log);

package/src/attachment-cache.ts

@@ -1,3 +1,4 @@
+import { readHumwickRecord, withSharedHumwickRecord } from "@humwick/sdk/stored-names";
 import { mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
@@ -40,7 +41,7 @@ function attachmentCacheRoot(agentId: string, rootDir = attachmentCacheDirFromEn
 }
 
 function attachmentCacheBase(rootDir = attachmentCacheDirFromEnv()): string {
-  return rootDir || join(homedir(), ".agent-relay", "attachments");
+  return rootDir || join(homedir(), ".humwick", "attachments");
 }
 
 export async function messagesWithCachedAttachments(
@@ -112,36 +113,30 @@ async function cacheArtifact(client: AttachmentCacheClient, artifactId: string,
 
 function withCacheMetadata(ref: Record<string, unknown>, cached: CachedAttachment): Record<string, unknown> {
   const metadata = isRecord(ref.metadata) ? ref.metadata : {};
-  const agentRelay = isRecord(metadata.agentRelay) ? metadata.agentRelay : {};
+  const humwick = readHumwickRecord(metadata) ?? {};
   return {
     ...ref,
-    metadata: {
-      ...metadata,
-      agentRelay: {
-        ...agentRelay,
-        localPath: cached.path,
-        filename: cached.filename,
-        mediaType: cached.mediaType,
-        size: cached.size,
-        digest: cached.digest,
-        cachedAt: new Date().toISOString(),
-      },
-    },
+    metadata: withSharedHumwickRecord(metadata, {
+      ...humwick,
+      localPath: cached.path,
+      filename: cached.filename,
+      mediaType: cached.mediaType,
+      size: cached.size,
+      digest: cached.digest,
+      cachedAt: new Date().toISOString(),
+    }),
   };
 }
 
 function withCacheError(ref: Record<string, unknown>, error: unknown): Record<string, unknown> {
   const metadata = isRecord(ref.metadata) ? ref.metadata : {};
-  const agentRelay = isRecord(metadata.agentRelay) ? metadata.agentRelay : {};
+  const humwick = readHumwickRecord(metadata) ?? {};
   return {
     ...ref,
-    metadata: {
-      ...metadata,
-      agentRelay: {
-        ...agentRelay,
-        cacheError: errMessage(error),
-      },
-    },
+    metadata: withSharedHumwickRecord(metadata, {
+      ...humwick,
+      cacheError: errMessage(error),
+    }),
   };
 }
 

package/src/background-script-reconcile.ts

@@ -1,21 +1,21 @@
-// #1856 — reconcile a leftover `background-script` busy that outlived its work.
+// reconcile a leftover `background-script` busy that outlived its work.
 //
 // The Claude Stop hook (`plugins/claude/hooks/relay-status.sh` `relay_post_turn_end_status`)
 // posts a `background-script:background-tasks` busy record at turn-end whenever a
 // `run_in_background` shell is still running — but Claude's `background_tasks[]` payload carries
 // only a synthetic shell id, never an OS pid, so that record is posted WITHOUT `pids`. A record
-// with no pids can never be liveness-reconciled (#650 `reconcileLiveness` only touches pid-bearing
+// with no pids can never be liveness-reconciled (`reconcileLiveness` only touches pid-bearing
 // records), and work records have no TTL, so the only thing that ever clears it is the NEXT Stop
 // hook — i.e. a fresh turn. If the background process finishes, or the operator kills it in the
 // Web terminal, nothing reconciles the belief: the agent reads `busy` forever, its turn-final
 // report is never flushed to the coordinator, and it holds a live-children quota slot doing nothing
-// (the #1856 wedge; #1068 is the sibling transient-reap symptom).
+// (the wedge; is the sibling transient-reap symptom).
 //
 // This is the runner-side backstop that breaks the wedge WITHOUT depending on per-task pids the
 // hook cannot supply: once the agent is busy on background-script work ALONE (its provider turn has
 // already ended) and has made no forward progress for the stale window, the leftover record is
 // force-cleared and the agent reconciles to idle on its own. When pids ARE available (a caller that
-// can resolve them, or a future hook), the #650 pid reconcile still clears it the instant the
+// can resolve them, or a future hook), the pid reconcile still clears it the instant the
 // process dies — this predicate only adds the no-pid backstop and is deliberately conservative:
 //   - a live provider turn (or any non-background-script work) → NEVER stale (that work owns busy),
 //   - a background-script record with a still-alive tracked pid → NEVER stale (demonstrably live),
@@ -49,7 +49,7 @@ export function isStaleBackgroundScriptOnlyBusy(input: StaleBackgroundScriptBusy
   const { activeWork } = input;
   // Something must be pinning busy, and it must be background-script work exclusively — a live
   // provider-turn, subagent, or any other work kind owns the busy state and must never be healed
-  // here (the #1656/#1838 "never clear a live turn" invariant).
+  // here (the "never clear a live turn" invariant).
   if (activeWork.length === 0) return false;
   if (activeWork.some((work) => work.kind !== "background-script")) return false;
   // A tracked pid still alive is positive proof the background work is genuinely running — hold.
@@ -61,7 +61,7 @@ export function isStaleBackgroundScriptOnlyBusy(input: StaleBackgroundScriptBusy
   return input.now - lastProgressAt >= staleAfterMs;
 }
 
-// #2034 (#2031 L3) — build the per-task background-script LEDGER a watchdog (#2035/#2036)
+// build the per-task background-script LEDGER a watchdog
 // reads to name a specific long-running script and its age, rather than just a count.
 //
 // The Claude Stop hook (`relay_background_task_list` in relay-status.sh) can only ever post

package/src/bounded-log.ts

@@ -24,7 +24,7 @@ function size(path: string): number {
 }
 
 // Keep existing oversized logs intact for operator inspection; only bounded generations
-// participate in archive pruning (#2668).
+// participate in archive pruning.
 function preserveLegacyFile(path: string, fileSize: number, maxBytes: number): void {
   if (fileSize <= maxBytes + Math.min(maxBytes, RUNNER_LOG_RECORD_MAX_BYTES)) return;
   try { renameSync(path, `${path}.legacy-${randomUUID()}`); } catch (error) {