@humwick/runner 0.130.4 → 0.130.6

package/src/question-decision.ts

@@ -1,7 +1,7 @@
 import { COORDINATOR_PROFILE_NAMES, errMessage, type OperatorDecisionFileInput, type HumwickHttpClient } from "@humwick/sdk";
 
-// #2914: a coordinator's AskUserQuestion becomes a durable operator decision (same store, dashboard card and
-// answer-as-message as relay_decision). Any other agent, or a failed file, keeps the live relayed question.
+// a coordinator's AskUserQuestion becomes a durable operator decision (same store, dashboard card and
+// answer-as-message as humwick_decision). Any other agent, or a failed file, keeps the live relayed question.
 export async function fileQuestionDecision(
   deps: { http: Pick<HumwickHttpClient, "fileDecision">; profile?: string; log(message: string): void },
   input: OperatorDecisionFileInput,

package/src/quota.ts

@@ -1,21 +1,15 @@
 export {
   DEFAULT_PROVIDER_QUOTA_CONFIG,
   QuotaRetryAfterError,
-  claudeRateLimitHeadersQuotaState,
   claudeUsageQuotaState,
-  collectClaudeQuotaState,
   collectCodexQuotaSample,
   collectCodexQuotaState,
   codexRateLimitsQuotaState,
   credentialAccountKey,
-  defaultClaudeConfigDir,
   defaultZaiCredentialsPath,
   normalizeProviderQuotaConfig,
   providerPayloadAccountKey,
-  resolveClaudeQuotaIdentity,
-  resolveClaudeStatuslineQuotaIdentity,
   resolveCodexQuotaIdentity,
-  resolveStableClaudeQuotaIdentity,
   resolveStableCodexQuotaIdentity,
   resolveStableZaiQuotaIdentity,
   type ProviderQuotaIdentity,

package/src/rate-limit.ts

@@ -1,4 +1,4 @@
-// #286 — shared rate-limit hold construction + Claude pane detection.
+// shared rate-limit hold construction + Claude pane detection.
 //
 // Two detection arms feed the SAME provider-neutral `blocked` hold:
 //   1. The StopFailure hook (clean API-error turn-end: API-429/auth/billing) → control-server.
@@ -18,6 +18,7 @@ const MAX_RESET_AHEAD_MS = 7 * 24 * 60 * 60 * 1000;
 
 interface RateLimitHoldInput {
   errorType?: string;
+  usageLimitScope?: ProviderState["usageLimitScope"];
   kind?: "usage_limit" | "transient_overload";
   /** Unix ms the limit window resets, when known. */
   resetAt?: number;
@@ -25,7 +26,7 @@ interface RateLimitHoldInput {
   source?: string;
 }
 
-// #3577 — Claude reports a proxy that refused CONNECT as "Couldn't connect through your proxy
+// Claude reports a proxy that refused CONNECT as "Couldn't connect through your proxy
 // (ERR_PROXY_TUNNEL)"; Agent Vault refuses an expired or revoked session with 407.
 const PROXY_AUTH_FAILURE_RE = /ERR_PROXY_TUNNEL|proxy authentication required|\b407\b[^\n]*proxy|proxy[^\n]*\b407\b/i;
 
@@ -64,6 +65,7 @@ export function buildRateLimitProviderState(input: RateLimitHoldInput): Provider
       ? "Holding briefly for provider overload; Humwick will retry with bounded backoff."
       : "Holding until the usage window resets; Humwick auto-resumes the agent.",
     kind,
+    ...(kind === "usage_limit" ? { usageLimitScope: input.usageLimitScope ?? "provider" } : {}),
     source: input.source ?? "claude",
     errorType: input.errorType ?? RATE_LIMIT_BLOCK_REASON,
     enteredAt: now,
@@ -94,7 +96,7 @@ const LIMIT_PHRASE_RE = /(?:hit (?:your|the)\s*(?:[\w-]+\s+)*limit|usage limit|\
 const RESET_AT_RE = /\bresets?\b(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
 const TRY_AGAIN_RE = /\btry again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
 
-// #1611 — the limit phrase and its reset/retry must sit on the same line or within this many
+// the limit phrase and its reset/retry must sit on the same line or within this many
 // lines of each other. The pairing was originally allowed to span the WHOLE pane so a modal
 // wrapping across rows still matched; that made the two halves collectable from unrelated
 // places on screen. A modal wraps onto the very next row, so a tight window keeps the wrapped
@@ -123,7 +125,7 @@ export function parseClaudeRateLimitPane(text: string, nowMs: number = Date.now(
 }
 
 /**
- * #1611 — the usage-limit modal, distinguished from the agent's OWN pane output.
+ * the usage-limit modal, distinguished from the agent's OWN pane output.
  *
  * The capture (`capture-pane -S -80`) contains the agent's rendered conversation, so a
  * phrase test over the whole pane fires on any agent that WRITES about rate limits. It did:
@@ -144,7 +146,7 @@ export function parseClaudeRateLimitPane(text: string, nowMs: number = Date.now(
  * a false negative, which costs one retry via the resume sweep. That is the cheap direction:
  * a false positive marks a healthy agent blocked, and `isAgentUnavailable` (src/db/
  * agent-predicates.ts) then QUEUES its inbound messages until the fabricated reset — real
- * work idled on a fabricated signal. See #1611.
+ * work idled on a fabricated signal.
  */
 function parseClaudeUsageLimitModal(text: string, nowMs: number): PaneRateLimit | null {
   const block = livePaneBlock(text);
@@ -171,25 +173,33 @@ function parseClaudeUsageLimitModal(text: string, nowMs: number): PaneRateLimit
   return null;
 }
 
-// #2619 — account-level usage/quota walls as providers word them in an API error message (zai:
+// account-level usage/quota walls as providers word them in an API error message (zai:
 // "Usage limit reached for 5 hour. Your limit will reset at 2026-09-24 03:47:08"). Narrower than
 // LIMIT_PHRASE_RE on purpose: a bare "rate limit" is a per-request throttle, not a quota wall.
-const USAGE_LIMIT_MESSAGE_RE = /usage limit|usage exceeded|quota|limit (?:will )?resets?\b|insufficient (?:balance|credits?)/i;
+const USAGE_LIMIT_MESSAGE_RE = /usage limit|usage exceeded|quota|limit (?:will )?resets?\b/i;
+// the money walls among them (Anthropic: "credit balance is too low", "You have reached your specified
+// API usage limits. You will regain access on ..."). Only these zero a metered API budget; a throttle never does.
+const CREDIT_WALL_MESSAGE_RE = /spend(?:ing)? limit|api usage limits?\b|credit balance[^\n]*too low|insufficient (?:balance|credits?)/i;
 const RESET_AT_TIMESTAMP_RE = /\bresets?\s+(?:at\s+)?(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?\s*(?:Z|[+-]\d{2}:?\d{2}))/i;
 
 type ProviderRefusal = { message: string; errorType?: string; statusCode?: number };
 
 /** An account-level usage/quota wall: retrying in-session or re-rolling the session cannot clear it. */
 export function isProviderUsageLimit(error: ProviderRefusal): boolean {
-  return USAGE_LIMIT_MESSAGE_RE.test(error.message) || /quota|usage_limit|tier_limit/i.test(error.errorType ?? "");
+  return isProviderCreditWall(error) || USAGE_LIMIT_MESSAGE_RE.test(error.message) || /quota|usage_limit|tier_limit/i.test(error.errorType ?? "");
 }
 
-/** #2619 — a provider-wide overload (5xx): not a broken session, so never worth a re-roll. */
+/** An account wall of money: exhausted credit or a reached spend limit. */
+export function isProviderCreditWall(error: ProviderRefusal): boolean {
+  return CREDIT_WALL_MESSAGE_RE.test(error.message);
+}
+
+/** a provider-wide overload (5xx): not a broken session, so never worth a re-roll. */
 export function isProviderOverload(error: ProviderRefusal): boolean {
   return (error.statusCode !== undefined && error.statusCode >= 500) || /overload/i.test(error.errorType ?? "");
 }
 
-// #2619 — per-request throttle wording. Some providers send it on a non-429 status flagged
+// per-request throttle wording. Some providers send it on a non-429 status flagged
 // non-retryable (zai: 403 "Rate limit exceeded"); it is still a throttle, never an auth/model failure.
 const THROTTLE_MESSAGE_RE = /rate[\s_-]?limit|too many requests|throttl/i;
 
@@ -206,7 +216,7 @@ function isProviderRateLimited(error: ProviderRefusal): boolean {
 }
 
 /**
- * #2619 — the hold a RETRYABLE provider API refusal (429 quota wall, 5xx overload) ends a turn in,
+ * the hold a RETRYABLE provider API refusal (429 quota wall, 5xx overload) ends a turn in,
  * instead of a terminal failure: a terminal `error` status resolves runner-core's provider exit,
  * which is how every zai/OpenCode session died ~10 min into a quota wall. The same
  * `blocked/rate_limit` hold the Claude arms raise: runner-core keeps it across the idle, the relay
@@ -214,10 +224,11 @@ function isProviderRateLimited(error: ProviderRefusal): boolean {
  */
 export function buildProviderRefusalHold(input: ProviderRefusal & { detail: string; source: string; resetAt?: number }, nowMs: number = Date.now()): ProviderState {
   const usageLimit = isProviderRateLimited(input);
-  // A provider-stated reset (OpenCode's retry `next`, #2775) beats parsing one out of the message.
+  // A provider-stated reset beats parsing one out of the message.
   const resetAt = usageLimit ? clampReset(input.resetAt, nowMs) ?? providerLimitResetAt(input.message, nowMs) : undefined;
   return buildRateLimitProviderState({
     kind: usageLimit ? "usage_limit" : "transient_overload",
+    usageLimitScope: isProviderCreditWall(input) ? "credit" : isProviderUsageLimit(input) || resetAt !== undefined ? "provider" : "request",
     errorType: input.errorType ?? (input.statusCode !== undefined ? String(input.statusCode) : "provider_error"),
     message: input.detail,
     source: input.source,
@@ -258,7 +269,7 @@ function livePaneBlock(text: string): string[] {
 // Unlike the usage-limit modal, Claude Code renders a transient API error as a CONVERSATION
 // row (`● API Error: 529 Overloaded…`), i.e. in the body, above the composer — so the
 // positional gate above cannot apply here without losing the detection entirely.
-// #1611 — but the arm had the same own-output hole: the phrase was matched anywhere on any
+// but the arm had the same own-output hole: the phrase was matched anywhere on any
 // line, so an agent rendering this file's diff or a quoted error tripped it (reproduced live:
 // the fragment `+ane("● API Error: 529 Ove` in a rendered patch marked the agent blocked).
 // Claude's own error row STARTS with the error, after nothing but its bullet/box chrome, so

package/src/refused-prompt-store.ts

@@ -5,12 +5,12 @@ import { join } from "node:path";
 import { sanitizeFsName } from "@humwick/sdk/fs-name";
 import { runnerOutboxDirFromEnv } from "./config";
 
-/** #2622: unconfirmed self-posts remain cancelled across restart, without an in-memory tombstone cap. */
+/** unconfirmed self-posts remain cancelled across restart, without an in-memory tombstone cap. */
 export class RefusedPromptStore {
   private readonly db: Database;
 
   constructor(options: { agentId: string; dir?: string }) {
-    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "agent-relay-outbox");
+    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "humwick-outbox");
     const name = sanitizeFsName(options.agentId, { replacement: "_", maxLen: 180, fallback: "agent" });
     if (dir !== ":memory:") mkdirSync(dir, { recursive: true });
     this.db = new Database(dir === ":memory:" ? dir : join(dir, `refused-prompts-${name}.sqlite`), { create: true });

package/src/relay-injection-events.ts

@@ -51,7 +51,7 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
         : event,
     }));
   }
-  // #1565 P5.7 — the native-memory lever gets its OWN `memory`-category event (the channel #1612
+  // P5.7 — the native-memory lever gets its OWN `memory`-category event (the channel
   // established for the spawn-seam memory block), not a line in the tools summary: this decides
   // whether the agent has one memory store or two, and a SUPPRESSED lever must be visible even on
   // a launch that provisions nothing else and would otherwise return early below.
@@ -75,7 +75,7 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
       },
     });
   }
-  // #3025 — a host without agent-redact still launches the agent; that launch must say so loudly.
+  // a host without agent-redact still launches the agent; that launch must say so loudly.
   // Appended last, so readers that find the first "tools" event still get the provisioning summary.
   const redaction = assembled.redaction;
   const redactionEvents: KeyedRelayInjectionEvent[] = redaction.state === "unavailable" ? [{

package/src/relay-instructions.ts

@@ -19,14 +19,14 @@ export function profileAllowsRelayFeature(config: Pick<RunnerSpawnConfig, "agent
 }
 
 /**
- * First-turn briefing (availability + text together). #2836: no core copy — the core is
+ * First-turn briefing (availability + text together).: no core copy — the core is
  * server-composed, and hand-started runners get no Relay instructions at all.
  */
 export function resolveRelayContext(input: {
   slug: string;
   config?: Pick<RunnerSpawnConfig, "agentProfile">;
   mcpServers?: Record<string, ProvisioningMcpServer>;
-  /** #3024 — the launch's Brave/Jina tools, named per provider in the steer. */
+  /** the launch's Brave/Jina tools, named per provider in the steer. */
   webTools?: { names: readonly WebToolName[]; claude: boolean };
 }): RelayContextResolution {
   if (input.config && !profileAllowsRelayFeature(input.config, "context")) {
@@ -47,7 +47,7 @@ export function claudeRelayManual(): string {
 /** One line per capability: Brave searches; the local reader fetches, with keyless Jina fallback. */
 export function webToolsSteer(names: readonly WebToolName[], claude: boolean): string {
   return names.map(name => name === "brave"
-    ? `Web search: use ${claude ? "web_search on the agent-relay MCP server (load with ToolSearch)" : "web_search on the agent-relay MCP server"}. Relay tries Tavily, then budget-capped Brave. If the monthly cap is reached, report it; do not retry in a loop.`
+    ? `Web search: use ${claude ? "web_search on the humwick MCP server (load with ToolSearch)" : "web_search on the humwick MCP server"}. Relay tries Tavily, then budget-capped Brave. If the monthly cap is reached, report it; do not retry in a loop.`
     : renderRunnerTemplate("relay.web.fetch", {
       tools: webToolSteerRefs(name, claude), fallback: webToolSteerRefs(name, claude, true),
     })).join("\n");
@@ -62,7 +62,7 @@ export function claudeReadOnlyRelayContext(): string {
 }
 
 export function relayReplyActionText(messageId: number): string {
-  return `relay_reply (messageId: ${messageId}, body: "<your reply>"). CLI fallback: agent-relay /reply ${messageId} "<your reply>"`;
+  return `humwick_reply (messageId: ${messageId}, body: "<your reply>"). CLI fallback: humwick /reply ${messageId} "<your reply>"`;
 }
 
 export function workspaceDepsNote(input: { mode?: string | null; depsMode?: string | null; installCommand?: string | null }): string {
@@ -92,7 +92,7 @@ export function workspaceSymlinksNote(linked: string[]): string {
 }
 
 export function workspaceDepsNoteFromEnv(env: Record<string, string | undefined> = process.env): string {
-  const json = relayEnv(env, "AGENT_RELAY_WORKSPACE_JSON");
+  const json = relayEnv(env, "HUMWICK_WORKSPACE_JSON");
   if (!json) return "";
   try {
     const parsed = JSON.parse(json) as { mode?: string; branch?: string; baseRef?: string; deps?: { mode?: string; command?: string }; symlinks?: { linked?: string[] } };

package/src/relay-mcp-proxy.long-turn-e2e.ts

@@ -1,7 +1,7 @@
 /**
- * #2429 / #2537 — opt-in compressed long-turn E2E for the shared MCP tool-call forward.
+ * opt-in compressed long-turn E2E for the shared MCP tool-call forward.
  *
- * Spawned as a CHILD bun process by the AGENT_RELAY_LONG_TURN_E2E=1-gated test in
+ * Spawned as a CHILD bun process by the HUMWICK_LONG_TURN_E2E=1-gated test in
  * relay-mcp-proxy.test.ts, with BUN_CONFIG_HTTP_IDLE_TIMEOUT=2 compressing Bun's native
  * ~300s HTTP idle watchdog down to ~2s for this process. A stand-in relay withholds ALL
  * response bytes for 6s (mimicking src/mcp/index.ts `tools/call`, which awaits the WHOLE
@@ -10,14 +10,14 @@
  *   CONTROL   — a plain fetch (no `timeout` option) against the slow relay must die with
  *               TimeoutError: proves this process's idle watchdog is live and would abort
  *               any >idle-timeout forward, i.e. the pre-fix behavior of forward().
- *   REAL PATH — a long `relay_run` `tools/call` through the REAL RelayMcpProxy (whose
+ *   REAL PATH — a long `humwick_run` `tools/call` through the REAL HumwickMcpProxy (whose
  *               forward() sets `timeout:false`) must complete with the usable
  *               `still-running` + `runId` envelope despite sitting silent well past the
  *               compressed idle timeout.
  *
  * Exits 0 and prints LONG-TURN E2E PASS on success; non-zero with diagnostics otherwise.
  */
-import { RelayMcpProxy } from "./relay-mcp-proxy";
+import { HumwickMcpProxy } from "./relay-mcp-proxy";
 
 const WITHHOLD_MS = 6_000;
 const SECRET = "long-turn-e2e-secret";
@@ -69,9 +69,9 @@ const slowRelay = Bun.serve({
       // Keep the intentionally silent response shape even for malformed control input.
     }
     await Bun.sleep(WITHHOLD_MS);
-    if (!request || request.method !== "tools/call" || request.params?.name !== "relay_run") {
+    if (!request || request.method !== "tools/call" || request.params?.name !== "humwick_run") {
       return Response.json(
-        { jsonrpc: "2.0", id, error: { code: -32601, message: "expected relay_run tools/call" } },
+        { jsonrpc: "2.0", id, error: { code: -32601, message: "expected humwick_run tools/call" } },
         { status: 400 },
       );
     }
@@ -85,7 +85,7 @@ const slowRelay = Bun.serve({
       jsonrpc: "2.0",
       id,
       result: {
-        content: [{ type: "text", text: "relay_run still running" }],
+        content: [{ type: "text", text: "humwick_run still running" }],
         structuredContent: {
           run: {
             runId: "long-turn-run-id",
@@ -121,7 +121,7 @@ async function controlPlainFetchMustTimeOut(relayUrl: string): Promise<void> {
 }
 
 async function proxyForwardMustComplete(): Promise<void> {
-  const proxy = new RelayMcpProxy({
+  const proxy = new HumwickMcpProxy({
     relayMcpEndpoint: `http://127.0.0.1:${slowRelay.port}/api/mcp`,
     getToken: () => "long-turn-e2e-live-token",
     authSecret: SECRET,
@@ -132,7 +132,7 @@ async function proxyForwardMustComplete(): Promise<void> {
     const startedAt = Date.now();
     // The agent-facing hop is NOT under test here (in production it does not run under the
     // compressed env), so it also opts out of the watchdog to avoid a false failure; the hop
-    // being verified is forward() inside the proxy, whose fetch carries the #2429 fix.
+    // being verified is forward inside the proxy, whose fetch carries the fix.
     const agentSideInit: RequestInit & { timeout?: number | false } = {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${SECRET}` },
@@ -141,7 +141,7 @@ async function proxyForwardMustComplete(): Promise<void> {
         id: "long-turn-1",
         method: "tools/call",
         params: {
-          name: "relay_run",
+          name: "humwick_run",
           // A real maximum inline window is intentionally longer than this child's compressed
           // watchdog. The stand-in withholds the envelope for 6s, while its unconfigured
           // watchdog dies at ~2-4s, reproducing the pre-fix no-runId failure shape.
@@ -160,13 +160,13 @@ async function proxyForwardMustComplete(): Promise<void> {
     };
     if (!res.ok || !body.result) {
       fail(`proxy forward returned status ${res.status} body ${JSON.stringify(body)} — forward() `
-        + "did not survive the idle watchdog; is the #2429 `timeout:false` flag present?");
+        + "did not survive the idle watchdog; is the `timeout:false` flag present?");
     }
     const run = body.result?.structuredContent?.run;
     if (run?.runId !== "long-turn-run-id" || run.status !== "still-running" || run.exitCode !== null) {
-      fail(`relay_run did not return a usable still-running + runId envelope: ${JSON.stringify(body.result)}`);
+      fail(`humwick_run did not return a usable still-running + runId envelope: ${JSON.stringify(body.result)}`);
     }
-    console.log(`real path: relay_run returned still-running + runId after ${Date.now() - startedAt}ms`);
+    console.log(`real path: humwick_run returned still-running + runId after ${Date.now() - startedAt}ms`);
   } finally {
     proxy.stop();
   }