@humwick/runner 0.130.5 → 0.130.6

package/src/config.ts

@@ -21,7 +21,7 @@ interface ProviderConfig {
   defaultTags: string[];
   chatCaptureMode: "final" | "full";
   reasoningCapture?: boolean;
-  // #2539 Phase A — optional: absent resolves through the OWNING adapter's default (codex
+  // Phase A — optional: absent resolves through the OWNING adapter's default (codex
   // adapter → steer, others → defer). `"defer"` is the operational kill switch for soft-steer.
   activeTurnMessageDelivery?: ActiveTurnMessageDelivery;
   headless: {
@@ -41,11 +41,11 @@ interface LoadedProviderConfig extends ProviderConfig {
 }
 
 export function humwickHome(): string {
-  return relayEnv(process.env, "AGENT_RELAY_HOME") || join(homedir(), ".agent-relay");
+  return relayEnv(process.env, "HUMWICK_HOME") || join(homedir(), ".humwick");
 }
 
 export function logDirFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_LOG_DIR");
+  return relayEnv(process.env, "HUMWICK_LOG_DIR");
 }
 
 function providersDir(home = humwickHome()): string {
@@ -70,7 +70,7 @@ export function defaultProviderConfig(provider: string): ProviderConfig {
     defaultTags: [],
     chatCaptureMode: "final",
     reasoningCapture: true,
-    // #2539 Phase A — deliberately NOT set here: absent resolves through the OWNING adapter's
+    // Phase A — deliberately NOT set here: absent resolves through the OWNING adapter's
     // default (codex → steer, others → defer) at the steer policy seam, so this config module
     // carries no provider-identity branch (lint:provider-contract).
     headless: {
@@ -91,14 +91,14 @@ export function loadGlobalConfig(home = humwickHome()): GlobalRunnerConfig {
 }
 
 function relayUrlFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_URL");
+  return relayEnv(process.env, "HUMWICK_URL");
 }
 
-// #1096 — override for the Codex hooks version gate (finding 4). An explicit version string
+// override for the Codex hooks version gate (finding 4). An explicit version string
 // bypasses the `codex --version` probe: deterministic in tests, and an operator escape hatch
 // when the probe can't run. Empty string means "assume supported".
 export function codexVersionOverrideFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_CODEX_VERSION");
+  return relayEnv(process.env, "HUMWICK_CODEX_VERSION");
 }
 
 function textEnvOrFile(name: string): string | undefined {
@@ -115,41 +115,41 @@ function textEnvOrFile(name: string): string | undefined {
 }
 
 export function relayTokenFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN");
+  return relayEnv(process.env, "HUMWICK_TOKEN");
 }
 
-// #2254 — escape hatch for the per-launch Claude folder-trust seed. Off by default: an
+// escape hatch for the per-launch Claude folder-trust seed. Off by default: an
 // unseeded launch wedges on CC's trust dialog until a human answers, so this exists only for
 // an operator who deliberately wants relay to keep its hands off a shared config. Never set
 // it to protect a test — tests point CLAUDE_CONFIG_DIR at a fixture instead
 // (scripts/test-preload-provider-home.ts), so the production path stays exercised.
 export function claudeTrustSeedDisabledFromEnv(): boolean {
-  return relayEnv(process.env, "AGENT_RELAY_TRUST_SEED_DISABLED") === "1";
+  return relayEnv(process.env, "HUMWICK_TRUST_SEED_DISABLED") === "1";
 }
 
-// #2950 slice flag: launch Claude with `--effort` and accept mid-session effort switches.
+// slice flag: launch Claude with `--effort` and accept mid-session effort switches.
 export function effortSwitchEnabledFromEnv(): boolean {
-  return relayEnv(process.env, "AGENT_RELAY_EFFORT_SWITCH") === "1";
+  return relayEnv(process.env, "HUMWICK_EFFORT_SWITCH") === "1";
 }
 
 export function runtimeTokenProfileFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN_PROFILE");
+  return relayEnv(process.env, "HUMWICK_TOKEN_PROFILE");
 }
 
 export function runtimeTokenJtiFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN_JTI");
+  return relayEnv(process.env, "HUMWICK_TOKEN_JTI");
 }
 
 export function runtimeTokenExpiresAtFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN_EXPIRES_AT");
+  return relayEnv(process.env, "HUMWICK_TOKEN_EXPIRES_AT");
 }
 
 export function runtimeTokenFileFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN_FILE");
+  return relayEnv(process.env, "HUMWICK_TOKEN_FILE");
 }
 
 export function runtimeTokenExpiresAtFileFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TOKEN_EXPIRES_AT_FILE");
+  return relayEnv(process.env, "HUMWICK_TOKEN_EXPIRES_AT_FILE");
 }
 
 // Deadline for a freshly spawned runner's INITIAL relay registration. Reconnects after the
@@ -158,13 +158,13 @@ export function runtimeTokenExpiresAtFileFromEnv(): string | undefined {
 // an unreachable relay) must EXIT instead of hanging `active` forever — a hung runner is
 // invisible to the orchestrator's exit detection, so the spawn-parent is never notified.
 export function registrationTimeoutMsFromEnv(): number {
-  const parsed = Number(relayEnv(process.env, "AGENT_RELAY_REGISTRATION_TIMEOUT_MS"));
+  const parsed = Number(relayEnv(process.env, "HUMWICK_REGISTRATION_TIMEOUT_MS"));
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
 }
 
 export { NATIVE_SELF_RESUME_TIMEOUT_MS, MIN_NATIVE_SELF_RESUME_TIMEOUT_MS, nativeSelfResumeTimeoutMsFromEnv } from "@humwick/sdk";
 
-// #2095 self-compact e2e test rig — one-shot forced context utilization. When set, the runner
+// self-compact e2e test rig — one-shot forced context utilization. When set, the runner
 // REPORTS a synthetic ContextState at this utilization (lifecycleState "working", source "estimate",
 // confidence "estimated") so the server's REAL 10s lifecycle tick fires the REAL advisory + REAL
 // forced clear-inject exactly once — the actual compaction path is never stubbed. Accepts a fraction
@@ -172,7 +172,7 @@ export { NATIVE_SELF_RESUME_TIMEOUT_MS, MIN_NATIVE_SELF_RESUME_TIMEOUT_MS, nativ
 // >1 after normalization) → undefined = feature OFF, and the runner's context reporting is UNCHANGED.
 // The strict one-shot LATCH lives in runner-core (heartbeatRuntimeMeta + handleCommand), not here.
 export function forceContextPctFromEnv(): number | undefined {
-  const raw = relayEnv(process.env, "AGENT_RELAY_FORCE_CONTEXT_PCT");
+  const raw = relayEnv(process.env, "HUMWICK_FORCE_CONTEXT_PCT");
   if (raw === undefined || raw.trim() === "") return undefined;
   const parsed = Number(raw);
   if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
@@ -186,24 +186,24 @@ export function forceContextPctFromEnv(): number | undefined {
 }
 
 export function agentProfileNameFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_AGENT_PROFILE");
+  return relayEnv(process.env, "HUMWICK_AGENT_PROFILE");
 }
 
 /** Explicit launch policy is independent of whether the named profile still exists. */
 export function harnessSubagentsFromEnv(env: Record<string, string | undefined> = process.env): boolean | undefined {
-  const value = relayEnv(env, "AGENT_RELAY_HARNESS_SUBAGENTS");
+  const value = relayEnv(env, "HUMWICK_HARNESS_SUBAGENTS");
   return value === "1" ? true : value === "0" ? false : undefined;
 }
 
 export function agentProfileJsonFromEnv(): string | undefined {
-  return textEnvOrFile("AGENT_RELAY_AGENT_PROFILE_JSON");
+  return textEnvOrFile("HUMWICK_AGENT_PROFILE_JSON");
 }
 
 export function workspaceJsonFromEnv(): string | undefined {
-  return textEnvOrFile("AGENT_RELAY_WORKSPACE_JSON");
+  return textEnvOrFile("HUMWICK_WORKSPACE_JSON");
 }
 
-/** #2947 — the toolchain the orchestrator launched this runner on, reported at registration; the relay validates it. */
+/** the toolchain the orchestrator launched this runner on, reported at registration; the relay validates it. */
 export function projectToolchainFromEnv(): ProjectToolchain | undefined {
   try {
     const parsed: unknown = JSON.parse(relayEnv(process.env, PROJECT_TOOLCHAIN_ENV) ?? "");
@@ -214,52 +214,52 @@ export function projectToolchainFromEnv(): ProjectToolchain | undefined {
 }
 
 export function relayInjectionEventsJsonFromEnv(): string | undefined {
-  return textEnvOrFile("AGENT_RELAY_INJECTION_EVENTS_JSON");
+  return textEnvOrFile("HUMWICK_INJECTION_EVENTS_JSON");
 }
 
 export function promptFromEnv(): string | undefined {
-  return textEnvOrFile("AGENT_RELAY_PROMPT");
+  return textEnvOrFile("HUMWICK_PROMPT");
 }
 
 export function systemPromptAppendFromEnv(): string | undefined {
-  return textEnvOrFile("AGENT_RELAY_SYSTEM_PROMPT_APPEND");
+  return textEnvOrFile("HUMWICK_SYSTEM_PROMPT_APPEND");
 }
 
 export function tmuxSessionFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TMUX_SESSION");
+  return relayEnv(process.env, "HUMWICK_TMUX_SESSION");
 }
 
 export function policyNameFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_POLICY");
+  return relayEnv(process.env, "HUMWICK_POLICY");
 }
 
 export function spawnRequestIdFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_SPAWN_REQUEST_ID");
+  return relayEnv(process.env, "HUMWICK_SPAWN_REQUEST_ID");
 }
 
 export function taskIdFromEnv(): number | undefined {
-  const parsed = Number(relayEnv(process.env, "AGENT_RELAY_TASK_ID"));
+  const parsed = Number(relayEnv(process.env, "HUMWICK_TASK_ID"));
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 
 export function automationIdFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_AUTOMATION_ID");
+  return relayEnv(process.env, "HUMWICK_AUTOMATION_ID");
 }
 
 export function automationRunIdFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_AUTOMATION_RUN_ID");
+  return relayEnv(process.env, "HUMWICK_AUTOMATION_RUN_ID");
 }
 
 export function lifecycleFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_LIFECYCLE");
+  return relayEnv(process.env, "HUMWICK_LIFECYCLE");
 }
 
 export function sessionDebugEnabled(): boolean {
-  return relayEnv(process.env, "AGENT_RELAY_SESSION_DEBUG") === "1";
+  return relayEnv(process.env, "HUMWICK_SESSION_DEBUG") === "1";
 }
 
 export function logLevelFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_LOG_LEVEL");
+  return relayEnv(process.env, "HUMWICK_LOG_LEVEL");
 }
 
 function envSwitchOn(name: string): boolean {
@@ -267,26 +267,26 @@ function envSwitchOn(name: string): boolean {
 }
 
 export function mcpProxyEnabledFromEnv(): boolean {
-  return envSwitchOn("AGENT_RELAY_MCP_PROXY");
+  return envSwitchOn("HUMWICK_MCP_PROXY");
 }
 
-/** #3025 rollback switch for agent-redact secret redaction hooks. */
+/** rollback switch for agent-redact secret redaction hooks. */
 export function redactionEnabledFromEnv(): boolean {
-  return envSwitchOn("AGENT_RELAY_REDACT");
+  return envSwitchOn("HUMWICK_REDACT");
 }
 
 export function runnerInfoFileFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_RUNNER_INFO_FILE");
+  return relayEnv(process.env, "HUMWICK_RUNNER_INFO_FILE");
 }
 
-// #1514 — the owning orchestrator's state-home id, stamped onto each tmux session
+// the owning orchestrator's state-home id, stamped onto each tmux session
 // (@agent-relay-owner) so the wedged-session reaper only reaps sessions it owns.
 export function tmuxOwnerIdFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TMUX_OWNER");
+  return relayEnv(process.env, "HUMWICK_TMUX_OWNER");
 }
 
 export function runnerOutboxDirFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_RUNNER_OUTBOX_DIR");
+  return relayEnv(process.env, "HUMWICK_RUNNER_OUTBOX_DIR");
 }
 
 export function runnerOutboxDirWithInfoFallback(): string | undefined {
@@ -297,25 +297,25 @@ export function runnerOutboxDirWithInfoFallback(): string | undefined {
 }
 
 export function capsFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_CAPS");
+  return relayEnv(process.env, "HUMWICK_CAPS");
 }
 
 export function tagsFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_TAGS");
+  return relayEnv(process.env, "HUMWICK_TAGS");
 }
 
 export function workspaceModeFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_WORKSPACE_MODE");
+  return relayEnv(process.env, "HUMWICK_WORKSPACE_MODE");
 }
 
 export function orchestratorBaseDirFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_ORCHESTRATOR_BASE_DIR");
+  return relayEnv(process.env, "HUMWICK_ORCHESTRATOR_BASE_DIR");
 }
 
 /**
  * The orchestrator stamps its stable Relay id on every managed runner. Central
  * provider configuration is keyed by that id, rather than the mutable OS hostname
- * (for example, orchestrator `wbox` may report hostname `wbox-1`). Interactive
+ * (for example, orchestrator `worker-a` may report hostname `worker-a-1`). Interactive
  * runners have no owner id and retain the hostname-scoped fallback.
  */
 export function providerConfigHostFromEnv(): string {
@@ -326,7 +326,7 @@ export function providerConfigHostFromEnv(): string {
 export function providerConfigLookupFromEnv(): { host: string; legacyHost?: string; managed: boolean } {
   const managedHost = localOrchestratorIdFromEnv();
   if (!managedHost) return { host: hostname(), managed: false };
-  const legacyHost = relayEnv(process.env, "AGENT_RELAY_ORCHESTRATOR_HOSTNAME")?.trim();
+  const legacyHost = relayEnv(process.env, "HUMWICK_ORCHESTRATOR_HOSTNAME")?.trim();
   return {
     host: managedHost,
     ...(legacyHost && legacyHost !== managedHost ? { legacyHost } : {}),
@@ -335,23 +335,23 @@ export function providerConfigLookupFromEnv(): { host: string; legacyHost?: stri
 }
 
 export function runnerLogFileFromEnv(): string | undefined {
-  return typeof relayEnv(process.env, "AGENT_RELAY_LOG_FILE") === "string" ? relayEnv(process.env, "AGENT_RELAY_LOG_FILE") : undefined;
+  return typeof relayEnv(process.env, "HUMWICK_LOG_FILE") === "string" ? relayEnv(process.env, "HUMWICK_LOG_FILE") : undefined;
 }
 
 export function orchestratorUrlFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_ORCHESTRATOR_URL");
+  return relayEnv(process.env, "HUMWICK_ORCHESTRATOR_URL");
 }
 
 export function contextStateDirFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_CONTEXT_STATE_DIR");
+  return relayEnv(process.env, "HUMWICK_CONTEXT_STATE_DIR");
 }
 
 export function attachmentCacheDirFromEnv(): string | undefined {
-  return relayEnv(process.env, "AGENT_RELAY_ATTACHMENT_CACHE_DIR");
+  return relayEnv(process.env, "HUMWICK_ATTACHMENT_CACHE_DIR");
 }
 
 export function providerHomeRootFromEnv(): string {
-  return relayEnv(process.env, "AGENT_RELAY_PROVIDER_HOME_ROOT") || join(homedir(), ".agent-relay", "provider-homes");
+  return relayEnv(process.env, "HUMWICK_PROVIDER_HOME_ROOT") || join(homedir(), ".humwick", "provider-homes");
 }
 
 export function loadProviderConfig(provider: string, home = humwickHome()): LoadedProviderConfig {
@@ -370,7 +370,7 @@ export function loadProviderConfig(provider: string, home = humwickHome()): Load
     defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
     chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
     reasoningCapture: booleanValue(raw.reasoningCapture) ?? defaults.reasoningCapture,
-    // #2539 — an invalid value falls back to absent, which the steer policy resolves through
+    // an invalid value falls back to absent, which the steer policy resolves through
     // the owning adapter's default.
     activeTurnMessageDelivery: enumValue(raw.activeTurnMessageDelivery, [...ACTIVE_TURN_MESSAGE_DELIVERY_VALUES]),
     headless: {
@@ -399,7 +399,7 @@ export async function loadProviderConfigFromRelay(
       attemptedKeys.push(legacyKey);
       const legacy = await fetchProviderConfig(provider, opts.relayUrl, opts.token, legacyKey, retry);
       if (legacy && legacy.version > 0) {
-        console.warn(`[agent-relay] central provider config ${key} is missing; using legacy hostname key ${legacyKey}. Migrate this row to ${key}.`);
+        console.warn(`[humwick] central provider config ${key} is missing; using legacy hostname key ${legacyKey}. Migrate this row to ${key}.`);
         return legacy.config;
       }
       if (!fetched && legacy) return legacy.config;
@@ -407,9 +407,9 @@ export async function loadProviderConfigFromRelay(
     if (fetched) return fetched.config;
     if (opts.managed) throw new Error(`central provider config missing for managed keys ${attemptedKeys.join(", ")}`);
   } catch (error) {
-    // #3238: a local fallback can select a different, obsolete provider binary.
+    // a local fallback can select a different, obsolete provider binary.
     if (opts.managed) throw new Error(`Managed provider config ${key} could not be loaded: ${errMessage(error)}`);
-    console.warn(`[agent-relay] provider config relay read failed (${errMessage(error)}); using local fallback ${local.path}.`);
+    console.warn(`[humwick] provider config relay read failed (${errMessage(error)}); using local fallback ${local.path}.`);
   }
   return local;
 }
@@ -510,6 +510,7 @@ async function fetchProviderConfig(
   retry?: Partial<StartupFetchDeps>,
 ): Promise<{ config: LoadedProviderConfig; version: number } | null> {
   const url = new URL(`/api/settings/provider-config/${encodeURIComponent(key)}`, relayUrl);
+  url.searchParams.set("effectiveEnv", "true");
   const { response: res, body } = await fetchStartupConfig(url, token, retry ? RUNNER_CONFIG_RETRY_TIMEOUT_MS : 0, retry);
   if (res.status === 404) return null;
   if (!res.ok) throw new Error(body?.error ? `${res.status}: ${body.error}` : `HTTP ${res.status}`);
@@ -517,7 +518,7 @@ async function fetchProviderConfig(
     || !isRecord(body.value) || !stringValue(body.value.command)) {
     throw new Error(`invalid central provider config response for ${key}`);
   }
-  // Version zero is the hub's resolved default, not a failed config read (#3320).
+  // Version zero is the hub's resolved default, not a failed config read.
   return { config: providerConfigFromValue(provider, body.value, `config:provider-config/${key}`), version: body.version! };
 }
 
@@ -536,7 +537,7 @@ function providerConfigFromValue(provider: string, value: unknown, path: string)
     defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
     chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
     reasoningCapture: booleanValue(raw.reasoningCapture) ?? defaults.reasoningCapture,
-    // #2539 — an invalid value falls back to absent, which the steer policy resolves through
+    // an invalid value falls back to absent, which the steer policy resolves through
     // the owning adapter's default.
     activeTurnMessageDelivery: enumValue(raw.activeTurnMessageDelivery, [...ACTIVE_TURN_MESSAGE_DELIVERY_VALUES]),
     headless: {

package/src/context-boundary.ts

@@ -2,7 +2,7 @@ import { errMessage } from "@humwick/sdk";
 import type { ProviderStatusUpdate } from "./adapter";
 
 /**
- * #3398 — Relay lists the agent's reads when a provider context resets. A reset fact goes out only after
+ * Relay lists the agent's reads when a provider context resets. A reset fact goes out only after
  * every delivery settlement started before it, so each mark-read the old context started has committed or
  * failed by then; a failed one leaves its message unread.
  */
@@ -22,7 +22,7 @@ export class DeliverySettlements {
 
 export type ContextResetKind = "compact" | "clear";
 
-/** A boundary command that gave up before its destructive input reached the provider (#3441). */
+/** A boundary command that gave up before its destructive input reached the provider. */
 export class ContextSubmitAborted extends Error {}
 
 export interface ContextResetFact {
@@ -34,16 +34,16 @@ export interface ContextResetFact {
 }
 
 /**
- * #3398 (docs/design/self-resume-carry.md) — one reset fact per genuine provider reset, waited for or not.
+ * (docs/design/self-resume-carry.md) — one reset fact per genuine provider reset, waited for or not.
  * Submitted destructive inputs stay in order until provider evidence settles one: a manual reset settles
  * the oldest of its kind, an automatic one none. A timed-out command keeps input the provider holds.
  */
-/** How long a reset the adapter confirmed may still be observed as its provider status (#3698). */
+/** How long a reset the adapter confirmed may still be observed as its provider status. */
 export const CONFIRMED_RESET_OBSERVE_WINDOW_MS = 60_000;
 
 export class ContextResetReporter {
   private readonly submitted: Array<{ commandId: string; kind: ContextResetKind }> = [];
-  /** #3698 — confirmed by the adapter before its provider status arrived: that status is the SAME reset. */
+  /** confirmed by the adapter before its provider status arrived: that status is the SAME reset. */
   private readonly confirmedUnobserved: Array<{ commandId: string; kind: ContextResetKind; at: number }> = [];
 
   /** `onUncommandedReset` runs at observation for a reset no boundary command caused (operator `/clear`, auto-compaction). */

package/src/context-command.ts

@@ -26,7 +26,7 @@ export class ClearInjectInboxFence {
     const pending = this.pending;
     if (pending?.commandId !== commandId) return;
     pending.clearing = awaitingLateClear;
-    // #2854: the continuation backstop may never arrive; wake the inbox independently.
+    // the continuation backstop may never arrive; wake the inbox independently.
     pending.timer = setTimeout(() => {
       if (this.pending !== pending) return;
       this.reset();
@@ -69,8 +69,8 @@ interface LateClearContinuation {
 export function lateClearHookContent(recovery: LateClearContinuation): string {
   if (recovery.content.length <= LATE_CLEAR_HOOK_MAX_CHARS) return recovery.content;
   const fetch = recovery.fullContextMessageId
-    ? `relay_get_message #${recovery.fullContextMessageId} (CLI: agent-relay get-message ${recovery.fullContextMessageId})`
-    : 'relay_recall with query "latest working state"';
+    ? `humwick_get_message #${recovery.fullContextMessageId} (CLI: humwick get-message ${recovery.fullContextMessageId})`
+    : 'humwick_recall with query "latest working state"';
   return `A delayed /clear committed after its confirmation timed out. Your saved continuation exceeds the hook context limit. Retrieve it with ${fetch} before resuming work; the full continuation was not injected here.`;
 }