@adhdev/daemon-core 0.9.82-rc.354 → 0.9.82-rc.356

package/src/providers/spec/adapter.ts

@@ -51,6 +51,43 @@ export interface TerminalAdapterHandlers {
     tick?(): void;
 }
 
+/**
+ * One entry in the PTY input/output event timeline (debug-only). Captured at
+ * the single common point every spec@4 provider funnels through — this adapter
+ * — so the Spec Debug Snapshot can answer "what input / output preceded a status
+ * transition?". Observation only; nothing here feeds the FSM decision.
+ */
+export interface SpecPtyEvent {
+    /** Wall-clock ms. */
+    ts: number;
+    kind: 'spawn' | 'input' | 'output' | 'resize' | 'cursor' | 'exit';
+    /** Human-readable, control-char-escaped, length-capped preview. */
+    content: string;
+    /** Raw byte length before truncation (output/input only). */
+    bytes?: number;
+}
+
+const MAX_PTY_EVENTS = 300;
+const EVENT_CONTENT_CAP = 240;
+
+/** Escape control characters into a visible form so the timeline is readable
+ *  (CR/LF/ESC/tab become \r \n \x1b \t; other C0 controls become \xNN). */
+function escapeControl(text: string): string {
+    // eslint-disable-next-line no-control-regex
+    return String(text).replace(/[\x00-\x1f\x7f]/g, (ch) => {
+        const code = ch.charCodeAt(0);
+        if (ch === '\r') return '\\r';
+        if (ch === '\n') return '\\n';
+        if (ch === '\t') return '\\t';
+        if (code === 0x1b) return '\\x1b';
+        return '\\x' + code.toString(16).padStart(2, '0');
+    });
+}
+
+function capPreview(text: string): string {
+    return text.length > EVENT_CONTENT_CAP ? text.slice(0, EVENT_CONTENT_CAP) + `…(+${text.length - EVENT_CONTENT_CAP})` : text;
+}
+
 export class TerminalAdapter {
     private rows: number;
     private cols: number;
@@ -62,6 +99,9 @@ export class TerminalAdapter {
     private screenTimer: ReturnType<typeof setTimeout> | null = null;
     private tickTimer: ReturnType<typeof setInterval> | null = null;
     private lastScreen = '';
+    /** Debug-only ring buffer of PTY input/output/resize/cursor events. */
+    private events: SpecPtyEvent[] = [];
+    private lastCursorKey = '';
 
     constructor(
         private readonly opts: TerminalAdapterOpts,
@@ -95,10 +135,12 @@ export class TerminalAdapter {
             cols: this.cols,
             rows: this.rows,
         });
+        this.recordEvent('spawn', `${this.opts.binary} (${this.cols}x${this.rows})`);
         this.handlers.init?.({ pid: this.pty.pid });
         this.pty.onData((chunk) => this.onChunk(chunk));
         this.pty.onExit((info) => {
             this.stopTimers();
+            this.recordEvent('exit', `exitCode=${typeof info.exitCode === 'number' ? info.exitCode : 0}`);
             this.handlers.on_exit?.({ exitCode: typeof info.exitCode === 'number' ? info.exitCode : 0 });
             this.pty = null;
         });
@@ -109,6 +151,7 @@ export class TerminalAdapter {
 
     resize(cols: number, rows: number): void {
         this.cols = cols; this.rows = rows;
+        this.recordEvent('resize', `${cols}x${rows}`);
         this.pty?.resize(cols, rows);
         this.screen.resize(rows, cols);
     }
@@ -133,9 +176,24 @@ export class TerminalAdapter {
     }
 
     send_keys(text: string): void {
+        this.recordEvent('input', capPreview(escapeControl(text)), text.length);
         this.pty?.write(text);
     }
 
+    /** Debug-only: most-recent PTY input/output/resize/cursor events, oldest
+     *  first. Pure observation — never consulted by the FSM. */
+    getEventTimeline(limit = MAX_PTY_EVENTS): SpecPtyEvent[] {
+        const n = Math.max(0, Math.min(limit, this.events.length));
+        return this.events.slice(this.events.length - n);
+    }
+
+    private recordEvent(kind: SpecPtyEvent['kind'], content: string, bytes?: number): void {
+        const ev: SpecPtyEvent = { ts: Date.now(), kind, content };
+        if (typeof bytes === 'number') ev.bytes = bytes;
+        this.events.push(ev);
+        if (this.events.length > MAX_PTY_EVENTS) this.events.splice(0, this.events.length - MAX_PTY_EVENTS);
+    }
+
     kill(): void {
         this.stopTimers();
         try { this.pty?.kill(); } catch { /* ignore */ }
@@ -144,6 +202,7 @@ export class TerminalAdapter {
     }
 
     private onChunk(chunk: string): void {
+        this.recordEvent('output', capPreview(escapeControl(chunk)), chunk.length);
         try { this.handlers.on_pty_data?.(chunk); } catch { /* user side */ }
         this.screen.write(chunk);
         // Coalesce snapshot emission — rapid bursts shouldn't fire 200x.
@@ -151,6 +210,14 @@ export class TerminalAdapter {
         this.screenTimer = setTimeout(() => {
             this.screenTimer = null;
             const snap = this.computeScreen();
+            // Record cursor movement at the (debounced) screen-change boundary
+            // rather than per output chunk, so the timeline isn't flooded.
+            const cur = this.screen.getCursorPosition();
+            const curKey = `${cur.row},${cur.col}`;
+            if (curKey !== this.lastCursorKey) {
+                this.lastCursorKey = curKey;
+                this.recordEvent('cursor', `(${cur.row},${cur.col})`);
+            }
             if (snap === this.lastScreen) return;
             this.lastScreen = snap;
             try { this.handlers.on_screen_changed?.(snap); } catch { /* user side */ }

package/src/providers/spec/cli-adapter.ts

@@ -413,11 +413,18 @@ export class SpecCliAdapter implements CliAdapter {
         choiceLabel: string | undefined,
     ): Promise<unknown> {
         // Open + wait so the choice list is on screen before we resolve the
-        // label → index mapping (a fresh invoke may arrive with the picker
-        // closed; re-opening an open picker is a no-op on these CLIs).
-        this.driver.dispatch({ kind: 'click_control', control_id: ctl.id });
-        await this.waitForPickerRendered(action);
-        const options = this.extractPickerChoices(action);
+        // label → index mapping. The picker is normally ALREADY open here (a
+        // preceding list invoke leaves it rendered), so only send the trigger
+        // when it is not on screen. Re-sending the trigger to an open picker is
+        // NOT a harmless no-op on claude-cli: the trailing CR of `/model\r`
+        // lands as Enter on the cursor's current row and commits the wrong
+        // model before we navigate. De-dup the open to avoid that.
+        let options = this.extractPickerChoicesIfRendered(action);
+        if (!options) {
+            this.driver.dispatch({ kind: 'click_control', control_id: ctl.id });
+            await this.waitForPickerRendered(action);
+            options = this.extractPickerChoices(action);
+        }
 
         let index = choiceIndex;
         if ((index == null || !Number.isFinite(index)) && choiceLabel) {
@@ -432,8 +439,34 @@ export class SpecCliAdapter implements CliAdapter {
             return { ok: false, error: 'choiceIndex or choiceLabel required to select' };
         }
 
-        const keys = (action.submit_key || '{index}\r').replace(/\{index\}/g, String(index));
-        this.driver.dispatch({ kind: 'pty_write', data: keys });
+        if (action.select_mode === 'arrow_keys') {
+            // Cursor-list picker (claude-cli /model): number keys are ignored.
+            // The cursor starts on the active row (extract flags it `current`);
+            // step it to the target row with arrows, then confirm.
+            const current = options.find(o => o.current);
+            if (current == null) {
+                // Without a known cursor position a blind Enter would commit
+                // whatever row the cursor sits on — fail loud instead.
+                return {
+                    ok: false,
+                    error: 'arrow-nav picker: current cursor row not detected on screen',
+                    controlResult: { options: options.map(o => ({ value: o.label, label: o.label, current: o.current })) },
+                };
+            }
+            const up = action.cursor_keys?.up ?? '';
+            const down = action.cursor_keys?.down ?? '';
+            const delta = index - current.index;
+            const step = delta >= 0 ? down : up;
+            const nav = step.repeat(Math.abs(delta));
+            // Confirm key = submit_key with the (unused) {index} placeholder
+            // stripped — e.g. `{index}\r` → `\r`.
+            const confirm = (action.submit_key || '\r').replace(/\{index\}/g, '') || '\r';
+            if (nav) this.driver.dispatch({ kind: 'pty_write', data: nav });
+            this.driver.dispatch({ kind: 'pty_write', data: confirm });
+        } else {
+            const keys = (action.submit_key || '{index}\r').replace(/\{index\}/g, String(index));
+            this.driver.dispatch({ kind: 'pty_write', data: keys });
+        }
         const selected = options.find(o => o.index === index);
         return {
             ok: true,
@@ -446,6 +479,23 @@ export class SpecCliAdapter implements CliAdapter {
         };
     }
 
+    /** Parse the picker choices only if the picker already appears rendered on
+     *  the live screen (its `wait_for` condition currently matches and at least
+     *  one choice parses). Returns the parsed choices when open, else null so
+     *  the caller knows it must send the trigger to open it. Used to de-dup the
+     *  picker open in {@link selectPickerChoice}. */
+    private extractPickerChoicesIfRendered(
+        action: Extract<ControlAction, { type: 'open_picker' }>,
+    ): Array<{ index: number; label: string; current: boolean }> | null {
+        const wf = action.wait_for;
+        if (wf?.regex) {
+            const re = new RegExp(wf.regex, wf.flags ?? 'i');
+            if (!re.test(this.readScreenSectionText(wf.section))) return null;
+        }
+        const options = this.extractPickerChoices(action);
+        return options.length > 0 ? options : null;
+    }
+
     /** Poll the live screen until the picker's `wait_for` condition matches,
      *  up to a short budget. Returns true if it rendered, false on timeout. */
     private async waitForPickerRendered(action: Extract<ControlAction, { type: 'open_picker' }>): Promise<boolean> {
@@ -552,6 +602,10 @@ export class SpecCliAdapter implements CliAdapter {
             // answers "why did this rule fire" after the fact, unlike the live
             // `fsm` field which only reflects the current instant.
             fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+            // PTY input/output/resize/cursor event timeline (debug-only) so the
+            // snapshot shows what we typed / what the PTY printed around each
+            // status transition. Null for drivers without the timeline.
+            eventTimeline: this.driver.getEventTimeline?.() ?? null,
             // Extended fields
             name: this.cliName,
             status: this.getStatus().status,
@@ -962,6 +1016,8 @@ export class SpecCliAdapter implements CliAdapter {
             // v4 FSM transition snapshot history — the captured pre-transition
             // evaluation table at each transition (null for v3 specs).
             fsmHistory: this.driver.getFsmSnapshotHistory?.() ?? null,
+            // PTY input/output/resize/cursor event timeline (debug-only).
+            eventTimeline: this.driver.getEventTimeline?.() ?? null,
             messages,
             committedMessages: messages,
         };

package/src/providers/spec/evaluator.ts

@@ -55,12 +55,24 @@ export function resolveSections(
                 // Normalize anchor + context into parallel candidate lists. A
                 // scalar anchor becomes a single-entry array; a single context
                 // object applies to every entry; an array context is positional.
-                // Candidates are tried IN ORDER as independent passes: the first
-                // pattern that finds any line wins. This keeps a scalar anchor's
-                // behavior identical, and lets an array express a preferred shape
-                // (e.g. a box divider) with later entries as fallbacks (e.g. a
-                // divider-less modal anchored on its question line) — the
-                // fallback only takes over when the preferred pattern is absent.
+                // Each candidate resolves its own anchor line independently
+                // (anchor_last → that candidate's LAST matching line, else its
+                // FIRST). Across candidates we then pick the TOPMOST resolved
+                // line, because a section's anchor marks the TOP of the block:
+                // among several recognized landmark shapes, the highest one
+                // bounds the whole block. This keeps a scalar anchor identical
+                // (one candidate), preserves a genuine box-top divider (it sits
+                // ABOVE the question line, so it still wins), and — crucially —
+                // stops a stray lower landmark from clipping the block: e.g. a
+                // claude approval whose numbered choices sit ABOVE the input-box
+                // `────` rule. anchor_last on the bare-divider pattern alone
+                // would latch that LOWER chrome rule and strand the buttons
+                // above it (deriveModal sees < min_count → auto-approve never
+                // fires); preferring the topmost landmark (here the question
+                // line just above the choices, matched by the fallback context)
+                // captures the whole modal. The fallback still only contributes
+                // when its own pattern matches, so non-modal screens are
+                // unaffected.
                 const anchorPatterns = Array.isArray(sec.anchor) ? sec.anchor : [sec.anchor];
                 const sharedCtx: AnchorContext | null = Array.isArray(sec.anchor_context)
                     ? null
@@ -84,12 +96,15 @@ export function resolveSections(
                     && (c.nextRe === null || (i < total - 1 && c.nextRe.test(lines[i + 1])));
                 let idx = -1;
                 for (const c of candidates) {
+                    let candIdx = -1;
                     if (sec.anchor_last) {
-                        for (let i = total - 1; i >= 0; i--) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                        for (let i = total - 1; i >= 0; i--) { if (matchesCandidate(c, i)) { candIdx = i; break; } }
                     } else {
-                        for (let i = 0; i < total; i++) { if (matchesCandidate(c, i)) { idx = i; break; } }
+                        for (let i = 0; i < total; i++) { if (matchesCandidate(c, i)) { candIdx = i; break; } }
                     }
-                    if (idx !== -1) break;
+                    // Topmost resolved anchor across candidates wins (see note
+                    // above): keep the smallest matching line index.
+                    if (candIdx !== -1 && (idx === -1 || candIdx < idx)) idx = candIdx;
                 }
                 if (idx !== -1) {
                     from = idx;
@@ -299,10 +314,10 @@ function compileLinePattern(ref: { pattern: string; flags?: string }): RegExp {
 export function extractButtonsFromRule(
     rule: ExtractButtons,
     hay: string,
-): { index: number; label: string; key: string }[] {
+): { index: number; label: string; key: string; current: boolean }[] {
     const keyTemplate = rule.key_for_index;
     const continuationLines = rule.continuation_lines ?? false;
-    const buttons: { index: number; label: string; key: string }[] = [];
+    const buttons: { index: number; label: string; key: string; current: boolean }[] = [];
 
     if (continuationLines) {
         const re = compileLinePattern(rule);
@@ -313,6 +328,7 @@ export function extractButtonsFromRule(
             const idx = Number(m[1]);
             let label = String(m[2] ?? '').trim();
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
+            const current = hasCursorMarker(lines[i]);
             let j = i + 1;
             while (j < lines.length) {
                 const next = lines[j];
@@ -324,7 +340,7 @@ export function extractButtonsFromRule(
             }
             if (buttons.some(b => b.index === idx)) continue;
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
-            buttons.push({ index: idx, label, key });
+            buttons.push({ index: idx, label, key, current });
             i = j - 1;
         }
     } else {
@@ -336,10 +352,19 @@ export function extractButtonsFromRule(
             if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
             if (buttons.some(b => b.index === idx)) continue;
             const key = keyTemplate.replace(/\{index\}/g, String(idx));
-            buttons.push({ index: idx, label, key });
+            // The matched text begins at the cursor marker (the pattern's
+            // optional `[❯›>]` prefix); flag this row as the cursor's current
+            // position so `select_mode: 'arrow_keys'` can step from it.
+            buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
         }
     }
 
     buttons.sort((a, b) => a.index - b.index);
     return buttons;
 }
+
+/** True when a button line carries a TUI cursor marker (`❯`, `›`, `>`) before
+ *  its number — i.e. the cursor currently sits on that row. */
+function hasCursorMarker(text: string): boolean {
+    return /^\s*[❯›>]/.test(text);
+}

package/src/providers/spec/fsm-driver.ts

@@ -21,7 +21,7 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { TerminalAdapter, type TerminalAdapterOpts } from './adapter.js';
+import { TerminalAdapter, type TerminalAdapterOpts, type SpecPtyEvent } from './adapter.js';
 import { resolveCliSpawnPlanFromParts } from '../../cli-adapters/provider-cli-runtime.js';
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
 import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from '@adhdev/session-host-core';
@@ -123,6 +123,7 @@ export interface ISpecDriver {
     getCompletionIdleDebounceState(): { active: boolean; ageMs: number; holdMs: number; forceAfterMs: number } | null;
     getFsmDebug?(): unknown;
     getFsmSnapshotHistory?(): ReadonlyArray<FsmSnapshotEntry>;
+    getEventTimeline?(limit?: number): ReadonlyArray<SpecPtyEvent>;
 }
 
 export interface SpecDriverOpts {
@@ -162,6 +163,23 @@ const SUBMIT_DELAY_FLOOR_MS = 200;
 // trimmed by the TUI on submit.
 const WIN32_SUBMIT_RESEND_GAP_MS = 350;
 const WIN32_SUBMIT_MAX_RESENDS = 14;
+// Settle-gate for the win32 FIRST submit CR. Hold the CR until the PTY output has
+// gone quiet for WIN32_SUBMIT_SETTLE_MS after the last input write — i.e. the full
+// (possibly multi-KB / multiline) message body has finished arriving in the
+// composer and echoing back. A long message waits until it actually lands; a short
+// one settles almost immediately. WIN32_SUBMIT_MAX_SETTLE_WAIT_MS bounds the wait
+// so a perpetually-noisy screen can never hang the submit. This is what stops a
+// blind fixed-delay CR from submitting a half-arrived prompt and dropping its
+// leading lines. The phase-2 verified-resend loop (below) is unchanged.
+const WIN32_SUBMIT_SETTLE_MS = 500;
+const WIN32_SUBMIT_MAX_SETTLE_WAIT_MS = 10_000;
+const WIN32_SUBMIT_SETTLE_POLL_MS = 120;
+// Defensive paced PTY write. A single unbounded ConPTY write can overflow the
+// input pipe and drop leading bytes; split a large body into bounded chunks with a
+// short inter-chunk gap so the console input buffer keeps up. Small bodies still
+// write in one shot.
+const WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+const WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
 
 export function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number {
     const lines = countNewlines(text);
@@ -170,6 +188,27 @@ export function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text:
     return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
 }
 
+/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
+ *  between a high and low surrogate (which would corrupt an astral char — emoji,
+ *  etc. — on the UTF-8 PTY write). */
+export function chunkPreservingSurrogates(text: string, size: number): string[] {
+    const chunks: string[] = [];
+    let offset = 0;
+    while (offset < text.length) {
+        let end = Math.min(text.length, offset + size);
+        if (end < text.length) {
+            const code = text.charCodeAt(end - 1);
+            // Boundary lands on a high surrogate → pull back one so the pair stays
+            // together in the next chunk.
+            if (code >= 0xd800 && code <= 0xdbff) end -= 1;
+        }
+        if (end <= offset) end = Math.min(text.length, offset + size); // size 1 on a lone surrogate
+        chunks.push(text.slice(offset, end));
+        offset = end;
+    }
+    return chunks;
+}
+
 export function guessExt(mime: string): string {
     if (/png/i.test(mime)) return '.png';
     if (/jpe?g/i.test(mime)) return '.jpg';
@@ -182,7 +221,7 @@ export function guessExt(mime: string): string {
 
 interface ModalSnapshot {
     title: string | null;
-    buttons: { index: number; label: string; key: string }[];
+    buttons: { index: number; label: string; key: string; current: boolean }[];
 }
 
 interface VisibleControl {
@@ -231,6 +270,16 @@ export class FsmDriver implements ISpecDriver {
      *  WIN32_SUBMIT_* and scheduleWin32Submit). Re-arms itself until the FSM
      *  leaves idle (submitted) or the resend budget is spent. */
     private win32SubmitTimer: ReturnType<typeof setTimeout> | null = null;
+    /** Wall-clock (ms) of the most recent raw PTY output chunk. Advances on every
+     *  on_pty_data — including the echo of text written into the composer — so the
+     *  win32 submit settle-gate can tell when input has finished landing. */
+    private lastPtyDataAt = 0;
+    /** Wall-clock (ms) of the most recent win32 message-body input write. Bridges
+     *  the gap between writing a chunk and its echo so the settle-gate does not
+     *  declare "quiet" mid-write. */
+    private lastWin32WriteAt = 0;
+    /** Pending paced chunk-write timer for a large win32 body (see writeWin32Body). */
+    private win32WriteTimer: ReturnType<typeof setTimeout> | null = null;
 
     private currentEval: CurrentEval | null = null;
     private stateHistory: HistoryEntry[] = [];
@@ -257,7 +306,7 @@ export class FsmDriver implements ISpecDriver {
             this.buildAdapterOpts(),
             {
                 init: () => this.emitInitialState(),
-                on_pty_data: (chunk) => this.emit({ kind: 'pty_data', chunk }),
+                on_pty_data: (chunk) => { this.lastPtyDataAt = Date.now(); this.emit({ kind: 'pty_data', chunk }); },
                 on_screen_changed: () => this.reevaluate(),
                 on_exit: ({ exitCode }) => this.handleExit(exitCode),
             },
@@ -349,6 +398,7 @@ export class FsmDriver implements ISpecDriver {
         if (this.wakeTimer) { clearTimeout(this.wakeTimer); this.wakeTimer = null; }
         if (this.stallTimer) { clearTimeout(this.stallTimer); this.stallTimer = null; }
         if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
+        if (this.win32WriteTimer) { clearTimeout(this.win32WriteTimer); this.win32WriteTimer = null; }
         this.specWatcher?.close();
         this.adapter.kill();
     }
@@ -385,6 +435,10 @@ export class FsmDriver implements ISpecDriver {
 
     getStateHistory(): ReadonlyArray<HistoryEntry> { return this.stateHistory; }
     getFsmSnapshotHistory(): ReadonlyArray<FsmSnapshotEntry> { return this.fsmSnapshotHistory; }
+    /** Debug-only PTY input/output/resize/cursor timeline from the adapter. */
+    getEventTimeline(limit?: number): ReadonlyArray<SpecPtyEvent> {
+        return this.adapter.getEventTimeline(limit);
+    }
     getSections(): Array<{ id: string; text: string }> | null {
         try {
             const screen = this.adapter.snapshot();
@@ -867,7 +921,7 @@ export class FsmDriver implements ISpecDriver {
         // typing simulation is skipped on win32; correctness of submission wins
         // over the typing visual there.
         if (process.platform === 'win32') {
-            this.adapter.send_keys(text);
+            this.writeWin32Body(text);
             this.scheduleWin32Submit(sm.submit_key, beforeSubmit);
             return;
         }
@@ -896,17 +950,70 @@ export class FsmDriver implements ISpecDriver {
         return st ? statusForState(st) : 'idle';
     }
 
+    /** Record a win32 body write so the settle-gate counts it as input activity
+     *  even before the echo arrives. */
+    private markWin32Write(): void {
+        this.lastWin32WriteAt = Date.now();
+    }
+
+    /** Most recent win32 input activity — a write we issued OR a PTY output chunk
+     *  (echo). The submit settle-gate waits for this to go quiet. */
+    private lastWin32InputActivityAt(): number {
+        return Math.max(this.lastPtyDataAt, this.lastWin32WriteAt);
+    }
+
     /**
-     * win32 verification-based submit. Sends the submit key, waits a gap, and if
-     * the FSM is still 'idle' (the prompt did not submit — the CR was absorbed as
-     * a multiline-paste newline) resends, up to WIN32_SUBMIT_MAX_RESENDS. The
-     * first CR always fires (so a stale/edge status never suppresses the submit);
-     * subsequent resends are gated on still being idle, and stop the instant the
-     * agent leaves idle (submitted → generating / approval). This converges the
-     * nondeterministic multiline window without spamming Enter into the next turn.
+     * Write the message body to the PTY for win32, paced into bounded chunks. A
+     * single unbounded ConPTY write can overflow the input pipe and drop leading
+     * bytes; splitting it with a short inter-chunk gap keeps the console input
+     * buffer from overflowing. Small bodies still go out in a single write. Each
+     * chunk advances lastWin32WriteAt so the submit settle-gate keeps waiting until
+     * the final chunk is out and echoed.
+     */
+    private writeWin32Body(text: string): void {
+        if (this.win32WriteTimer) { clearTimeout(this.win32WriteTimer); this.win32WriteTimer = null; }
+        if (text.length <= WIN32_PTY_WRITE_CHUNK_CHARS) {
+            this.markWin32Write();
+            this.adapter.send_keys(text);
+            return;
+        }
+        const chunks = chunkPreservingSurrogates(text, WIN32_PTY_WRITE_CHUNK_CHARS);
+        let idx = 0;
+        const writeNext = (): void => {
+            this.win32WriteTimer = null;
+            if (idx >= chunks.length) return;
+            this.markWin32Write();
+            this.adapter.send_keys(chunks[idx]);
+            idx += 1;
+            if (idx < chunks.length) {
+                this.win32WriteTimer = setTimeout(writeNext, WIN32_PTY_WRITE_CHUNK_GAP_MS);
+            }
+        };
+        writeNext();
+    }
+
+    /**
+     * win32 submit. Two phases:
+     *
+     *  Phase 1 (settle-gate): hold the first CR until the PTY output has been quiet
+     *  for WIN32_SUBMIT_SETTLE_MS after the last input write — i.e. the full
+     *  (possibly multi-KB / multiline) body has finished arriving in the composer
+     *  and echoing. Honors an initial minimum delay and is bounded by
+     *  WIN32_SUBMIT_MAX_SETTLE_WAIT_MS so a noisy screen can never hang the submit.
+     *  This is what stops a long message from being submitted half-arrived (its
+     *  leading lines lost). A short message settles almost immediately.
+     *
+     *  Phase 2 (verified resend — unchanged): send the submit key, wait a gap, and
+     *  if the FSM is still 'idle' (the CR was absorbed as a multiline-paste
+     *  newline) resend, up to WIN32_SUBMIT_MAX_RESENDS. The first CR always fires
+     *  (a stale/edge status never suppresses it); resends are gated on still being
+     *  idle and stop the instant the agent leaves idle (submitted → generating /
+     *  approval). This preserves the win32 lone-CR-swallow handling.
      */
     private scheduleWin32Submit(submitKey: string, initialDelayMs: number): void {
         if (this.win32SubmitTimer) { clearTimeout(this.win32SubmitTimer); this.win32SubmitTimer = null; }
+        const startedAt = Date.now();
+
         const fire = (attempt: number): void => {
             this.win32SubmitTimer = null;
             this.adapter.send_keys(submitKey);
@@ -917,8 +1024,22 @@ export class FsmDriver implements ISpecDriver {
                 fire(attempt + 1);
             }, WIN32_SUBMIT_RESEND_GAP_MS);
         };
-        if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(() => fire(0), initialDelayMs);
-        else fire(0);
+
+        const waitForSettle = (): void => {
+            this.win32SubmitTimer = null;
+            const now = Date.now();
+            const quietFor = now - this.lastWin32InputActivityAt();
+            const waited = now - startedAt;
+            if (quietFor >= WIN32_SUBMIT_SETTLE_MS || waited >= WIN32_SUBMIT_MAX_SETTLE_WAIT_MS) {
+                fire(0);
+                return;
+            }
+            const recheckIn = Math.min(WIN32_SUBMIT_SETTLE_MS - quietFor, WIN32_SUBMIT_SETTLE_POLL_MS);
+            this.win32SubmitTimer = setTimeout(waitForSettle, Math.max(recheckIn, 30));
+        };
+
+        if (initialDelayMs > 0) this.win32SubmitTimer = setTimeout(waitForSettle, initialDelayMs);
+        else waitForSettle();
     }
 
     private handleClickControl(controlId: string, payload?: unknown): void {
@@ -958,6 +1079,28 @@ export class FsmDriver implements ISpecDriver {
         if (!m) return;
         const btn = m.buttons.find(b => b.index === index);
         if (!btn) return;
+
+        const rule = stateById(this.spec, this.currentStateId)?.extract?.buttons;
+        if (rule?.select_mode === 'arrow_keys') {
+            // Cursor-list approval modal (claude-cli new TUI): number keys are
+            // IGNORED — sending `btn.key` ("1\r") types a literal "1" into the
+            // composer and the trailing CR submits it as a chat message. Drive
+            // the cursor from its current row to the target row with arrows,
+            // then confirm. The cursor opens on the first option, so when the
+            // marker isn't detected we step down from row 1 (index - 1).
+            const from = m.buttons.find(b => b.current)?.index ?? 1;
+            const up = rule.cursor_keys?.up ?? '\x1b[A';
+            const down = rule.cursor_keys?.down ?? '\x1b[B';
+            const delta = btn.index - from;
+            const step = delta >= 0 ? down : up;
+            const nav = step.repeat(Math.abs(delta));
+            // Confirm = key_for_index with the (now unused) {index} stripped:
+            // `{index}\r` → `\r`.
+            const confirm = (rule.key_for_index || '\r').replace(/\{index\}/g, '') || '\r';
+            if (nav) this.adapter.send_keys(nav);
+            this.adapter.send_keys(confirm);
+            return;
+        }
         this.adapter.send_keys(btn.key);
     }
 
@@ -1039,7 +1182,8 @@ function summarizeTransition(t: TransitionEval): string[] {
 }
 
 function flattenCond(c: import('./fsm-evaluator.js').CondResult, out: string[], depth: number): void {
-    out.push(`${'  '.repeat(depth)}${c.kind} ${c.detail} = ${c.result}${c.remainingMs ? ` (${c.remainingMs}ms left)` : ''}`);
+    const matched = c.matchedText ? ` matched=${JSON.stringify(c.matchedText)}` : '';
+    out.push(`${'  '.repeat(depth)}${c.kind} ${c.detail} = ${c.result}${c.remainingMs ? ` (${c.remainingMs}ms left)` : ''}${matched}`);
     for (const child of c.children ?? []) flattenCond(child, out, depth + 1);
 }
 

package/src/providers/spec/fsm-evaluator.ts

@@ -16,7 +16,7 @@
 
 import type { Condition, SectionDef } from './types.js';
 import {
-    resolveSections, evaluateCondition, type ResolvedSection, type TraceEntry,
+    resolveSections, evaluateCondition, sectionText, type ResolvedSection, type TraceEntry,
 } from './evaluator.js';
 import {
     type CliSpecV4, type FsmCondition, type FsmTransition,
@@ -42,6 +42,10 @@ export interface CondResult {
     /** Remaining ms until a time-based condition would flip to true. 0 if
      *  already true or not applicable. Lets the UI show a countdown. */
     remainingMs?: number;
+    /** Debug-only: the actual substring a TRUE regex condition matched, so the
+     *  snapshot shows WHAT text the rule fired on — not just which regex. Never
+     *  read by the FSM; purely for the Spec Debug Snapshot. */
+    matchedText?: string;
     children?: CondResult[];
 }
 
@@ -164,7 +168,20 @@ function evalCond(
         const detail = isRegex(cond)
             ? `${(cond as any).section ?? '*'}~/${(cond as any).matches}/`
             : `cursor_above=${(cond as any).cursor_above} changed=${(cond as any).changed}`;
-        return { kind, result, detail };
+        // Debug-only: when a regex condition is TRUE, also capture the substring
+        // it matched so the snapshot can show the exact text the rule fired on.
+        // This re-runs the regex (read-only) and CANNOT change `result` above —
+        // the FSM decision is still entirely owned by evaluateCondition().
+        let matchedText: string | undefined;
+        if (result && isRegex(cond)) {
+            try {
+                const hay = sectionText(sections, (cond as any).section, fullScreen);
+                const re = new RegExp((cond as any).matches, (cond as any).flags ?? 'i');
+                const m = re.exec(hay);
+                if (m && m[0]) matchedText = m[0].replace(/\s+/g, ' ').trim().slice(0, 160);
+            } catch { /* capture is best-effort; never affects result */ }
+        }
+        return matchedText ? { kind, result, detail, matchedText } : { kind, result, detail };
     }
     return { kind: 'all', result: false, detail: 'unknown condition' };
 }