@cspeach/cli 1.1.18 → 1.1.20

package/dist/ui/skill-picker.js

@@ -1,50 +1,8 @@
-import { select } from '@inquirer/prompts';
 /**
- * Sentinel value returned when the user cancels the picker (Esc / Ctrl+C or
- * selects the "↩ cancel" entry). Callers re-prompt rather than dispatching.
- */
-export const PICK_CANCELLED = Symbol('PICK_CANCELLED');
-/**
- * Arrow-key picker for the top-3 classifier candidates. Returns the chosen
- * skill name. Each choice shows the skill, a trimmed reasoning line, and
- * the confidence percentage.
+ * Sentinel value returned when the user cancels a skill picker (Esc / Ctrl+C
+ * or the Cancel entry). Callers re-prompt rather than dispatching.
  *
- * Cancel routes:
- *   - Selecting the "↩ cancel" item returns PICK_CANCELLED
- *   - Pressing Ctrl+C inquirer raises ExitPromptError → we catch and treat as cancel
- *     (without Ctrl+C'ing the whole process)
+ * The old inquirer `pickSkill` that lived here had no callers and was removed
+ * in piece 2 (it rendered a confidence percentage, which §3 drops).
  */
-export async function pickSkill(result) {
-    const candidates = [result.skill, ...result.alternates].slice(0, 3);
-    const reasoning = (result.reasoning ?? '').slice(0, 60);
-    const confidencePct = Math.round(result.confidence * 100);
-    const choices = candidates.map((skill, idx) => {
-        // Top-1 carries the reasoning + confidence; alternates are simple names.
-        if (idx === 0) {
-            const suffix = reasoning
-                ? ` — ${reasoning} (${confidencePct}%)`
-                : ` (${confidencePct}%)`;
-            return { name: `/${skill}${suffix}`, value: skill };
-        }
-        return { name: `/${skill}`, value: skill };
-    });
-    // Cancel entry — user can arrow-down past the candidates and pick this to
-    // go back to the REPL prompt and retype the request.
-    choices.push({ name: '↩ cancel (go back to prompt)', value: '__cancel__' });
-    try {
-        const chosen = await select({
-            message: 'Pick a skill — or ↩ to cancel:',
-            choices,
-        });
-        if (chosen === '__cancel__')
-            return PICK_CANCELLED;
-        return chosen;
-    }
-    catch (err) {
-        // inquirer throws ExitPromptError on Ctrl+C. Treat as cancel, not a crash.
-        const name = err?.name;
-        if (name === 'ExitPromptError')
-            return PICK_CANCELLED;
-        throw err;
-    }
-}
+export const PICK_CANCELLED = Symbol('PICK_CANCELLED');

package/dist/ui/text-input.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 /**
  * PasteSafeTextInput — drop-in replacement for `ink-text-input` (D29,
  * "chewed words" during seed-session paste; 2026-06-12).
@@ -23,12 +23,50 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * Rendering, cursor drawing, placeholder, and mask behaviour are vendored
  * verbatim from ink-text-input v6 (MIT, © Vadim Demedes) minus
  * `highlightPastedText` (Footer never used it).
+ *
+ * Piece 2 (I1, spec §7) — `wrapWidth` switches rendering to the input box:
+ * the value is HARD-WRAPPED here (ui/input-wrap.ts: string-width cells,
+ * graphemes whole, tabs → 2 spaces) and shown as rows that grow to `maxLines`
+ * then scroll with the cursor row visible. ↑/↓ move between rows; the first /
+ * last row hand over to history (onHistoryUp / onHistoryDown). A paste of more
+ * than PASTE_FOLD_LINES lines becomes one atomic chip via onLargePaste.
+ * Without `wrapWidth` everything renders exactly as before (Ctrl+R search,
+ * question cards).
  */
 import { useState, useEffect, useRef } from 'react';
-import { Text, useInput } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import chalk from 'chalk';
-/** An image chip ending exactly at the cursor — Backspace removes it whole. */
-const CHIP_BEFORE_CURSOR = /\[Image #\d+\]$/;
+import stringWidth from 'string-width';
+import { wrapInput, visibleRange, indexAt, pastedLineCount, INPUT_MAX_LINES, PASTE_FOLD_LINES, } from './input-wrap.js';
+import { isNoColor } from '../renderer/color-mode.js';
+import { paint } from '../renderer/theme.js';
+import { applyKeyBurst, stripControlChars } from './key-burst.js';
+/** An atomic chip ending exactly at the cursor — Backspace removes it whole. */
+const CHIP_BEFORE_CURSOR = /\[(?:Image #\d+|Pasted \d+ lines(?: #\d+)?)\]$/;
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/**
+ * Draw the fake cursor at cell `col` of a wrapped display row. After the last
+ * character it takes one cell. NO_COLOR has no inverse video: the end cursor
+ * shows as '_' and a mid-row cursor is not marked.
+ */
+export function drawCursor(line, col) {
+    let acc = 0;
+    let out = '';
+    let placed = false;
+    for (const { segment } of SEGMENTER.segment(line)) {
+        if (!placed && acc === col) {
+            out += isNoColor() ? segment : chalk.inverse(segment);
+            placed = true;
+        }
+        else {
+            out += segment;
+        }
+        acc += stringWidth(segment);
+    }
+    if (!placed)
+        out += isNoColor() ? '_' : chalk.inverse(' ');
+    return out;
+}
 /**
  * Pure windowing core (exported for tests). Given the value length, the
  * cursor position, the display budget (character cells) and whether the
@@ -50,7 +88,7 @@ export function computeDisplayWindow(valueLength, cursorOffset, budget, cursorVi
     const end = Math.min(valueLength, start + budget);
     return { start, end };
 }
-export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, onPasteImage, }) {
+export function PasteSafeTextInput({ value: originalValue, placeholder = '', focus = true, mask, showCursor = true, onChange, onSubmit, onPasteLines, maxDisplayWidth, onPasteImage, wrapWidth, maxLines, heldLines, prompt, onHistoryUp, onHistoryDown, onLargePaste, }) {
     const [cursorOffset, setCursorOffset] = useState((originalValue || '').length);
     // The paste-safety core: synchronous mirrors of value + cursor. The
     // input handler reads/writes THESE, never the (possibly stale) props.
@@ -89,6 +127,10 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         setCursorOffset((previous) => previous > originalValue.length ? originalValue.length : previous);
     }, [originalValue, focus, showCursor]);
     const value = mask ? mask.repeat(originalValue.length) : originalValue;
+    const moveCursor = (i) => {
+        cursorRef.current = i;
+        setCursorOffset(i);
+    };
     // Wave1 live-fix (Bug 1) — display-only horizontal window + control-char
     // flattening. The mirrors, the props, and every handler above operate on
     // the FULL value; only what's painted is windowed, so the row can never
@@ -124,11 +166,27 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         }
     }
     useInput((input, key) => {
-        if (key.upArrow ||
-            key.downArrow ||
-            (key.ctrl && input === 'c') ||
-            key.tab ||
-            (key.shift && key.tab)) {
+        if ((key.ctrl && input === 'c') || key.tab || (key.shift && key.tab))
+            return;
+        if (key.upArrow || key.downArrow) {
+            // Without wrapWidth: ignored, exactly as before (other consumers).
+            if (wrapWidth === undefined)
+                return;
+            // I1 — move between visual rows; the edges hand over to history.
+            const cur = valueRef.current;
+            const w = wrapInput(cur, cursorRef.current, wrapWidth);
+            if (key.upArrow) {
+                if (w.cursorLine > 0)
+                    moveCursor(indexAt(cur, wrapWidth, w.cursorLine - 1, w.cursorCol));
+                else
+                    onHistoryUp?.();
+            }
+            else if (w.cursorLine < w.lines.length - 1) {
+                moveCursor(indexAt(cur, wrapWidth, w.cursorLine + 1, w.cursorCol));
+            }
+            else {
+                onHistoryDown?.();
+            }
             return;
         }
         if (onPasteImage && input === 'v' && (key.ctrl || key.meta)) {
@@ -161,7 +219,18 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
         // Task 7 — complete lines carved out of a newline-bearing paste
         // chunk; reported to the parent AFTER the mirrors are updated.
         let pasteLines = null;
-        if (key.leftArrow) {
+        // Fix round 3 (item 6) — several control keys coalesced into one chunk
+        // (held Backspace / arrows) match no single key; apply each in order.
+        // Pastes carrying newlines keep their own branch below.
+        const burst = !key.backspace && !key.delete && !key.leftArrow && !key.rightArrow
+            && !input.includes('\n') && !input.includes('\r')
+            ? applyKeyBurst(currentValue, cursorRef.current, input)
+            : null;
+        if (burst) {
+            nextValue = burst.value;
+            nextCursorOffset = burst.cursor;
+        }
+        else if (key.leftArrow) {
             if (showCursor)
                 nextCursorOffset--;
         }
@@ -170,7 +239,7 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
                 nextCursorOffset++;
         }
         else if (key.backspace || key.delete) {
-            const chip = onPasteImage
+            const chip = (onPasteImage || onLargePaste)
                 ? CHIP_BEFORE_CURSOR.exec(currentValue.slice(0, cursorRef.current))
                 : null;
             if (chip) {
@@ -197,16 +266,28 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
             // compounds on the fragment — duplicate delivery of a completed
             // line is structurally impossible, and every D29 mirror/echo
             // mechanism below operates exactly as for a plain insert.
-            const cleanInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            const combined = currentValue.slice(0, cursorRef.current) +
-                cleanInput +
-                currentValue.slice(cursorRef.current, currentValue.length);
-            const lastNl = combined.lastIndexOf('\n');
-            pasteLines = combined.slice(0, lastNl).split('\n');
-            nextValue = combined.slice(lastNl + 1);
-            // Cursor lands where the insertion ended, mapped into the fragment
-            // (0 when the paste ended on the newline itself).
-            nextCursorOffset = Math.max(0, cursorRef.current + cleanInput.length - (lastNl + 1));
+            const cleanInput = stripControlChars(input.replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
+            if (onLargePaste && pastedLineCount(cleanInput) > PASTE_FOLD_LINES) {
+                // I1 — a long paste folds to ONE atomic `[Pasted N lines]` chip at the
+                // cursor; the Footer keeps the text and expands it on submit. The
+                // mirror stays single-line, so the D29 invariants hold unchanged.
+                // The text is kept exactly as pasted (a trailing newline included), so
+                // what is typed after the chip still starts on a new line when sent.
+                const chip = onLargePaste(cleanInput);
+                nextValue = currentValue.slice(0, cursorRef.current) + chip + currentValue.slice(cursorRef.current);
+                nextCursorOffset = cursorRef.current + chip.length;
+            }
+            else {
+                const combined = currentValue.slice(0, cursorRef.current) +
+                    cleanInput +
+                    currentValue.slice(cursorRef.current, currentValue.length);
+                const lastNl = combined.lastIndexOf('\n');
+                pasteLines = combined.slice(0, lastNl).split('\n');
+                nextValue = combined.slice(lastNl + 1);
+                // Cursor lands where the insertion ended, mapped into the fragment
+                // (0 when the paste ended on the newline itself).
+                nextCursorOffset = Math.max(0, cursorRef.current + cleanInput.length - (lastNl + 1));
+            }
         }
         else {
             // 2026-09-17 — a single-line field (question form, question modal:
@@ -217,9 +298,9 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
             // stray control characters. Join the lines with one space instead:
             // the whole paste is visible and the answer is clean. Fields that do
             // handle lines (the main prompt) never take this branch.
-            const insert = (input.includes('\n') || input.includes('\r'))
+            const insert = stripControlChars((input.includes('\n') || input.includes('\r'))
                 ? input.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+/g, ' ')
-                : input;
+                : input);
             nextValue =
                 currentValue.slice(0, cursorRef.current) +
                     insert +
@@ -244,6 +325,29 @@ export function PasteSafeTextInput({ value: originalValue, placeholder = '', foc
             onChange(nextValue);
         }
     }, { isActive: focus });
+    if (wrapWidth !== undefined) {
+        // I1 — the input box body: held rows (dim) + the value's rows, windowed to
+        // maxLines with the cursor row visible. Rows already fit (wrapInput), and
+        // truncate-end guarantees no dynamic-frame row can soft-wrap.
+        const heldRows = (heldLines ?? []).flatMap((l) => wrapInput(l, -1, wrapWidth).lines);
+        const w = wrapInput(value, cursorRendered ? cursorOffset : -1, wrapWidth);
+        const all = [...heldRows, ...w.lines];
+        const cursorRow = cursorRendered ? heldRows.length + w.cursorLine : all.length - 1;
+        const { start, end } = visibleRange(all.length, cursorRow, maxLines ?? INPUT_MAX_LINES);
+        const lead = prompt ?? '';
+        const leadWidth = Math.max(1, stringWidth(lead));
+        const indent = ' '.repeat(stringWidth(lead));
+        return (_jsx(Box, { flexDirection: "column", children: all.slice(start, end).map((row, k) => {
+                const r = start + k;
+                const prefix = k > 0
+                    ? indent
+                    : start === 0 ? chalk.bold(paint('sap', lead)) : paint('dim', '…'.padEnd(leadWidth));
+                const body = r < heldRows.length
+                    ? paint('dim', row)
+                    : cursorRendered && r === cursorRow ? drawCursor(row, w.cursorCol) : row;
+                return _jsxs(Text, { wrap: "truncate-end", children: [prefix, body] }, r);
+            }) }));
+    }
     return (_jsx(Text, { children: placeholder
             ? value.length > 0
                 ? renderedValue

package/dist/ui/todo-emitter.js

@@ -23,3 +23,22 @@ import { EventEmitter } from 'node:events';
  * <App> for stdout and corrupts the Ink frame.
  */
 export const todoEmitter = new EventEmitter();
+/*
+ * Piece 2 (spec §4) — second event: todoEmitter.emit('close') at turn end
+ * when the plan is finished; <App> hides the live checklist until the next
+ * 'update'. Emitted only by repl/plan-turn-end.ts.
+ */
+/**
+ * "The plan changed this turn" — set by a TOP-LEVEL todo_set (ctx carries
+ * todoEmitter; subagent ctxs do not), consumed once by emitPlanTurnEnd so a
+ * turn that never touched the plan leaves no close line.
+ */
+let todoSetThisTurn = false;
+export function markTodoSetThisTurn() {
+    todoSetThisTurn = true;
+}
+export function consumeTodoSetThisTurn() {
+    const v = todoSetThisTurn;
+    todoSetThisTurn = false;
+    return v;
+}

package/dist/ui/turn-status-emitter.js

@@ -4,7 +4,7 @@
 // the CC-style "always alive while working" indicator, B5 smoke
 // feedback round 3: fresh-line heartbeats were not enough).
 //
-// Same singleton-emitter pattern as error-emitter / approval-emitter:
+// Same singleton-emitter pattern as approval-emitter / ask-question-emitter:
 // the REPL marks turn start/stop around runTurn (try/finally so a
 // thrown turn can never leave the row stuck), loop.ts narrates the
 // current activity, and <TurnStatus /> renders it in the dynamic Ink
@@ -12,7 +12,7 @@
 // listeners, and every call is a no-op.
 import { EventEmitter } from 'node:events';
 class TurnStatusEmitter extends EventEmitter {
-    state = { active: false, reserved: false, paused: false, label: '', startedAt: 0 };
+    state = { active: false, reserved: false, paused: false, routing: false, routingStartedAt: 0, label: '', startedAt: 0 };
     /**
      * BUG-3 (2026-07-05 live smoke) — the row vanished WHILE the model still
      * worked. Root cause was the twin-turn overlap (BUG-2): turn 1 finished
@@ -25,6 +25,35 @@ class TurnStatusEmitter extends EventEmitter {
      * of blanking the liveness row.
      */
     depth = 0;
+    /**
+     * UI fix round (CLI 1.1.20) — the turn CLOCK pauses while the user is the
+     * one being waited on. Live: a question card waited ~7 min and the receipt
+     * read "420.2s". Every blocking prompt already pauses this emitter (card
+     * slot withFocusClaim, the loop's interactive-tool pause, the save hook),
+     * so the emitter keeps the paused time: `pausedTotal` is a process-wide
+     * monotonic sum of closed pause intervals, `pauseBegan` the open one.
+     * Receipts snapshot pausedMs() at turn start and subtract the growth.
+     */
+    pausedTotal = 0;
+    pauseBegan = null;
+    /** pausedMs() when the current startedAt was set (the live row's base). */
+    pauseBase = 0;
+    closePause(now = Date.now()) {
+        if (this.pauseBegan === null)
+            return;
+        this.pausedTotal += Math.max(0, now - this.pauseBegan);
+        this.pauseBegan = null;
+    }
+    /** Total ms spent paused on user input so far (monotonic, includes an open pause). */
+    pausedMs(now = Date.now()) {
+        return this.pausedTotal + (this.pauseBegan === null ? 0 : Math.max(0, now - this.pauseBegan));
+    }
+    /** The live row's clock: time since the turn started, less time paused on the user. */
+    activeElapsedMs(now = Date.now()) {
+        if (!this.state.active)
+            return 0;
+        return Math.max(0, now - this.state.startedAt - (this.pausedMs(now) - this.pauseBase));
+    }
     /**
      * BUG-2b — mark a dispatch in-flight before the async pre-turn work runs.
      * Invisible (no spinner); isBusy() reports it so the submit guard can
@@ -36,6 +65,20 @@ class TurnStatusEmitter extends EventEmitter {
         this.state = { ...this.state, reserved: true };
         this.emit('change', this.state);
     }
+    /** Fix round 3 (item 8) — the classifier round-trip started. */
+    routingStart() {
+        if (this.state.routing)
+            return;
+        this.state = { ...this.state, routing: true, routingStartedAt: Date.now() };
+        this.emit('change', this.state);
+    }
+    /** Fix round 3 (item 8) — routing finished (any outcome). */
+    routingEnd() {
+        if (!this.state.routing)
+            return;
+        this.state = { ...this.state, routing: false, routingStartedAt: 0 };
+        this.emit('change', this.state);
+    }
     /** BUG-2b — release the pre-turn reservation (dispatch lifecycle ended). */
     release() {
         if (!this.state.reserved)
@@ -48,11 +91,25 @@ class TurnStatusEmitter extends EventEmitter {
     isBusy() {
         return this.state.active || this.state.reserved;
     }
+    /**
+     * Counts top-level turns (depth 0 → 1). card-slot's focus claim keys its
+     * refcount on this so a claim left unsettled by an earlier turn (Ctrl+C
+     * mid-card) cannot suppress, or fake, a later turn's resume.
+     */
+    turnCount = 0;
+    /** Identifies the current top-level turn; nested start() keeps it. */
+    turnGeneration() {
+        return this.turnCount;
+    }
     start(label = 'thinking') {
         // BUG-3 — nest instead of replace so an overlapping stop() can't blank
         // the row (see the `depth` field doc). `...this.state` preserves the
         // reserved flag set by reserve() at dispatch start.
+        if (this.depth === 0)
+            this.turnCount++;
         this.depth++;
+        this.closePause();
+        this.pauseBase = this.pausedMs();
         this.state = { ...this.state, active: true, paused: false, label, startedAt: Date.now() };
         this.emit('change', this.state);
     }
@@ -61,6 +118,7 @@ class TurnStatusEmitter extends EventEmitter {
     activity(label) {
         if (!this.state.active)
             return;
+        this.closePause();
         this.state = { ...this.state, label, paused: false };
         this.emit('change', this.state);
     }
@@ -68,6 +126,7 @@ class TurnStatusEmitter extends EventEmitter {
     pause() {
         if (!this.state.active || this.state.paused)
             return;
+        this.pauseBegan = Date.now();
         this.state = { ...this.state, paused: true };
         this.emit('change', this.state);
     }
@@ -75,6 +134,7 @@ class TurnStatusEmitter extends EventEmitter {
     resume() {
         if (!this.state.active || !this.state.paused)
             return;
+        this.closePause();
         this.state = { ...this.state, paused: false };
         this.emit('change', this.state);
     }
@@ -88,6 +148,9 @@ class TurnStatusEmitter extends EventEmitter {
         this.depth--;
         if (this.depth > 0)
             return;
+        // A turn ended while a card waited (Ctrl+C / Esc on it): the wait was
+        // still the user's time, not the turn's.
+        this.closePause();
         this.state = { ...this.state, active: false, paused: false, label: '', startedAt: 0 };
         this.emit('change', this.state);
     }

package/dist/ui/turn-status.js

@@ -1,33 +1,24 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
 import { Text } from 'ink';
 import { turnStatusEmitter } from './turn-status-emitter.js';
+import { roleProps } from './role-props.js';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const TICK_MS = 250;
-const PEACH = '#FFCBA4';
 function fmtElapsed(ms) {
-    const s = Math.floor(ms / 1000);
+    // `now` is sampled at mount / on each tick, so the first frame after a turn
+    // starts can precede startedAt — never show "-1s".
+    const s = Math.max(0, Math.floor(ms / 1000));
     if (s < 60)
         return `${s}s`;
     return `${Math.floor(s / 60)}m ${s % 60}s`;
 }
-/**
- * Task 5 (ux-wave2) — cap for the in-progress-todo strip appended to the
- * status row. The row already carries spinner + label + elapsed + hint;
- * 40 chars of todo text keeps the whole line comfortably inside a normal
- * terminal (and wrap="truncate-end" clips the rest regardless).
- */
-export const TODO_STRIP_MAX = 40;
-/** ≤40 chars, '…' as the 40th when clipped. Exported for tests. */
-export function truncateTodoStrip(text) {
-    return text.length > TODO_STRIP_MAX ? `${text.slice(0, TODO_STRIP_MAX - 1)}…` : text;
-}
 /**
  * Persistent turn-status row (2026-06-07) — lives in the DYNAMIC Ink
  * frame just above the Footer, so it repaints with the frame and
  * vanishes the instant the turn ends. While a turn is in flight:
  *
- *   ⠹ sap_create_object · 34s · ctrl+c to interrupt
+ *   ⠹ Reading ZCL_ORDER_API · 34s · ctrl+c to stop
  *
  * The label follows the loop's narration (thinking / tool name /
  * writing response / save check). Its presence answers "is it still
@@ -38,7 +29,7 @@ export function truncateTodoStrip(text) {
  * cursor #25 class of bug came from a raw-stdout spinner; this
  * component cannot reproduce it). Guard: ink-cursor-invariant test.
  */
-export function TurnStatus({ inProgressTodo } = {}) {
+export function TurnStatus() {
     const [state, setState] = useState(turnStatusEmitter.snapshot());
     const [frame, setFrame] = useState(0);
     const [now, setNow] = useState(Date.now());
@@ -56,19 +47,25 @@ export function TurnStatus({ inProgressTodo } = {}) {
         // repaints the dynamic frame every 250ms and overdraws an inquirer
         // approval picker / churns the Ink ask_question modal (stacked borders,
         // lost keypress). The row resumes the instant the user answers.
-        if (!state.active || state.paused)
+        const routingOnly = state.routing && !state.active;
+        if ((!state.active || state.paused) && !routingOnly)
             return;
         const interval = setInterval(() => {
             setFrame((f) => (f + 1) % FRAMES.length);
             setNow(Date.now());
         }, TICK_MS);
         return () => clearInterval(interval);
-    }, [state.active, state.paused]);
+    }, [state.active, state.paused, state.routing]);
+    // Fix round 3 (item 8) — routing (no turn yet): spinner + "routing…" +
+    // elapsed, no "ctrl+c to stop" (there is no turn to stop).
+    if (state.routing && !state.active) {
+        return (_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { ...roleProps('sap'), children: [FRAMES[frame], " "] }), _jsx(Text, { children: "routing\u2026" }), _jsxs(Text, { ...roleProps('dim'), children: [" \u00B7 ", fmtElapsed(now - state.routingStartedAt)] })] }));
+    }
     if (!state.active || state.paused)
         return null;
     // wrap="truncate-end" (wave1 live-fix, Bug 1): this row sits in the
     // dynamic frame too — a long tool label must clip, never soft-wrap
     // (wrapped dynamic-frame rows break Ink's erase accounting and leak
     // stale rows into scrollback).
-    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { color: PEACH, children: [FRAMES[frame], " "] }), _jsx(Text, { children: state.label }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", fmtElapsed(now - state.startedAt), " \u00B7 ctrl+c to interrupt"] }), inProgressTodo ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u00B7 " }), _jsxs(Text, { color: PEACH, children: ["\u25B6 ", truncateTodoStrip(inProgressTodo)] })] })) : null] }));
+    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsxs(Text, { ...roleProps('sap'), children: [FRAMES[frame], " "] }), _jsx(Text, { children: state.label }), _jsxs(Text, { ...roleProps('dim'), children: [" \u00B7 ", fmtElapsed(turnStatusEmitter.activeElapsedMs(now)), " \u00B7 ctrl+c to stop"] })] }));
 }

package/dist/ui/use-card-request.js

@@ -0,0 +1,44 @@
+// src/ui/use-card-request.ts
+//
+// The one "a request arrives → mount its card → resolve → clear" hook for the
+// card slot (piece 2 §1.6). Same rules the ask/approval listeners in app.tsx
+// learned the hard way:
+//   - a replacing request resolves the earlier one CANCELLED (no leaked promise);
+//   - `finish` clears only if the request still owns the slot;
+//   - unmount resolves an open request CANCELLED so a turn never wedges.
+import { useEffect, useRef, useState } from 'react';
+export function useCardRequest(subscribe, cancelled, onArrive) {
+    const [pending, setPending] = useState(null);
+    const [seq, setSeq] = useState(0);
+    const ref = useRef(null);
+    const arriveRef = useRef(onArrive);
+    arriveRef.current = onArrive;
+    useEffect(() => {
+        const unsubscribe = subscribe((req) => {
+            const prev = ref.current;
+            if (prev)
+                prev.resolve(cancelled);
+            ref.current = req;
+            setSeq((s) => s + 1);
+            arriveRef.current?.();
+            setPending(req);
+        });
+        return () => {
+            unsubscribe();
+            const open = ref.current;
+            ref.current = null;
+            if (open)
+                open.resolve(cancelled);
+        };
+        // Mount-once by design: subscribe/cancelled are stable for the App's life.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const finish = (req, result) => {
+        req.resolve(result);
+        if (ref.current === req) {
+            ref.current = null;
+            setPending(null);
+        }
+    };
+    return { pending, seq, finish };
+}