@dungle-scrubs/harness-cli-normalizer 0.4.4 → 0.4.5

package/src/cli/run.ts

@@ -1,16 +1,72 @@
+import { existsSync } from "node:fs";
 import type { HarnessEvent } from "../execution/events.js";
+import { failureFromRejected } from "../execution/failure.js";
 import { nodeRunnerDeps } from "../execution/node-deps.js";
 import { KILL_GRACE_MS, redactArgv, streamTurn } from "../execution/stream-turn.js";
 import { buildLaunchArgv, buildResumeArgv } from "../interpretation/argv.js";
 import { composeEscalatedPrompt } from "../interpretation/question.js";
+import type { RefusalIssue } from "../interpretation/refusal.js";
 import { ArgvRefusalError } from "../interpretation/refusal.js";
 import { FloorExceededError, resolveEffectiveOptions } from "../interpretation/resolve-options.js";
+import { storePath } from "../interpretation/store.js";
 import { recognizeNativeSpelling, supportedBy } from "../interpretation/support.js";
 import { defaultDescriptors } from "../knowledge/overrides.js";
 import { parseRunExtra, parseTurnOptions, resolvePromptAsync } from "./args.js";
 import { createRenderState, renderEvent, writeEventNdjson } from "./render.js";
 import { resolveHarness } from "./resolve-harness.js";
 
+/** One shape for every hcn-side refusal. Stderr keeps the prose (message,
+ * hint, support lists, usage pointer); under --json the same fields also
+ * ride stdout as a `failure` event plus a `done`, so a stream reader never
+ * meets an empty stream on exit 2. */
+interface Refusal {
+  readonly message: string;
+  readonly issue: RefusalIssue;
+  readonly option?: ArgvRefusalError["option"];
+  readonly facet?: ArgvRefusalError["facet"];
+  readonly supported?: readonly string[];
+  readonly supportedBy?: ArgvRefusalError["supportedBy"];
+  readonly hint?: string;
+  /** Plain stderr lines written after the structured ones. */
+  readonly trailer?: readonly string[];
+}
+
+const refusalOf = (err: ArgvRefusalError): Refusal => ({
+  message: err.message,
+  issue: err.issue,
+  option: err.option,
+  facet: err.facet,
+  supported: err.supported,
+  supportedBy: err.supportedBy,
+  hint: err.hint,
+});
+
+const refuse = (r: Refusal, json: boolean): void => {
+  process.stderr.write(`${r.message}\n`);
+  if (r.hint) process.stderr.write(`hint: ${r.hint}\n`);
+  if (r.supportedBy?.length) {
+    process.stderr.write(
+      `supported on: ${r.supportedBy.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
+    );
+  }
+  if (r.supported?.length) process.stderr.write(`supported: ${r.supported.join(", ")}\n`);
+  for (const line of r.trailer ?? []) process.stderr.write(`${line}\n`);
+  if (json) {
+    const summary = failureFromRejected({
+      issue: r.issue,
+      option: r.option,
+      facet: r.facet,
+      supported: r.supported,
+      supportedBy: r.supportedBy,
+      hint: r.hint,
+      detail: r.message,
+    });
+    writeEventNdjson({ kind: "failure", ...summary });
+    writeEventNdjson({ kind: "done", exitCode: null, cause: "failed", failure: summary });
+  }
+  process.exitCode = 2;
+};
+
 export const run = async (harnessName: string, rawArgs: string[]): Promise<void> => {
   const h = resolveHarness(harnessName);
 
@@ -23,7 +79,10 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
   const { parseCommonFlags, detectPositionalPromptInjection, splitPassthrough } = await import(
     "./args.js"
   );
-  const { passthrough } = splitPassthrough(rawArgs);
+  const { normalized, passthrough } = splitPassthrough(rawArgs);
+  // Decided before any refusal can fire: a refused --json run still owes
+  // the stream a failure and a done.
+  const wantJson = normalized.includes("--json");
   const injection = detectPositionalPromptInjection(rawArgs);
   if (injection) {
     const err = new ArgvRefusalError({
@@ -32,9 +91,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       supported: ["prompt must not start with '-'"],
       detail: `it would be parsed as a flag by ${h.bin}`,
     });
-    process.stderr.write(`${err.message}\n`);
-    process.stderr.write(`supported: prompt must not start with '-'\n`);
-    process.exitCode = 2;
+    refuse(refusalOf(err), wantJson);
     return;
   }
   let parsed: ReturnType<typeof parseCommonFlags>;
@@ -77,19 +134,25 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
           : native.option.startsWith("discovery.")
             ? `--no-${native.option.split(".")[1] === "instructionFiles" ? "instruction-files" : native.option.split(".")[1]}`
             : `--${native.option}`;
-      process.stderr.write(
-        `unknown flag: ${rawFlag} is a native spelling (used by ${native.entries.map((e) => e.harness).join(", ")}) - use the normalized ${normalizedSpelling} flag instead\n`,
+      refuse(
+        {
+          message: `unknown flag: ${rawFlag} is a native spelling (used by ${native.entries.map((e) => e.harness).join(", ")}) - use the normalized ${normalizedSpelling} flag instead`,
+          issue: "invalid-option-value",
+          supportedBy: by,
+          trailer: ["Run 'hcn run --help' for usage."],
+        },
+        wantJson,
       );
-      if (by.length > 0) {
-        process.stderr.write(
-          `supported on: ${by.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
-        );
-      }
-    } else {
-      process.stderr.write(`unknown flag: ${message}\n`);
+      return;
     }
-    process.stderr.write(`Run 'hcn run --help' for usage.\n`);
-    process.exitCode = 2;
+    refuse(
+      {
+        message: `unknown flag: ${message}`,
+        issue: "invalid-option-value",
+        trailer: ["Run 'hcn run --help' for usage."],
+      },
+      wantJson,
+    );
     return;
   }
 
@@ -98,18 +161,26 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
   // positionals may contain prompt if not using flag; harness already consumed so first positional is prompt
   const positionalPrompt = positionals.length > 0 ? positionals[0] : undefined;
   if (positionals.length > 1) {
-    process.stderr.write(`too many positionals for run; expected one prompt\n`);
-    process.exitCode = 2;
+    refuse(
+      {
+        message: "too many positionals for run; expected one prompt",
+        issue: "invalid-option-value",
+      },
+      wantJson,
+    );
     return;
   }
   if (passthrough.length === 0 && rawArgs.includes("--")) {
-    process.stderr.write(`-- separator given but no passthrough tokens followed it\n`);
-    process.exitCode = 2;
+    refuse(
+      {
+        message: "-- separator given but no passthrough tokens followed it",
+        issue: "invalid-option-value",
+      },
+      wantJson,
+    );
     return;
   }
 
-  const wantJson = values.json === true;
-
   // Resolve prompt (async for --prompt-file -)
   let prompt: string;
   let promptSource: string;
@@ -123,20 +194,14 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     promptSource = resolved.source;
   } catch (err) {
     if (err instanceof ArgvRefusalError) {
-      process.stderr.write(`${err.message}\n`);
-      if (err.hint) process.stderr.write(`hint: ${err.hint}\n`);
-      if (err.supportedBy?.length) {
-        process.stderr.write(
-          `supported on: ${err.supportedBy.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
-        );
-      }
-      if (err.supported.length) process.stderr.write(`supported: ${err.supported.join(", ")}\n`);
-      process.exitCode = 2;
+      refuse(refusalOf(err), wantJson);
       return;
     }
     if (err instanceof Error && (err as NodeJS.ErrnoException).code === "ENOENT") {
-      process.stderr.write(`prompt file not found: ${(err as Error).message}\n`);
-      process.exitCode = 2;
+      refuse(
+        { message: `prompt file not found: ${err.message}`, issue: "invalid-option-value" },
+        wantJson,
+      );
       return;
     }
     throw err;
@@ -148,15 +213,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     turnOpts = parseTurnOptions(values);
   } catch (err) {
     if (err instanceof ArgvRefusalError) {
-      process.stderr.write(`${err.message}\n`);
-      if (err.hint) process.stderr.write(`hint: ${err.hint}\n`);
-      if (err.supportedBy?.length) {
-        process.stderr.write(
-          `supported on: ${err.supportedBy.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
-        );
-      }
-      if (err.supported.length) process.stderr.write(`supported: ${err.supported.join(", ")}\n`);
-      process.exitCode = 2;
+      refuse(refusalOf(err), wantJson);
       return;
     }
     throw err;
@@ -167,15 +224,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     extra = parseRunExtra(values);
   } catch (err) {
     if (err instanceof ArgvRefusalError) {
-      process.stderr.write(`${err.message}\n`);
-      if (err.hint) process.stderr.write(`hint: ${err.hint}\n`);
-      if (err.supportedBy?.length) {
-        process.stderr.write(
-          `supported on: ${err.supportedBy.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
-        );
-      }
-      if (err.supported.length) process.stderr.write(`supported: ${err.supported.join(", ")}\n`);
-      process.exitCode = 2;
+      refuse(refusalOf(err), wantJson);
       return;
     }
     throw err;
@@ -199,9 +248,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       (turnOpts as unknown as Record<string, unknown>).__claudeSkillTokens = claudeTokens;
     } catch (err) {
       if (err instanceof ArgvRefusalError) {
-        process.stderr.write(`${err.message}\n`);
-        if (err.supported.length) process.stderr.write(`supported: ${err.supported.join(", ")}\n`);
-        process.exitCode = 2;
+        refuse(refusalOf(err), wantJson);
         return;
       }
       throw err;
@@ -230,8 +277,10 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       if (proj !== null) tiers.project = proj.config;
     } catch (configErr) {
       if (configErr instanceof ConfigError) {
-        process.stderr.write(`config error: ${(configErr as Error).message}\n`);
-        process.exitCode = 2;
+        refuse(
+          { message: `config error: ${configErr.message}`, issue: "invalid-option-value" },
+          wantJson,
+        );
         return;
       }
       throw configErr;
@@ -243,8 +292,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       resolved = resolveEffectiveOptions(h, { ...turnOpts, prompt } as never, tiers);
     } catch (resErr) {
       if (resErr instanceof FloorExceededError) {
-        process.stderr.write(`${(resErr as Error).message}\n`);
-        process.exitCode = 2;
+        refuse({ message: resErr.message, issue: "invalid-tool-grant" }, wantJson);
         return;
       }
       throw resErr;
@@ -265,6 +313,18 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
           `divergence: profile ${JSON.stringify(key)} not expressible on ${h.name}; harness default applies\n`,
         );
       }
+      // issue #48 (ratified): when claude's instruction-files isolation
+      // rides (the --setting-sources project spelling), surface its known
+      // cost as a divergence line - legal to use, priced in stderr.
+      if (
+        h.name === "claude" &&
+        (resolved.options as { discovery?: { instructionFiles?: boolean } }).discovery
+          ?.instructionFiles === false
+      ) {
+        process.stderr.write(
+          "divergence: setting-sources isolation also skips hooks, LSP and keychain reads on claude - weighed, not refused\n",
+        );
+      }
     }
   }
 
@@ -342,15 +402,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     _validated = true;
   } catch (err) {
     if (err instanceof ArgvRefusalError) {
-      process.stderr.write(`${err.message}\n`);
-      if (err.hint) process.stderr.write(`hint: ${err.hint}\n`);
-      if (err.supportedBy?.length) {
-        process.stderr.write(
-          `supported on: ${err.supportedBy.map((e) => `${e.harness} (${e.spelling})`).join(", ")}\n`,
-        );
-      }
-      if (err.supported.length) process.stderr.write(`supported: ${err.supported.join(", ")}\n`);
-      process.exitCode = 2;
+      refuse(refusalOf(err), wantJson);
       return;
     }
     throw err;
@@ -372,6 +424,51 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     process.stderr.write(
       `provenance: escalateQuestions = ${escalateQuestions} (${escalateTier})\n`,
     );
+    // On a harness whose include flag is not a strict allowlist (claude),
+    // a name outside the curated set passes through ungated; say which
+    // ones so a wrong-case name is visible. A grant with no known name at
+    // all refuses inside buildLaunchArgv below, so a throw here is left
+    // to that path.
+    const grant = (fullOpts.resume ? turnOpts : effectiveTurnOpts).tools;
+    if (grant !== undefined && grant.length > 0 && !h.tools.includeIsStrictAllowlist) {
+      try {
+        const { renderToolSelection } = await import("../interpretation/tool-selection.js");
+        const { unmapped } = renderToolSelection(h, { include: [...grant] });
+        if (unmapped.length > 0) {
+          process.stderr.write(`provenance: unmapped tools = ${JSON.stringify(unmapped)}\n`);
+        }
+      } catch {
+        // refused below with the structured message
+      }
+    }
+  }
+
+  // A harness that creates a session when the id is unknown (pi, muse)
+  // would turn a stale --resume into a silent blank session. Refuse when
+  // the session store path does not exist; where the path cannot be
+  // computed, the runner's pre-spawn warning is the only guard.
+  if (fullOpts.resume !== undefined && h.resume.onMissing === "create") {
+    let path: string | null = null;
+    try {
+      path = storePath(h, {
+        home: process.env.HOME ?? process.env.USERPROFILE ?? "",
+        cwd: extra.cwd ?? process.cwd(),
+        sessionId: fullOpts.resume,
+      });
+    } catch {
+      path = null;
+    }
+    if (path !== null && !existsSync(path)) {
+      refuse(
+        {
+          message: `no ${h.name} session ${fullOpts.resume} found at ${path}`,
+          issue: "invalid-option-value",
+          supported: [`a session id that exists in ${h.name}'s store`],
+        },
+        wantJson,
+      );
+      return;
+    }
   }
 
   // Delete HERDR_ENV before spawn
@@ -410,10 +507,12 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     },
   };
 
+  const abortController = new AbortController();
   let interrupted = false;
   const onSig = async () => {
     if (interrupted) return;
     interrupted = true;
+    abortController.abort();
     if (lastProc) {
       try {
         wrappedDeps.signal(lastProc, "SIGTERM");
@@ -439,7 +538,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
 
   try {
     // streamTurn handles both launch and resume via TurnRunOptions
-    const events = streamTurn(h, fullOpts, wrappedDeps);
+    const events = streamTurn(h, { ...fullOpts, signal: abortController.signal }, wrappedDeps);
     for await (const event of events) {
       lastEvent = event;
       if (wantJson) {

package/src/execution/decode.ts

@@ -4,12 +4,13 @@
  * caller threads (identity dedupe per D-022). Unparseable lines on a
  * structured stream are tolerated - scanned for walls, never fatal.
  */
-import { capabilitiesOf } from "../interpretation/capabilities.js";
+import { type CapabilityResult, capabilitiesOf } from "../interpretation/capabilities.js";
 import { contentEventsOf } from "../interpretation/content.js";
 import { decodeIdentity } from "../interpretation/identity.js";
 import { detectLimitInLine } from "../interpretation/limits.js";
-import type { HarnessDescriptor } from "../knowledge/descriptor.js";
+import type { HarnessDescriptor, StreamingGranularity } from "../knowledge/descriptor.js";
 import type { HarnessEvent } from "./events.js";
+import { failureFromBudget } from "./failure.js";
 
 export interface DecodeState {
   lastSeenId: string | null;
@@ -30,6 +31,7 @@ export const decodeLine = (
   line: string,
   state: DecodeState,
   model: string,
+  streaming?: StreamingGranularity,
 ): HarnessEvent[] => {
   let raw: unknown;
   try {
@@ -43,7 +45,7 @@ export const decodeLine = (
     }
     return [];
   }
-  return decodeParsed(h, raw, state, model);
+  return decodeParsed(h, raw, state, model, streaming);
 };
 
 /** The parsed-record half of decodeLine, for pumps that already parsed the
@@ -54,8 +56,16 @@ export const decodeParsed = (
   raw: unknown,
   state: DecodeState,
   model: string,
+  streaming?: StreamingGranularity,
 ): HarnessEvent[] => {
   const events: HarnessEvent[] = [];
+  // Streaming is a property of the spawned argv, not of the model, so the
+  // runner passes what streamingGranularityOf computed for it; the curated
+  // baseline supplies the rest. An unknown model stays unknown throughout.
+  const capabilities = (): CapabilityResult => {
+    const base = capabilitiesOf(h, model, "headless-turn");
+    return streaming !== undefined && base.source !== "unknown" ? { ...base, streaming } : base;
+  };
   const decoded = decodeIdentity(h, raw, state.lastSeenId, state.requestedId);
   if (decoded.sessionId !== null) state.lastSeenId = decoded.sessionId;
   if (decoded.identity !== null) {
@@ -63,18 +73,41 @@ export const decodeParsed = (
       kind: "identity",
       sessionId: decoded.identity,
       authority: h.identity.authority,
-      capabilities: capabilitiesOf(h, model, "headless-turn"),
+      capabilities: capabilities(),
     });
   } else if (decoded.outcome === "malformed" || decoded.outcome === "rotated") {
-    // The interpretation layer classified an identity anomaly; swallowing
-    // it would leave the runner waiting for an identity that already
-    // failed to arrive (or bind a rotated one).
-    events.push({ kind: "error", message: `identity ${decoded.outcome}` });
+    if (decoded.outcome === "rotated") {
+      const requested = state.requestedId ?? "unknown";
+      const announced = decoded.sessionId ?? "unknown";
+      events.push({
+        kind: "error",
+        message: `identity rotated: requested ${requested} but announced ${announced}`,
+      });
+      // The harness answered under a different id: hand the consumer the
+      // id it can actually resume, marked as minted by the harness.
+      if (decoded.sessionId !== null) {
+        events.push({
+          kind: "identity",
+          sessionId: decoded.sessionId,
+          authority: "harness-minted",
+          capabilities: capabilities(),
+        });
+      }
+    } else {
+      events.push({ kind: "error", message: `identity ${decoded.outcome}` });
+    }
   }
 
-  // Content (message/token/tool/error) is per-harness; identity above is
-  // descriptor-driven. contentEventsOf dispatches by harness name.
-  for (const content of contentEventsOf(h.name, raw)) events.push(content);
+  // Content (message/token/tool/error/budget) is per-harness; identity
+  // above is descriptor-driven. contentEventsOf dispatches by harness
+  // name. budget is not a HarnessEvent kind and must not leak out.
+  for (const content of contentEventsOf(h.name, raw)) {
+    if (content.kind === "budget") {
+      events.push({ kind: "failure", ...failureFromBudget(content.detail) });
+    } else {
+      events.push(content);
+    }
+  }
 
   // claude's rate_limit_event: only non-"allowed" statuses are failures.
   // overageStatus is deliberately not classified - it is a separate

package/src/execution/deps.ts

@@ -16,6 +16,9 @@ export interface SpawnedProcess {
   /** Resolves with the exit code, or null when the process died to a
    * signal without one. */
   readonly exited: Promise<number | null>;
+  /** After `exited` settles, the spawn-time error message when the child
+   * never started (async ENOENT and the like), else null. */
+  readonly startupError?: () => string | null;
   /** Present when the spawner opened a writable stdin (session mode needs
    * it; one-shot turns close or inherit stdin instead). */
   readonly stdin?: {

package/src/execution/events.ts

@@ -15,6 +15,7 @@
  * concatenate both.
  */
 import type { CapabilityResult } from "../interpretation/capabilities.js";
+import type { LimitCode } from "../knowledge/descriptor.js";
 import type { FailureSummary } from "./failure.js";
 
 export type ExitCause =
@@ -49,8 +50,10 @@ export type HarnessEvent =
       readonly options: readonly string[];
       readonly recommended?: string;
     }
-  | { readonly kind: "limit"; readonly code: string; readonly message: string }
-  | { readonly kind: "error"; readonly message: string }
+  | { readonly kind: "limit"; readonly code: LimitCode; readonly message: string }
+  /** `terminal: true` marks an error that ended the turn; the matching
+   * `failure` (class task) follows it. */
+  | { readonly kind: "error"; readonly message: string; readonly terminal?: boolean }
   | ({ readonly kind: "failure" } & FailureSummary)
   | {
       readonly kind: "done";

package/src/execution/node-deps.ts

@@ -157,6 +157,7 @@ const realSpawn = (argv: readonly string[], opts: SpawnOptions): SpawnedProcess
     stdout: stdoutOutput === null ? emptyStream() : stdoutOutput.stream,
     stderr: stderrWithError(),
     exited,
+    startupError: () => spawnError?.message ?? null,
     disposeOutput: (): void => {
       if (outputDisposed) return;
       outputDisposed = true;

package/src/execution/open-session.ts

@@ -27,6 +27,8 @@ import { AsyncChannel } from "./channel.js";
 import { decodeParsed, freshDecodeState } from "./decode.js";
 import type { RunnerDeps, SpawnedProcess } from "./deps.js";
 import type { ExitCause, HarnessEvent } from "./events.js";
+import type { FailureSummary } from "./failure.js";
+import { failureFromAuth, failureFromLimit, reduceFailures } from "./failure.js";
 import { LineBuffer } from "./lines.js";
 import { KILL_GRACE_MS, PIPE_GRACE_MS, redactArgv, StderrTail } from "./stream-turn.js";
 
@@ -145,6 +147,7 @@ export const openSession = (
   let exitCode: number | null = null;
   let resultError = false;
   let turnLimitSeen = false;
+  let turnFailures: FailureSummary[] = [];
   let pumpError: unknown = null;
   // issue #44: the active turn's last assistant message (where the
   // hcn-question block lives) and whether the turn ended by asking.
@@ -175,14 +178,24 @@ export const openSession = (
     }
   };
 
+  /** A decoded failure event minus its kind: what done.failure carries. */
+  const summaryOf = (event: HarnessEvent & { kind: "failure" }): FailureSummary => {
+    const { kind: _kind, ...summary } = event;
+    return summary;
+  };
+
   const startTurn = (): void => {
     turnLimitSeen = false;
+    turnFailures = [];
     turnAsked = false;
     lastAssistantText = null;
     activeTurn = new AsyncChannel<HarnessEvent>();
     activeTurnId = `${opts.sessionId}:turn-${++turnCounter}`;
     log({ event: "turn_start", sessionId: opts.sessionId, turnId: activeTurnId });
-    for (const held of preTurnEvents.splice(0)) activeTurn.push(held);
+    for (const held of preTurnEvents.splice(0)) {
+      if (held.kind === "failure") turnFailures.push(summaryOf(held));
+      activeTurn.push(held);
+    }
     turnsChannel.push(activeTurn);
   };
 
@@ -224,6 +237,10 @@ export const openSession = (
     // in sessions) and the caller answers with the next send().
     emitQuestionIfAsked();
     if (turnAsked && done.cause === "clean") done = { ...done, cause: "awaiting-input" };
+    // Every failure was already emitted as an event through pushFailure;
+    // the turn's done carries the reduced summary, as streamTurn's does.
+    const reduced = reduceFailures(turnFailures);
+    if (reduced !== undefined) done = { ...done, failure: reduced };
     activeTurn.push(done);
     activeTurn.close();
     log({
@@ -265,6 +282,11 @@ export const openSession = (
     return Promise.resolve();
   };
 
+  const pushFailure = (f: FailureSummary): Promise<void> => {
+    turnFailures.push(f);
+    return routeEvent({ kind: "failure", ...f });
+  };
+
   const pumpStdout = async (): Promise<void> => {
     const lines = new LineBuffer();
     const matches = (
@@ -297,6 +319,7 @@ export const openSession = (
         const code = detectLimitInLine(h, line);
         if (code !== null) {
           await routeEvent({ kind: "limit", code, message: `limit wall detected (${code})` });
+          await pushFailure(failureFromLimit(code));
         }
         return;
       }
@@ -367,7 +390,10 @@ export const openSession = (
         // decodeParsed already surfaces the is_error case as an error event
         // (content.ts claude reader); routing the events is enough - we only
         // still track resultError here to classify the done cause.
-        for (const event of events) await routeEvent(event);
+        for (const event of events) {
+          if (event.kind === "failure") await pushFailure(summaryOf(event));
+          else await routeEvent(event);
+        }
         if (parsed.is_error === true) resultError = true;
         endTurn({
           kind: "done",
@@ -376,7 +402,10 @@ export const openSession = (
         });
         return;
       }
-      for (const event of events) await routeEvent(event);
+      for (const event of events) {
+        if (event.kind === "failure") await pushFailure(summaryOf(event));
+        else await routeEvent(event);
+      }
     };
     for await (const chunk of proc.stdout) {
       for (const line of lines.push(chunk)) await handleLine(line);
@@ -396,10 +425,12 @@ export const openSession = (
             code: limit,
             message: `limit wall detected (${limit})`,
           });
+          await pushFailure(failureFromLimit(limit));
           continue;
         }
         const auth = detectAuthFailureInLine(h, line);
         if (auth !== null) {
+          await pushFailure(failureFromAuth(auth));
           await routeEvent({ kind: "error", message: `auth wall: ${auth}` });
           continue;
         }