muonroi-cli 1.8.4 → 1.9.0

package/dist/packages/agent-harness-opentui/src/agent-mode.js

@@ -22,6 +22,7 @@ import { createIdleDetector } from "@muonroi/agent-harness-core/idle";
 import { createLineSplitter, createSidechannelWriter } from "@muonroi/agent-harness-core/transports/sidechannel";
 import { installOpenTUIHarness } from "./install.js";
 import { createSemanticRegistry } from "./reconciler-hook.js";
+import { createVisualCaptureHook } from "./visual-capture.js";
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -90,6 +91,11 @@ export async function startAgentMode(opts) {
     const now = () => (opts.fakeClock ? 0 : Date.now());
     // --- Semantic registry ---------------------------------------------------
     const registry = createSemanticRegistry();
+    // --- Visual capture (real rendered cell grid) ----------------------------
+    // The renderer does not exist yet — it is constructed after this runtime and
+    // handed back via attachRenderer(). The hook reads it late-bound.
+    let rendererRef;
+    const visualHook = createVisualCaptureHook(() => rendererRef);
     // --- Idle detector -------------------------------------------------------
     const idle = createIdleDetector({
         quiescenceMs: opts.idleMs,
@@ -116,6 +122,9 @@ export async function startAgentMode(opts) {
         // becomes deterministic (seq*16). Without this, ts = Date.now() and the
         // determinism spec sees timestamps differ between runs.
         fakeClock: opts.fakeClock,
+        // Emit a VisualFrame (real rendered cell grid) alongside each semantic
+        // change. No-op until attachRenderer() supplies the renderer.
+        captureVisual: (seq, ts) => visualHook.capture(seq, ts),
     });
     // --- Command channel (in stream → handlers) ------------------------------
     const commandHandlers = [];
@@ -165,6 +174,10 @@ export async function startAgentMode(opts) {
     const onCommand = (h) => {
         commandHandlers.push(h);
     };
+    const attachRenderer = (renderer) => {
+        rendererRef = renderer;
+        visualHook.resetDedup(); // force the first visual frame after attach
+    };
     const dispose = () => {
         harnessHandle.uninstall(); // stops poll interval; transport.close() ends outStream
         idle.dispose();
@@ -173,6 +186,6 @@ export async function startAgentMode(opts) {
             inStream.destroy();
         }
     };
-    return { registry, capture, emitEvent, onCommand, now, dispose };
+    return { registry, capture, emitEvent, onCommand, now, attachRenderer, dispose };
 }
 //# sourceMappingURL=agent-mode.js.map

package/dist/packages/agent-harness-opentui/src/input-bridge.d.ts

@@ -13,15 +13,7 @@
  * raw byte. We construct ParsedKey directly so we don't depend on terminal
  * escape sequence conventions.
  */
+import type { KeyEvent } from "@opentui/core";
 import type { AgentModeRuntime } from "./agent-mode.js";
-/**
- * Subscribe to agentRuntime.onCommand and inject synthetic key events into
- * OpenTUI's keyHandler. Safe no-op when agentRuntime is undefined (normal user
- * mode).
- *
- * Special key `__focus__:<id>` is intentionally NOT translated to OpenTUI input
- * here — it is a driver-level signal currently ignored at this layer. (Focus
- * routing in OpenTUI is owned by individual components; a global focus dispatch
- * is out of scope for this bridge.)
- */
+export declare function keyForNamed(key: string): KeyEvent | null;
 export declare function useAgentInputBridge(agentRuntime: AgentModeRuntime | undefined): void;

package/dist/packages/agent-harness-opentui/src/input-bridge.js

@@ -35,7 +35,54 @@ const NAMED = {
     PageUp: { name: "pageup", sequence: "\x1b[5~", raw: "\x1b[5~" },
     PageDown: { name: "pagedown", sequence: "\x1b[6~", raw: "\x1b[6~" },
 };
-function makeKey(partial) {
+// Case-insensitive view of NAMED. The map above is capitalized, but drivers
+// naturally send lowercase ("enter", "escape", "tab", "space") — those missed
+// the exact-case lookup, so keyForNamed returned null and the keystroke was a
+// SILENT no-op (Enter never submitted, Escape never dismissed a modal). Resolve
+// on the lowercased base so every casing works. Includes a couple of common
+// short aliases drivers reach for.
+const NAMED_LC = {
+    ...Object.fromEntries(Object.entries(NAMED).map(([k, v]) => [k.toLowerCase(), v])),
+    ret: NAMED.Return,
+    del: NAMED.Delete,
+    spacebar: NAMED.Space,
+    pgup: NAMED.PageUp,
+    pgdn: NAMED.PageDown,
+};
+/**
+ * Strip modifier prefixes (`C-` ctrl, `M-` meta/alt, `S-` shift) off a harness
+ * key string so combos like `C-b` or `C-o` can be driven. Prefixes may stack in
+ * any order (`C-S-tab`). The remainder is the base key (named or single char).
+ */
+function parseModifiers(key) {
+    const mods = {};
+    let base = key;
+    // Only consume a prefix when a base remains after it, so a literal "C" or a
+    // hyphen key is not mis-parsed.
+    for (;;) {
+        if (base.length > 2 && base[1] === "-") {
+            const p = base[0];
+            if (p === "C" || p === "c") {
+                mods.ctrl = true;
+                base = base.slice(2);
+                continue;
+            }
+            if (p === "M" || p === "m") {
+                mods.meta = true;
+                base = base.slice(2);
+                continue;
+            }
+            if (p === "S") {
+                mods.shift = true;
+                base = base.slice(2);
+                continue;
+            }
+        }
+        break;
+    }
+    return { mods, base };
+}
+function makeKey(partial, mods = {}) {
     // Some app key-handlers conditionally call key.preventDefault()/stopPropagation()
     // (typed `?.()` so they tolerate undefined). When the host's keypress arrives
     // through a terminal, OpenTUI attaches these methods; in agent-mode we
@@ -48,9 +95,9 @@ function makeKey(partial) {
     let _propagationStopped = false;
     const ev = {
         name: partial.name,
-        ctrl: false,
-        meta: false,
-        shift: false,
+        ctrl: mods.ctrl ?? false,
+        meta: mods.meta ?? false,
+        shift: mods.shift ?? false,
         option: false,
         sequence: partial.sequence,
         number: false,
@@ -72,18 +119,22 @@ function makeKey(partial) {
     };
     return ev;
 }
-function keyForChar(ch) {
-    return makeKey({ name: ch, sequence: ch, raw: ch });
+function keyForChar(ch, mods = {}) {
+    return makeKey({ name: ch, sequence: ch, raw: ch }, mods);
 }
-function keyForNamed(key) {
-    const m = NAMED[key];
+export function keyForNamed(key) {
+    const { mods, base } = parseModifiers(key);
+    // Exact case first (fast path), then case-insensitive so "enter"/"Enter"/
+    // "ENTER"/"return" all resolve. Single-letter bases never collide with a
+    // NAMED word, so they still fall through to the literal-char path below.
+    const m = NAMED[base] ?? NAMED_LC[base.toLowerCase()];
     if (!m) {
         // Unknown named key — fall back to treating it as a literal character if it's 1 char.
-        if (key.length === 1)
-            return keyForChar(key);
+        if (base.length === 1)
+            return keyForChar(base, mods);
         return null;
     }
-    return makeKey(m);
+    return makeKey(m, mods);
 }
 /**
  * Subscribe to agentRuntime.onCommand and inject synthetic key events into
@@ -95,15 +146,51 @@ function keyForNamed(key) {
  * routing in OpenTUI is owned by individual components; a global focus dispatch
  * is out of scope for this bridge.)
  */
+// Runtimes that already have the input bridge wired — module-level so the guard
+// survives App remounts (a per-component ref would reset and re-register).
+const mountedRuntimes = new WeakSet();
 export function useAgentInputBridge(agentRuntime) {
-    const { keyHandler } = useAppContext();
+    const ctx = useAppContext();
+    const keyHandler = ctx.keyHandler;
+    // Focused renderables (the composer textarea) subscribe to keypresses via
+    // renderer._internalKeyInput.onInternal("keypress"), NOT via the public
+    // keyHandler (useAppContext().keyHandler === renderer.keyInput). On the real
+    // TTY renderer both are the SAME InternalKeyHandler, but under the agent-mode
+    // headless renderer they are DISTINCT objects — so emitting only on keyHandler
+    // reached app-level useKeyboard shortcuts yet never the textarea, and typed
+    // text silently vanished (the tier-2 harness-drive bug). Prefer
+    // _internalKeyInput: its emitWithPriority dispatches to BOTH the focused
+    // renderable AND global listeners registered on it.
+    const internal = ctx.renderer?._internalKeyInput;
     useEffect(() => {
-        if (!agentRuntime || !keyHandler)
+        if (!agentRuntime)
+            return;
+        // onCommand has no unsubscribe (it only pushes to a handler array), so
+        // registering twice doubles every keystroke (observed: a typed prompt
+        // arrived duplicated). A per-component ref is not enough — the App can
+        // remount (e.g. hero → chat transition) giving a fresh ref while the prior
+        // handler stays registered on the same long-lived runtime. Track mounted
+        // runtimes in a module-level WeakSet so registration is once-per-runtime
+        // across remounts.
+        if (mountedRuntimes.has(agentRuntime))
+            return;
+        const target = internal ?? keyHandler;
+        if (!target)
             return;
         // Toast-only stub in normal interactive mode provides emitEvent but not
         // onCommand. Guard so the bridge no-ops cleanly instead of crashing the TUI.
         if (typeof agentRuntime.onCommand !== "function")
             return;
+        mountedRuntimes.add(agentRuntime);
+        // Emit to the renderable channel (the focused textarea), and also to the
+        // public keyHandler when it is a distinct object so global shortcuts still
+        // fire. The `!== target` guard avoids double-dispatch on the real renderer
+        // where the two are identical.
+        const emitKey = (k) => {
+            target.emit("keypress", k);
+            if (keyHandler && keyHandler !== target)
+                keyHandler.emit("keypress", k);
+        };
         agentRuntime.onCommand((cmd) => {
             if (!cmd || typeof cmd !== "object")
                 return;
@@ -113,14 +200,14 @@ export function useAgentInputBridge(agentRuntime) {
                     return;
                 const k = keyForNamed(c.key);
                 if (k)
-                    keyHandler.emit("keypress", k);
+                    emitKey(k);
             }
             else if (c.op === "type" && typeof c.text === "string") {
                 for (const ch of c.text) {
-                    keyHandler.emit("keypress", keyForChar(ch));
+                    emitKey(keyForChar(ch));
                 }
             }
         });
-    }, [agentRuntime, keyHandler]);
+    }, [agentRuntime, internal, keyHandler]);
 }
 //# sourceMappingURL=input-bridge.js.map

package/dist/packages/agent-harness-opentui/src/install.d.ts

@@ -41,6 +41,14 @@ export interface InstallOpenTUIHarnessOptions {
      * the `--agent-fake-clock` CLI flag.
      */
     fakeClock?: boolean;
+    /**
+     * Optional visual-frame capture. When provided, a VisualFrame (the actual
+     * rendered cell grid — colors + attributes) is captured and sent right after
+     * each SEMANTIC frame change. Piggybacking on semantic changes bounds the
+     * per-frame `getSpanLines()` allocation to real UI updates instead of every
+     * poll tick. Returns null on dedup / unavailable renderer.
+     */
+    captureVisual?: (seq: number, ts: number) => object | null;
 }
 export interface OpenTUIHarnessHandle {
     /**

package/dist/packages/agent-harness-opentui/src/install.js

@@ -28,6 +28,7 @@ export function installOpenTUIHarness(opts) {
     const fps = opts.fps ?? 60;
     const intervalMs = Math.max(1, Math.round(1000 / fps));
     let seq = 0;
+    let vseq = 0;
     const fakeClock = opts.fakeClock ?? false;
     const hook = createReconcilerHook({
         registry: opts.registry,
@@ -43,6 +44,15 @@ export function installOpenTUIHarness(opts) {
         try {
             opts.transport.send(`${JSON.stringify(frame)}\n`);
             opts.onFrame?.(frame);
+            // Piggyback the visual (rendered cell-grid) frame on semantic changes so
+            // getSpanLines() only runs when the UI actually changed, not every tick.
+            if (opts.captureVisual) {
+                const vframe = opts.captureVisual(vseq, fakeClock ? vseq * 16 : Date.now());
+                if (vframe !== null) {
+                    vseq++;
+                    opts.transport.send(`${JSON.stringify(vframe)}\n`);
+                }
+            }
         }
         catch {
             // Drop frame on transport error — survivor of next tick will retry.

package/dist/packages/agent-harness-opentui/src/semantic.js

@@ -31,22 +31,24 @@ export function Semantic(props) {
         const unregister = registry.register({ ...nodeRef.current, parentId });
         return unregister;
     }, [registry, parentId, node.id]);
-    // Updates: re-register on prop change. This calls register() with the new
-    // node fields; Map.set on an existing key preserves insertion order.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: nodeKey is the intentional cache-bust for node fields
+    // Updates: patch fields on prop change via registry.update(). nodeKey is the
+    // intentional cache-bust dep — it serializes the node fields so this effect
+    // re-runs whenever any field changes; Map.set on an existing key preserves
+    // insertion order.
     React.useEffect(() => {
         if (!registry)
             return;
         if (!nodeKey)
             return;
         // Skip the very first run — the mount effect above already registered.
-        // We detect "subsequent run" by checking if the entry exists in the
-        // registry. On mount, the order is: this effect runs after the mount
-        // effect, so the entry IS present. We then call register() again with
-        // the same node — that's a no-op write that updates fields without
-        // changing position. On subsequent renders with different nodeKey,
-        // register() updates the fields in place.
-        registry.register({ ...nodeRef.current, parentId });
+        // On mount this effect runs after the mount effect, so the entry IS
+        // present; update() patches fields in place (Map.set on an existing key
+        // preserves insertion order). On subsequent renders with a different
+        // nodeKey it patches the changed fields. Using update() (not register())
+        // is the cheaper intended path — it merges instead of rebuilding the
+        // entry, and it is a no-op if the entry was already unmounted.
+        const { id: _id, ...patch } = nodeRef.current;
+        registry.update(nodeRef.current.id, patch);
         // No cleanup — the mount effect's cleanup is the single source of
         // truth for unmounting. If we returned a cleanup here, it would race
         // with re-renders and re-delete the entry.

package/dist/packages/agent-harness-opentui/src/visual-capture.d.ts

@@ -0,0 +1,56 @@
+/**
+ * visual-capture.ts — read OpenTUI's ACTUAL rendered cell grid.
+ *
+ * The semantic harness (reconciler-hook) reports STRUCTURE (id/role/name/props)
+ * but is blind to what a human SEES — colors, bold/italic, alignment, blank
+ * rows, mojibake. This module snapshots the ground-truth render buffer instead:
+ * OpenTUI's `CliRenderer.currentRenderBuffer` is a cell grid it already paints,
+ * and `OptimizedBuffer.getSpanLines()` returns per-cell char + RGBA fg/bg +
+ * attribute bits (verified against @opentui/core@0.1.107 buffer.d.ts:43 +
+ * lib/RGBA.d.ts). No OCR — the buffer is authoritative and in-process.
+ *
+ * Consumers get a `VisualFrame` (protocol) they can query per-cell, render to
+ * annotated text, or (P2) rasterize to PNG for a vision model.
+ */
+import { type VisualFrame } from "@muonroi/agent-harness-core/protocol";
+interface RgbaLike {
+    toInts?: () => [number, number, number, number];
+    r?: number;
+    g?: number;
+    b?: number;
+    a?: number;
+}
+interface CapturedSpanLike {
+    text: string;
+    fg: RgbaLike;
+    bg: RgbaLike;
+    attributes: number;
+    width: number;
+}
+interface CapturedLineLike {
+    spans: CapturedSpanLike[];
+}
+interface OptimizedBufferLike {
+    width: number;
+    height: number;
+    getSpanLines: () => CapturedLineLike[];
+}
+export interface RendererLike {
+    currentRenderBuffer?: OptimizedBufferLike;
+    nextRenderBuffer?: OptimizedBufferLike;
+}
+export interface VisualCaptureHook {
+    /** Build a VisualFrame from the renderer's current buffer. Returns null when
+     *  no renderer is attached, the buffer is unreadable, or content is unchanged
+     *  (content-hash dedup — same contract as the semantic reconciler hook). */
+    capture(seq: number, ts: number): VisualFrame | null;
+    /** Reset dedup state so the next capture always emits. */
+    resetDedup(): void;
+}
+/**
+ * Create a visual-capture hook. `getRenderer` is a late-bound accessor because
+ * the OpenTUI renderer is constructed AFTER the agent-mode runtime (which owns
+ * this hook) — see src/index.ts attachRenderer wiring.
+ */
+export declare function createVisualCaptureHook(getRenderer: () => RendererLike | undefined): VisualCaptureHook;
+export {};

package/dist/packages/agent-harness-opentui/src/visual-capture.js

@@ -0,0 +1,103 @@
+/**
+ * visual-capture.ts — read OpenTUI's ACTUAL rendered cell grid.
+ *
+ * The semantic harness (reconciler-hook) reports STRUCTURE (id/role/name/props)
+ * but is blind to what a human SEES — colors, bold/italic, alignment, blank
+ * rows, mojibake. This module snapshots the ground-truth render buffer instead:
+ * OpenTUI's `CliRenderer.currentRenderBuffer` is a cell grid it already paints,
+ * and `OptimizedBuffer.getSpanLines()` returns per-cell char + RGBA fg/bg +
+ * attribute bits (verified against @opentui/core@0.1.107 buffer.d.ts:43 +
+ * lib/RGBA.d.ts). No OCR — the buffer is authoritative and in-process.
+ *
+ * Consumers get a `VisualFrame` (protocol) they can query per-cell, render to
+ * annotated text, or (P2) rasterize to PNG for a vision model.
+ */
+import { createHash } from "node:crypto";
+import { PROTOCOL_VERSION, } from "@muonroi/agent-harness-core/protocol";
+/** Low byte of OpenTUI's TextAttributes (ATTRIBUTE_BASE_MASK = 255). */
+const ATTR_MASK = 255;
+function clampByte(n) {
+    return Math.max(0, Math.min(255, Math.round(n)));
+}
+/**
+ * Convert an OpenTUI RGBA to a "#rrggbb" (or "#rrggbbaa" when translucent) hex
+ * string. Prefers `toInts()` (0-255 ints); falls back to component getters,
+ * scaling 0-1 floats up to 0-255 when the renderer exposes normalized channels.
+ */
+function toHex(c) {
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 255;
+    if (c && typeof c.toInts === "function") {
+        const ints = c.toInts();
+        r = ints[0];
+        g = ints[1];
+        b = ints[2];
+        a = ints[3];
+    }
+    else if (c) {
+        const scale = (v) => (v === undefined ? 0 : v <= 1 ? v * 255 : v);
+        r = scale(c.r);
+        g = scale(c.g);
+        b = scale(c.b);
+        a = c.a === undefined ? 255 : c.a <= 1 ? c.a * 255 : c.a;
+    }
+    const h = (n) => clampByte(n).toString(16).padStart(2, "0");
+    return a < 255 ? `#${h(r)}${h(g)}${h(b)}${h(a)}` : `#${h(r)}${h(g)}${h(b)}`;
+}
+/**
+ * Create a visual-capture hook. `getRenderer` is a late-bound accessor because
+ * the OpenTUI renderer is constructed AFTER the agent-mode runtime (which owns
+ * this hook) — see src/index.ts attachRenderer wiring.
+ */
+export function createVisualCaptureHook(getRenderer) {
+    let lastHash;
+    function capture(seq, ts) {
+        const renderer = getRenderer();
+        const buffer = renderer?.currentRenderBuffer ?? renderer?.nextRenderBuffer;
+        if (!buffer || typeof buffer.getSpanLines !== "function")
+            return null;
+        let captured;
+        try {
+            captured = buffer.getSpanLines();
+        }
+        catch (err) {
+            // getSpanLines allocates + decodes native Zig memory; a mid-resize/destroy
+            // race can throw. Skip this frame (the next tick retries). Debug-gated log
+            // only — unconditional logging here would spam the render loop.
+            if (process.env.MUONROI_DEBUG_VISUAL) {
+                console.error(`[visual-capture] getSpanLines failed: ${err?.message}`);
+            }
+            return null;
+        }
+        const lines = captured.map((ln) => ({
+            spans: (ln.spans ?? []).map((s) => ({
+                text: s.text,
+                fg: toHex(s.fg),
+                bg: toHex(s.bg),
+                attrs: (s.attributes ?? 0) & ATTR_MASK,
+                width: s.width,
+            })),
+        }));
+        const hash = createHash("sha1").update(JSON.stringify(lines)).digest("hex");
+        if (lastHash === hash)
+            return null;
+        lastHash = hash;
+        return {
+            mode: "visual",
+            version: PROTOCOL_VERSION,
+            seq,
+            ts,
+            cols: buffer.width,
+            rows: buffer.height,
+            cursor: null,
+            lines,
+        };
+    }
+    function resetDedup() {
+        lastHash = undefined;
+    }
+    return { capture, resetDedup };
+}
+//# sourceMappingURL=visual-capture.js.map

package/dist/src/agent-harness/mock-model.d.ts

@@ -48,6 +48,44 @@ export interface MockModelFixture {
     provider?: string;
     /** Reported model id. Default "mock-model". */
     modelId?: string;
+    /**
+     * Response for PIL's model-first intent classifier (src/pil/llm-classify.ts).
+     * Since the no-regex refactor (2026-07-07) PIL classifies EVERY turn by
+     * calling the model with a distinctive system prompt ("Reply with ONE line of
+     * EIGHT lowercase words…") and parses a comma-separated line. The generic
+     * fixture stream ("Hello back!" / arbitrary chunks) does not parse → the turn
+     * degrades to intentKind=UNKNOWN, which skips the gsd gate and breaks routing
+     * in E2E specs. The mock detects that classify call by its system prompt and
+     * returns THIS line instead of consuming the turn fixture — so every spec gets
+     * a sane classification for free. Override per-fixture when a spec needs a
+     * specific taskType/intent/depth. Format:
+     *   <taskType>,<style>,<intent>,<deliverable>,<depth>,<scope>,<lang>,<clarity>
+     */
+    classify?: string;
+    /**
+     * Milliseconds to wait before each streamed chunk. Default 0 (instant).
+     *
+     * A real provider takes seconds; the mock is instant, which makes anything
+     * that only exists WHILE a call is in flight — a progress card, a spinner —
+     * impossible to observe from a spec. Set this to hold the in-flight state open
+     * long enough to assert on it. Keep it small: it is wall-clock in every spec
+     * that sets it.
+     */
+    chunkDelayMs?: number;
+    /**
+     * Opt in to the PIL-classifier intercept described on `classify`. When true,
+     * a `doStream` call carrying the classifier's system prompt is answered with
+     * `classify` (or DEFAULT_CLASSIFY_LINE) WITHOUT consuming a turn fixture.
+     *
+     * This is a convenience for the file-based E2E harness (`loadMockModelFromDir`
+     * sets it true by default) whose fixtures supply agent turn-rounds and must
+     * not spend a round on the classify call. Direct in-memory callers
+     * (`createMockModel`/`installMockModel`, e.g. llm-classify.test.ts) leave it
+     * OFF so the fixture stream they configure IS delivered to the classifier —
+     * otherwise every classification would collapse to DEFAULT_CLASSIFY_LINE.
+     * Setting `classify` implies opting in.
+     */
+    autoClassify?: boolean;
 }
 export interface MockModelHandle {
     /** The mock model instance — assign to `globalThis.__muonroiMockModel`. */

package/dist/src/agent-harness/mock-model.js

@@ -25,6 +25,40 @@
 import { APICallError } from "@ai-sdk/provider";
 import { simulateReadableStream } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
+/**
+ * System-prompt substring that uniquely identifies PIL's model-first intent
+ * classifier call (see SYSTEM_PROMPT in src/pil/llm-classify.ts). Kept in sync
+ * with that constant's opening line.
+ */
+const CLASSIFY_SIGNATURE = "Reply with ONE line of EIGHT lowercase words";
+/**
+ * Safe default classification: a non-chitchat coding task of standard depth.
+ * `intent=task` keeps the toolset + gsd gate active; `standard` depth avoids
+ * forcing heavy-only paths. First word MUST be a valid taskType.
+ */
+const DEFAULT_CLASSIFY_LINE = "generate, balanced, task, code, standard, local, english, clear";
+/** Concatenated text of every `system` message in a doStream call's prompt. */
+function systemPromptText(options) {
+    const prompt = options.prompt;
+    if (!Array.isArray(prompt))
+        return "";
+    const parts = [];
+    for (const msg of prompt) {
+        const m = msg;
+        if (m.role !== "system")
+            continue;
+        if (typeof m.content === "string")
+            parts.push(m.content);
+        else if (Array.isArray(m.content)) {
+            for (const c of m.content) {
+                const t = c.text;
+                if (typeof t === "string")
+                    parts.push(t);
+            }
+        }
+    }
+    return parts.join("\n");
+}
 function isNestedArray(v) {
     return Array.isArray(v) && v.length > 0 && Array.isArray(v[0]);
 }
@@ -44,10 +78,35 @@ export function createMockModel(fx) {
     let genIdx = 0;
     const provider = fx.provider ?? "mock";
     const modelId = fx.modelId ?? "mock-model";
+    const classifyLine = fx.classify ?? DEFAULT_CLASSIFY_LINE;
+    // Intercept the PIL classifier call ONLY when the fixture opts in (E2E
+    // harness fixtures do, via loadMockModelFromDir). Direct in-memory callers
+    // (llm-classify.test.ts) leave it off so the stream they configure IS
+    // delivered to the classifier — intercepting would override their reply with
+    // DEFAULT_CLASSIFY_LINE and make every classification collapse to "generate".
+    const interceptClassify = fx.autoClassify === true || fx.classify !== undefined;
+    const chunkDelayMs = Math.max(0, fx.chunkDelayMs ?? 0);
     const model = new MockLanguageModelV3({
         provider,
         modelId,
-        doStream: async () => {
+        doStream: async (options) => {
+            // PIL model-first classifier call — answer with the parseable eight-word
+            // line and DO NOT advance the turn-fixture cursor, so the classify call
+            // (which fires on every turn) never steals the round chunks meant for the
+            // agent's actual reply. Without this the generic fixture text fails
+            // parseResponse → intentKind=UNKNOWN → gsd gate/routing break in E2E.
+            if (interceptClassify && systemPromptText(options).includes(CLASSIFY_SIGNATURE)) {
+                if (process.env.MUONROI_DEBUG_MOCK_MODEL === "1") {
+                    process.stderr.write(`[mock-model] doStream classify → "${classifyLine}"\n`);
+                }
+                return {
+                    stream: simulateReadableStream({
+                        chunks: textOnlyStream(classifyLine),
+                        initialDelayInMs: null,
+                        chunkDelayInMs: null,
+                    }),
+                };
+            }
             const chunks = streams[Math.min(callIdx, streams.length - 1)];
             callIdx += 1;
             if (process.env.MUONROI_DEBUG_MOCK_MODEL === "1") {
@@ -58,8 +117,11 @@ export function createMockModel(fx) {
             return {
                 stream: simulateReadableStream({
                     chunks,
-                    initialDelayInMs: null,
-                    chunkDelayInMs: null,
+                    // Only the turn stream honours the delay — the classify intercept above
+                    // fires on EVERY turn, so pacing it would tax specs that just want a
+                    // slow answer.
+                    initialDelayInMs: chunkDelayMs || null,
+                    chunkDelayInMs: chunkDelayMs || null,
                 }),
             };
         },
@@ -397,6 +459,10 @@ export async function loadMockModelFromDir(dir) {
         // to createMockModel, so the AI SDK stream-loop and orchestrator see a
         // consistent Error shape regardless of fixture serialization.
         const normalized = {
+            // File-based E2E fixtures supply agent turn-rounds; auto-answer the PIL
+            // classifier call so it never consumes a round (a fixture may still set
+            // autoClassify:false to opt out, or classify:"…" to force a line).
+            autoClassify: true,
             ...raw.model,
             stream: isNestedArray(raw.model.stream)
                 ? raw.model.stream.map(normalizeStreamChunks)