@dungle-scrubs/harness-cli-normalizer 0.4.1 → 0.4.3

package/src/cli/run.ts

@@ -2,12 +2,9 @@ import type { HarnessEvent } from "../execution/events.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 { ArgvRefusalError } from "../interpretation/refusal.js";
-import {
-  FloorExceededError,
-  type ProvenanceEntry,
-  resolveEffectiveOptions,
-} from "../interpretation/resolve-options.js";
+import { FloorExceededError, resolveEffectiveOptions } from "../interpretation/resolve-options.js";
 import { recognizeNativeSpelling, supportedBy } from "../interpretation/support.js";
 import { defaultDescriptors } from "../knowledge/overrides.js";
 import { parseRunExtra, parseTurnOptions, resolvePromptAsync } from "./args.js";
@@ -213,15 +210,18 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
 
   // Defaults profile + user config: LAUNCH-ONLY. A resumed session keeps
   // its own settings; the resolver never runs on resume paths.
-  let resolvedProvenance: readonly ProvenanceEntry[] = [];
-  let resolvedUnrenderable: readonly string[] = [];
   let effectiveTurnOpts: ReturnType<typeof parseTurnOptions> = turnOpts;
   const resolvedTiers: {
     user?: Partial<ReturnType<typeof parseTurnOptions>>;
     project?: Partial<ReturnType<typeof parseTurnOptions>>;
   } = {};
-  if (extra.resume === undefined) {
-    const tiers = resolvedTiers;
+  // Config files load on EVERY run, launch or resume: the tiers feed the
+  // defaults profile on launch, and issue #41's escalateQuestions (a
+  // behavior instruction, not a turn option) resolves from them on resume
+  // too - otherwise a no-escalate session would flip its preamble on the
+  // answer turn. Resolution of TURN options stays launch-only.
+  const tiers = resolvedTiers;
+  {
     const { loadUserConfig, loadProjectConfig, ConfigError } = await import("./config.js");
     try {
       const loaded = loadUserConfig();
@@ -236,6 +236,8 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       }
       throw configErr;
     }
+  }
+  if (extra.resume === undefined) {
     let resolved: ReturnType<typeof resolveEffectiveOptions>;
     try {
       resolved = resolveEffectiveOptions(h, { ...turnOpts, prompt } as never, tiers);
@@ -248,8 +250,6 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
       throw resErr;
     }
     const { provenance, unrenderable } = resolved;
-    resolvedProvenance = provenance;
-    resolvedUnrenderable = unrenderable;
     const { prompt: _p, ...rest } = resolved.options as { prompt: string };
     effectiveTurnOpts = rest as ReturnType<typeof parseTurnOptions>;
     // Provenance is diagnostic data like the spawn line - stderr in BOTH
@@ -268,12 +268,39 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
     }
   }
 
+  // issue #41: question-escalation precedence arg > project > user >
+  // default-true (a behavior instruction, not a turn option - the
+  // default lives OUTSIDE the profile on purpose, per the spec). It
+  // applies on LAUNCH AND RESUME alike: it shapes each turn's prompt
+  // preamble and event stream, never a session setting.
+  const projectEscalate = (resolvedTiers.project as { escalateQuestions?: boolean } | undefined)
+    ?.escalateQuestions;
+  const userEscalate = (resolvedTiers.user as { escalateQuestions?: boolean } | undefined)
+    ?.escalateQuestions;
+  const escalateQuestions =
+    turnOpts.escalateQuestions !== undefined
+      ? turnOpts.escalateQuestions
+      : projectEscalate !== undefined
+        ? projectEscalate
+        : userEscalate !== undefined
+          ? userEscalate
+          : true;
+  const escalateTier =
+    turnOpts.escalateQuestions !== undefined
+      ? "arg"
+      : projectEscalate !== undefined
+        ? "project-config"
+        : userEscalate !== undefined
+          ? "user-config"
+          : "default";
+
   const fullOpts = {
     ...effectiveTurnOpts,
-    prompt,
+    prompt: composeEscalatedPrompt(prompt, escalateQuestions),
     cwd: extra.cwd,
     env: extra.env,
     resume: extra.resume,
+    escalateQuestions,
     ...(passthrough.length > 0 ? { passthrough } : {}),
     ...(isExplicit ? { __explicitPrompt: true as const } : {}),
   } as Parameters<typeof streamTurn>[1] & {
@@ -287,20 +314,23 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
   let preArgv: string[] | null = null;
   try {
     if (fullOpts.resume) {
-      // Resume never carries profile/config resolution (launch-only rule),
-      // so it builds from the raw turn options.
+      // Resume never carries TURN-option profile resolution (launch-only
+      // rule), so it builds from the raw turn options; hcn-owned behavior
+      // (escalateQuestions preamble, timeout budget) still applies.
       preArgv = buildResumeArgv(h, {
         ...(turnOpts as object),
-        prompt,
+        prompt: fullOpts.prompt,
         sessionId: fullOpts.resume,
         __explicitPrompt: isExplicit,
       } as never);
     } else {
       // Launch builds from the RESOLVED options so the spawn line and the
-      // real argv agree.
+      // real argv agree. The prompt here is the COMPOSED one (escalation
+      // preamble included) - redactArgv masks by position, so an argv
+      // built from the raw prompt would leak it into the spawn line.
       preArgv = buildLaunchArgv(h, {
         ...(effectiveTurnOpts as object),
-        prompt,
+        prompt: fullOpts.prompt,
         __explicitPrompt: isExplicit,
       } as never);
       const claudeSkillTokens = (effectiveTurnOpts as unknown as { __claudeSkillTokens?: string[] })
@@ -330,13 +360,18 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
   // since buildLaunchArgv now respects __explicitPrompt.
 
   if (preArgv) {
-    const redacted = redactArgv(preArgv, prompt);
+    const redacted = redactArgv(preArgv, fullOpts.prompt);
     if (!wantJson) {
       process.stderr.write(`spawn: ${redacted.join(" ")}\n`);
     } else {
       // In JSON mode, diagnostics to stderr only
       process.stderr.write(`spawn: ${redacted.join(" ")}\n`);
     }
+    // issue #41: the escalation mode rides stderr as provenance, like
+    // every other resolution the turn depends on.
+    process.stderr.write(
+      `provenance: escalateQuestions = ${escalateQuestions} (${escalateTier})\n`,
+    );
   }
 
   // Delete HERDR_ENV before spawn
@@ -413,7 +448,7 @@ export const run = async (harnessName: string, rawArgs: string[]): Promise<void>
         renderEvent(event, state);
       }
       if (event.kind === "done") {
-        if (event.cause === "clean") exitCode = 0;
+        if (event.cause === "clean" || event.cause === "awaiting-input") exitCode = 0;
         else exitCode = 1;
         // If failure class is rejected? But done.cause for rejected would be failed? Still 1 per mapping, but refusal before spawn is 2.
         // The RFC says limit/auth ->1, transport ->1, refusal ->2 (already handled). So done non-clean =>1.

package/src/cli/session.ts

@@ -7,22 +7,27 @@ import { createRenderState, renderEvent } from "./render.js";
 import { resolveHarness } from "./resolve-harness.js";
 
 export const session = async (harnessName: string, rawArgs: string[]): Promise<void> => {
-  // Only claude supported
-  if (harnessName !== "claude") {
+  // issue #44: the gate is the descriptor's sessionMode (claude stream-json,
+  // pi --mode rpc), not a hardcoded name list - a harness that grows a
+  // session mode is available the moment its descriptor declares one.
+  const h = resolveHarness(harnessName);
+  if (h.sessionMode === null) {
+    const supported = ["claude", "codex", "pi", "muse"]
+      .map((name) => resolveHarness(name))
+      .filter((d) => d.sessionMode !== null)
+      .map((d) => d.name);
     const err = new ArgvRefusalError({
       issue: "no-session-mode",
       harness: harnessName as "claude",
-      supported: ["claude"],
-      detail: `session is claude-only; ${harnessName} declares no persistent headless session mode`,
+      supported,
+      detail: `session mode is available on ${supported.join(", ")}; ${harnessName} declares no persistent headless session`,
     });
     process.stderr.write(`${err.message}\n`);
-    process.stderr.write(`supported: claude\n`);
+    process.stderr.write(`supported: ${supported.join(", ")}\n`);
     process.exitCode = 2;
     return;
   }
 
-  const h = resolveHarness(harnessName);
-
   if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
     const { SESSION_HELP } = await import("./help.js");
     process.stdout.write(SESSION_HELP);
@@ -48,6 +53,44 @@ export const session = async (harnessName: string, rawArgs: string[]): Promise<v
   const model = values.model as string | undefined;
   const cwd = values.cwd as string | undefined;
 
+  // issue #44: same precedence as hcn run - arg > project > user >
+  // default-true. A behavior instruction, so it rides every send's
+  // preamble, never a harness flag.
+  const argEscalate =
+    values["escalate-questions"] === true
+      ? true
+      : values["no-escalate-questions"] === true
+        ? false
+        : undefined;
+  let escalateQuestions: boolean;
+  let escalateTier: "arg" | "project-config" | "user-config" | "default";
+  try {
+    const { loadUserConfig, loadProjectConfig } = await import("./config.js");
+    const user = loadUserConfig()?.config as { escalateQuestions?: boolean } | undefined;
+    const project = loadProjectConfig()?.config as { escalateQuestions?: boolean } | undefined;
+    escalateQuestions =
+      argEscalate !== undefined
+        ? argEscalate
+        : project?.escalateQuestions !== undefined
+          ? project.escalateQuestions
+          : user?.escalateQuestions !== undefined
+            ? user.escalateQuestions
+            : true;
+    escalateTier =
+      argEscalate !== undefined
+        ? "arg"
+        : project?.escalateQuestions !== undefined
+          ? "project-config"
+          : user?.escalateQuestions !== undefined
+            ? "user-config"
+            : "default";
+  } catch (configErr) {
+    process.stderr.write(`config error: ${(configErr as Error).message}\n`);
+    process.exitCode = 2;
+    return;
+  }
+  process.stderr.write(`provenance: escalateQuestions = ${escalateQuestions} (${escalateTier})\n`);
+
   // Validate sessionId shape? let openSession handle via assertUsableSessionId
   delete (process.env as Record<string, string | undefined>).HERDR_ENV;
 
@@ -55,7 +98,7 @@ export const session = async (harnessName: string, rawArgs: string[]): Promise<v
 
   let handle: ReturnType<typeof openSession>;
   try {
-    handle = openSession(h, { sessionId, model, cwd }, deps);
+    handle = openSession(h, { sessionId, model, cwd, escalateQuestions }, deps);
   } catch (err) {
     if (err instanceof ArgvRefusalError) {
       process.stderr.write(`${err.message}\n`);
@@ -76,6 +119,20 @@ export const session = async (harnessName: string, rawArgs: string[]): Promise<v
 
   const rl = createInterface({ input: process.stdin, output: process.stdout });
 
+  // One line source for BOTH the you-prompt and the answer menu. A
+  // readline interface buffers at most one pending line per question()
+  // call site; the answer line typically arrives while the interface sits
+  // BETWEEN calls (the turn is still streaming), and those bytes were
+  // dropped (verified live: menu rendered, buffered "2" never delivered).
+  // An explicit async-iterator pull never drops: the iterator parks on the
+  // stream until the next line exists, whenever the caller asks for it.
+  const lines = rl[Symbol.asyncIterator]();
+  const nextLine = async (prompt: string): Promise<string | null> => {
+    process.stdout.write(prompt);
+    const res = await lines.next();
+    return res.done ? null : (res.value as string);
+  };
+
   // Handle SIGINT to close session cleanly
   let closing = false;
   const doClose = async () => {
@@ -99,13 +156,14 @@ export const session = async (harnessName: string, rawArgs: string[]): Promise<v
   const turns = handle.turns[Symbol.asyncIterator]();
   try {
     while (true) {
-      let line: string;
+      let line: string | null;
       try {
-        line = await rl.question("you › ");
+        line = await nextLine("you › ");
       } catch {
-        // readline closed (Ctrl-D)
+        // stdin closed (Ctrl-D)
         break;
       }
+      if (line === null) break;
       const trimmed = line.trim();
       if (trimmed === "" || trimmed === "exit") break;
 
@@ -119,8 +177,52 @@ export const session = async (harnessName: string, rawArgs: string[]): Promise<v
         | undefined;
       if (turn === undefined) break;
       const state = createRenderState();
+      // issue #44: a turn that ends awaiting-input renders its question as
+      // a pickable menu; the choice (or a custom answer) is the next send,
+      // delivered on the SAME live session - no exit, no resume.
+      let asked:
+        | (import("../execution/events.js").HarnessEvent & {
+            kind: "question";
+          })
+        | null = null;
       for await (const event of turn) {
         renderEvent(event, state);
+        if (event.kind === "question") asked = event;
+      }
+      if (asked !== null) {
+        const q = asked;
+        process.stdout.write(`\nanswer › pick a number, or type your own answer:\n`);
+        for (let i = 0; i < q.options.length; i++) {
+          const opt = q.options[i] as string;
+          const mark = opt === q.recommended ? " (recommended)" : "";
+          process.stdout.write(`  ${i + 1}. ${opt}${mark}\n`);
+        }
+        let answer: string | null = null;
+        while (answer === null) {
+          const a = ((await nextLine("> ")) ?? "").trim();
+          if (a === "") continue;
+          const n = Number(a);
+          if (Number.isInteger(n) && n >= 1 && n <= q.options.length) {
+            answer = q.options[n - 1] as string;
+          } else {
+            answer = a;
+          }
+        }
+        handle.send(
+          `The user answered the question: "${q.question}" with: ${answer}. Continue accordingly.`,
+        );
+        // Drain the answer turn BEFORE prompting again - the pump's
+        // backpressure stalls the harness until the turn iterable is
+        // consumed (verified live: menu answered, you-prompt rendered, no
+        // answer turn ever ran).
+        const answerTurn = (await turns.next()).value as
+          | AsyncIterable<import("../execution/events.js").HarnessEvent>
+          | undefined;
+        if (answerTurn === undefined) break;
+        const answerState = createRenderState();
+        for await (const event of answerTurn) {
+          renderEvent(event, answerState);
+        }
       }
     }
   } catch (err) {

package/src/execution/events.ts

@@ -17,7 +17,16 @@
 import type { CapabilityResult } from "../interpretation/capabilities.js";
 import type { FailureSummary } from "./failure.js";
 
-export type ExitCause = "clean" | "limit" | "crash" | "stall" | "killed" | "failed";
+export type ExitCause =
+  | "clean"
+  | "limit"
+  | "crash"
+  | "stall"
+  | "killed"
+  | "failed"
+  /** issue #41: the turn ended by asking (escalateQuestions) - a
+   * SUCCESSFUL turn (process exit 0); the caller resumes with the answer. */
+  | "awaiting-input";
 
 export type HarnessEvent =
   | {
@@ -31,6 +40,15 @@ export type HarnessEvent =
   | { readonly kind: "progress"; readonly label: string }
   | { readonly kind: "tool"; readonly name: string; readonly input?: unknown }
   | { readonly kind: "context"; readonly usedPct: number }
+  | {
+      /** issue #41: the worker asked the caller's user a question (the
+       * final message carried an hcn-question block). Structured-first:
+       * these fields ARE the question; prose renders from them. */
+      readonly kind: "question";
+      readonly question: string;
+      readonly options: readonly string[];
+      readonly recommended?: string;
+    }
   | { readonly kind: "limit"; readonly code: string; readonly message: string }
   | { readonly kind: "error"; readonly message: string }
   | ({ readonly kind: "failure" } & FailureSummary)

package/src/execution/failure.ts

@@ -14,12 +14,7 @@
  */
 
 import type { RefusalIssue } from "../interpretation/refusal.js";
-import type {
-  AuthFailureKind,
-  DiscoveryFacet,
-  LimitCode,
-  TurnOptionKey,
-} from "../knowledge/descriptor.js";
+import type { AuthFailureKind, DiscoveryFacet, LimitCode } from "../knowledge/descriptor.js";
 
 export const FAILURE_CLASSES = Object.freeze([
   "rate-limit",

package/src/execution/open-session.ts

@@ -14,7 +14,9 @@
  * sessionId + turnId correlation.
  */
 import { buildSessionArgv } from "../interpretation/argv.js";
+import { capabilitiesOf } from "../interpretation/capabilities.js";
 import { detectAuthFailureInLine, detectLimitInLine } from "../interpretation/limits.js";
+import { composeEscalatedPrompt, detectQuestionBlock } from "../interpretation/question.js";
 import {
   encodeSessionInput,
   resolveSessionInput,
@@ -52,6 +54,11 @@ export interface OpenSessionOptions {
   readonly model?: string;
   /** Working directory for the spawned harness. */
   readonly cwd?: string;
+  /** issue #44: question escalation in session mode (behavior
+   * instruction, default true). True composes the session preamble onto
+   * every send and arms block detection at turn end; false composes the
+   * no-ask instruction and disarms detection. */
+  readonly escalateQuestions?: boolean;
 }
 
 export class SessionClosedError extends Error {
@@ -124,6 +131,8 @@ export const openSession = (
 
   const turnsChannel = new AsyncChannel<AsyncIterable<HarnessEvent>>();
   const state = freshDecodeState(opts.sessionId);
+  const escalateQuestions = opts.escalateQuestions !== false;
+  const sessionInputMode = h.sessionMode;
   const stderrTail = new StderrTail();
   let turnCounter = 0;
   let activeTurn: AsyncChannel<HarnessEvent> | null = null;
@@ -137,6 +146,11 @@ export const openSession = (
   let resultError = false;
   let turnLimitSeen = false;
   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.
+  let lastAssistantText: string | null = null;
+  let turnAsked = false;
+  let identityAnnounced = false;
 
   const safeSignal = (sig: "SIGTERM" | "SIGKILL"): void => {
     if (!dead) deps.signal(proc, sig);
@@ -148,7 +162,12 @@ export const openSession = (
 
   const writeUser = (text: string): boolean => {
     try {
-      stdin.write(encodeSessionInput(sessionInput, text));
+      stdin.write(
+        encodeSessionInput(
+          sessionInput,
+          composeEscalatedPrompt(text, escalateQuestions, "session"),
+        ),
+      );
       return true;
     } catch {
       activeTurn?.push({ kind: "error", message: "send failed: session stdin is gone" });
@@ -158,6 +177,8 @@ export const openSession = (
 
   const startTurn = (): void => {
     turnLimitSeen = false;
+    turnAsked = false;
+    lastAssistantText = null;
     activeTurn = new AsyncChannel<HarnessEvent>();
     activeTurnId = `${opts.sessionId}:turn-${++turnCounter}`;
     log({ event: "turn_start", sessionId: opts.sessionId, turnId: activeTurnId });
@@ -165,8 +186,44 @@ export const openSession = (
     turnsChannel.push(activeTurn);
   };
 
+  /** issue #44: at a turn boundary, scan the last assistant message for
+   * the hcn-question block - same structured-first discipline and
+   * last-message rule as streamTurn. The question event lands in the
+   * turn stream right before its done; a malformed block surfaces as an
+   * error event, never a silent no-op. */
+  const emitQuestionIfAsked = (): void => {
+    if (!escalateQuestions || lastAssistantText === null) return;
+    const detection = detectQuestionBlock(lastAssistantText);
+    if (detection === null) return;
+    if ("malformed" in detection) {
+      activeTurn?.push({ kind: "error", message: detection.malformed });
+      return;
+    }
+    turnAsked = true;
+    log({
+      event: "question",
+      sessionId: opts.sessionId,
+      turnId: activeTurnId,
+      harness: h.name,
+      options: detection.block.options.length,
+    });
+    activeTurn?.push({
+      kind: "question",
+      question: detection.block.question,
+      options: detection.block.options,
+      ...(detection.block.recommended !== undefined
+        ? { recommended: detection.block.recommended }
+        : {}),
+    });
+  };
+
   const endTurn = (done: HarnessEvent & { kind: "done" }): void => {
     if (activeTurn === null) return;
+    // Asking is a successful turn: the session semantic is "blocked on
+    // answer, session alive" - the done stays TURN-scoped (exitCode null
+    // in sessions) and the caller answers with the next send().
+    emitQuestionIfAsked();
+    if (turnAsked && done.cause === "clean") done = { ...done, cause: "awaiting-input" };
     activeTurn.push(done);
     activeTurn.close();
     log({
@@ -188,6 +245,9 @@ export const openSession = (
       state.limitSeen = true;
       turnLimitSeen = true;
     }
+    if (escalateQuestions && event.kind === "message" && event.role === "assistant") {
+      lastAssistantText = event.text;
+    }
     if (activeTurn !== null) {
       // Awaited by the pumps: past the channel's high water mark this
       // blocks the pump, so OS pipe backpressure reaches the child.
@@ -207,6 +267,28 @@ export const openSession = (
 
   const pumpStdout = async (): Promise<void> => {
     const lines = new LineBuffer();
+    const matches = (
+      record: Record<string, unknown>,
+      spec: Readonly<Record<string, string>>,
+    ): boolean => {
+      for (const [key, expected] of Object.entries(spec)) {
+        if (record[key] !== expected) return false;
+      }
+      return true;
+    };
+    // issue #44: pi rpc is identity-silent at startup; the probe round
+    // trip is the only way to read the id (spike fixtures). The response
+    // echoes our marker id, so it cannot be confused with a user-visible
+    // get_state response.
+    if (sessionInputMode?.identityProbe !== null && sessionInputMode !== null) {
+      try {
+        stdin.write(
+          `${JSON.stringify({ id: "hcn-identity", type: sessionInputMode.identityProbe.command })}\n`,
+        );
+      } catch {
+        // stdin already gone; the exited handler will surface the death.
+      }
+    }
     const handleLine = async (line: string): Promise<void> => {
       let parsed: Record<string, unknown> | null = null;
       try {
@@ -218,10 +300,70 @@ export const openSession = (
         }
         return;
       }
-      // The result line still feeds identity dedupe (claude includes
-      // session_id on it - a rotation announced there must not be missed).
+      // pi rpc bookkeeping: the probe response announces identity; a
+      // failed command response is a surfaced error, never a silent drop
+      // (spike: mid-stream prompts fail with success:false naming the
+      // remedy - hcn never sends those, but any other failure shows here).
+      if (parsed.type === "response") {
+        if (
+          parsed.id === "hcn-identity" &&
+          typeof parsed.command === "string" &&
+          parsed.command === sessionInputMode?.identityProbe?.command &&
+          parsed.success === true
+        ) {
+          const data = parsed.data as Record<string, unknown> | undefined;
+          const announced = data?.sessionId;
+          if (typeof announced !== "string") {
+            await routeEvent({
+              kind: "error",
+              message: "identity probe response carried no sessionId",
+            });
+          } else if (sessionInputMode.idFlag === null) {
+            // Harness-MINTED identity (pi rpc: `--session` refuses unknown
+            // ids, so fresh sessions omit the flag). The minted id IS the
+            // identity; opts.sessionId stays the caller-side handle.
+            if (!identityAnnounced) {
+              identityAnnounced = true;
+              state.lastSeenId = announced;
+              await routeEvent({
+                kind: "identity",
+                sessionId: announced,
+                authority: h.identity.authority,
+                capabilities: capabilitiesOf(h, opts.model ?? "", "headless-session"),
+              });
+            }
+          } else if (announced === opts.sessionId) {
+            if (!identityAnnounced) {
+              identityAnnounced = true;
+              await routeEvent({
+                kind: "identity",
+                sessionId: announced,
+                authority: h.identity.authority,
+                capabilities: capabilitiesOf(h, opts.model ?? "", "headless-session"),
+              });
+            }
+          } else {
+            await routeEvent({
+              kind: "error",
+              message: `identity rotated: session announced ${JSON.stringify(announced)} but ${opts.sessionId} was requested`,
+            });
+          }
+          return;
+        }
+        if (parsed.success === false) {
+          await routeEvent({
+            kind: "error",
+            message: `rpc command failed: ${JSON.stringify(parsed.command)} - ${JSON.stringify(parsed.error ?? "unknown error")}`,
+          });
+        }
+        return;
+      }
+      // The turn-end record still feeds identity dedupe (claude includes
+      // session_id on result - a rotation announced there must not be
+      // missed).
       const events = decodeParsed(h, parsed, state, opts.model ?? "");
-      if (parsed.type === "result") {
+      const isTurnEnd = sessionInputMode !== null && matches(parsed, sessionInputMode.turnEnd);
+      if (isTurnEnd) {
         // 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.