@cspeach/cli 1.1.18 → 1.1.20

package/dist/renderer/widget-fallback.js

@@ -1,78 +1,71 @@
+// src/renderer/widget-fallback.ts
+//
+// Piece 2 §9/§5: the off-Ink question widget is a plain card in the confirm-
+// card frame — QUESTION chip on the top edge, the question in bold, dim
+// context, numbered options, and how to answer on the bottom edge. Every
+// line is exactly `width` cells (uiWidth() by default); text is sanitised
+// and wrapped BEFORE colouring so no cut can land inside an escape code and
+// model text can never drive the terminal.
+//
+// The frame geometry mirrors CardFrame/edgeSegments (ui/widgets/confirm-card.tsx)
+// as plain strings: that module is an Ink component, and this path runs off
+// Ink (piped / CI), so it must not pull Ink and React in.
 import chalk from 'chalk';
-// Inner content width — the box becomes content+4 total width.
-const CONTENT_WIDTH = 55;
-const TOTAL_WIDTH = CONTENT_WIDTH + 4; // left "┃ " + content + " ┃"
-function padLine(s) {
-    // Pad to CONTENT_WIDTH visible chars, preserve ANSI codes if any
-    const ANSI = /\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]/g;
-    const visible = s.replace(ANSI, '');
-    const padding = Math.max(0, CONTENT_WIDTH - visible.length);
-    return s + ' '.repeat(padding);
-}
+import stringWidth from 'string-width';
+import { paint, chip } from './theme.js';
+import { getBoxChars } from '../ui/ascii-chars.js';
+import { uiWidth, truncateToWidth } from './ui-width.js';
+import { ANSI_RE } from './tool-labels.js';
+import { sanitizeControlChars } from './sanitize.js';
+const vis = (s) => stringWidth(s.replace(ANSI_RE, ''));
+/** Word-wrap plain text to `width` cells; a single over-long word is truncated. */
 function wrap(text, width) {
-    if (text.length <= width)
-        return [text];
-    const words = text.split(/\s+/);
+    const words = sanitizeControlChars(text).replace(/\t/g, '  ').split(/\s+/).filter((w) => w.length > 0);
     const lines = [];
-    let current = '';
-    for (const word of words) {
-        if (current.length === 0) {
-            current = word;
-        }
-        else if (current.length + 1 + word.length <= width) {
-            current += ' ' + word;
-        }
+    let cur = '';
+    for (const raw of words) {
+        const word = stringWidth(raw) > width ? truncateToWidth(raw, width) : raw;
+        if (cur === '')
+            cur = word;
+        else if (stringWidth(cur) + 1 + stringWidth(word) <= width)
+            cur += ' ' + word;
         else {
-            lines.push(current);
-            current = word;
+            lines.push(cur);
+            cur = word;
         }
     }
-    if (current.length > 0)
-        lines.push(current);
-    return lines;
+    if (cur !== '')
+        lines.push(cur);
+    return lines.length > 0 ? lines : [''];
 }
-/**
- * Render a question widget as a heavy-bordered chalk card for classic-mode
- * REPL output. Called by the pipeline's widget-fallback path when
- * shouldUseInk() is false OR when we're rendering the default text
- * fallback for the widget system.
- *
- * Uses heavy box-drawing chars (┏ ┓ ┗ ┛ ━ ┃) so the question card
- * visually distinguishes from the light-bordered tool-widget boxes.
- */
-export function renderQuestionCard(widget) {
-    const border = chalk.cyan;
-    const dim = chalk.dim;
-    const top = border('┏━ ' + chalk.cyan.bold(`Question: ${widget.id}`) + ' ' + '━'.repeat(Math.max(0, CONTENT_WIDTH - widget.id.length - 12)) + '━┓');
-    const bottom = border('┗' + '━'.repeat(TOTAL_WIDTH - 2) + '┛');
+export function renderQuestionCard(widget, width = uiWidth(), box = getBoxChars()) {
+    const inner = Math.max(10, width - 4); // "│ " + content + " │"
+    const row = (plain, style = (s) => s) => paint('frame', box.v) + ' ' + style(plain) + ' '.repeat(Math.max(0, inner - stringWidth(plain))) + ' ' + paint('frame', box.v);
+    // Top edge: ╭─<chip> <id> ───╮  (2 + chip + 1 + id + 1 + fill + 1 = width)
+    const tag = chip('QUESTION');
+    const idText = truncateToWidth(sanitizeControlChars(widget.id), Math.max(1, width - vis(tag) - 6));
+    const topFill = Math.max(0, width - (2 + vis(tag) + 1 + stringWidth(idText) + 1) - 1);
+    const top = paint('frame', box.tl + box.h) + tag + ' ' + chalk.bold(idText) + ' ' + paint('frame', box.h.repeat(topFill) + box.tr);
+    // Bottom edge: ╰───── <note> ─╯  (1 + fill + 1 + note + 1 + 1 + 1 = width)
+    const noteText = widget.kind === 'choice' ? 'reply with a number'
+        : widget.kind === 'multi' ? 'reply with numbers, comma-separated'
+            : 'reply in your next message';
+    const note = truncateToWidth(noteText, Math.max(1, width - 8));
+    const bottomFill = Math.max(0, width - stringWidth(note) - 5);
+    const bottom = paint('frame', box.bl + box.h.repeat(bottomFill)) + ' ' + paint('dim', note) + ' ' + paint('frame', box.h + box.br);
     const lines = [top];
-    lines.push(border('┃ ') + padLine('') + border(' ┃'));
-    // Question text (wrapped)
-    for (const line of wrap(widget.question, CONTENT_WIDTH)) {
-        lines.push(border('┃ ') + padLine(chalk.bold(line)) + border(' ┃'));
-    }
-    // Optional context
-    if (widget.context) {
-        lines.push(border('┃ ') + padLine('') + border(' ┃'));
-        for (const line of wrap(`Context: ${widget.context}`, CONTENT_WIDTH)) {
-            lines.push(border('┃ ') + padLine(dim(line)) + border(' ┃'));
-        }
-    }
-    // Choice list for choice/multi kinds
+    for (const l of wrap(widget.question, inner))
+        lines.push(row(l, (s) => chalk.bold(s)));
+    if (widget.context)
+        for (const l of wrap(widget.context, inner))
+            lines.push(row(l, (s) => paint('dim', s)));
     if (widget.kind === 'choice' || widget.kind === 'multi') {
-        lines.push(border('┃ ') + padLine('') + border(' ┃'));
-        const header = widget.kind === 'choice' ? 'Pick one:' : 'Pick any (comma-separate):';
-        lines.push(border('┃ ') + padLine(chalk.bold(header)) + border(' ┃'));
-        const choices = widget.choices ?? [];
-        for (let i = 0; i < choices.length; i++) {
-            const choice = choices[i];
-            const line = `[${i + 1}] ${choice.label}`;
-            for (const wrapped of wrap(line, CONTENT_WIDTH)) {
-                lines.push(border('┃ ') + padLine(wrapped) + border(' ┃'));
-            }
-        }
+        lines.push(row(''));
+        (widget.choices ?? []).forEach((c, i) => {
+            for (const l of wrap(`${i + 1}. ${c.label}`, inner))
+                lines.push(row(l));
+        });
     }
-    lines.push(border('┃ ') + padLine('') + border(' ┃'));
     lines.push(bottom);
     return '\n' + lines.join('\n') + '\n';
 }

package/dist/repl/bracketed-paste.js

@@ -39,6 +39,7 @@
  *    classic REPL path (non-Ink). Ink mode uses its own input component.
  */
 import { Transform } from 'node:stream';
+import { markPastedChunk } from './paste-marker.js';
 /** DEC Private Mode 2004 — enable bracketed paste. */
 export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h';
 /** DEC Private Mode 2004 — disable bracketed paste. */
@@ -164,6 +165,8 @@ export class BracketedPasteDecoder extends Transform {
         // End of stream. If we were still inside a paste (unterminated),
         // flush the buffered content so it's not lost.
         if (this.inPaste && this.pasteBuf.length > 0) {
+            if (this.emitVerbatim)
+                markPastedChunk(this.pasteBuf.toString('utf8'));
             this.push(this.emitVerbatim ? this.pasteBuf : this.collapseNewlines(this.pasteBuf));
             this.pasteBuf = Buffer.alloc(0);
             this.inPaste = false;
@@ -196,8 +199,11 @@ export class BracketedPasteDecoder extends Transform {
                     // `\r` that arrived as its own stdin chunk INSIDE the span was
                     // accumulated here instead of reaching Ink's parseKeypress,
                     // which would have flagged it key.return and submitted.
-                    if (this.pasteBuf.length > 0)
+                    if (this.pasteBuf.length > 0) {
+                        // Piece 2 — tell App this chunk was pasted, not typed (the `?` trigger).
+                        markPastedChunk(this.pasteBuf.toString('utf8'));
                         this.push(this.pasteBuf);
+                    }
                 }
                 else {
                     this.push(this.collapseNewlines(this.pasteBuf));

package/dist/repl/builtin-commands.js

@@ -4,13 +4,22 @@
  * Extracted from slash-picker.ts (2026-06-11) so the router layer
  * (src/router/classifier.ts) can distinguish "user typed a builtin with
  * arguments" (e.g. `/help me`) from "user typed an unknown skill"
- * WITHOUT importing the inquirer-backed picker module. Pure data — no
- * runtime dependencies.
+ * WITHOUT importing the inquirer-backed picker module. Pure data plus one
+ * read of the process-wide cost display mode (cost/credits.ts); no
+ * inquirer, so the router can import it.
  */
+import { creditsActive } from '../cost/credits.js';
+export const COST_DESCRIPTION_USD = 'Show this session\'s spend so far ($ and tokens)';
+export const COST_DESCRIPTION_CREDITS = 'Show the credits this session has used so far';
+/** Piece 2 §10: managed customers see credits, never "$" (cost/display-mode.ts). */
+export function costCommandDescription() {
+    return creditsActive() ? COST_DESCRIPTION_CREDITS : COST_DESCRIPTION_USD;
+}
 export const BUILTIN_ENTRIES = [
-    { name: '/cancel', description: 'Cancel the current pre-filled command, return to a clean prompt' },
-    { name: '/cost', description: 'Show this session\'s API spend so far ($ + token breakdown)' },
-    { name: '/compact', description: 'Summarise older turns into a compact context block — cuts subsequent turn cost by 80-90%' },
+    // Piece 2: /cancel is not listed — it exists only in the classic loop
+    // (repl.tsx), and Esc / Ctrl+C already cancel under Ink.
+    { name: '/cost', get description() { return costCommandDescription(); } },
+    { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
     { name: '/export', description: 'Export the signable session audit record — /export audit [filename]' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
@@ -22,19 +31,21 @@ export const BUILTIN_ENTRIES = [
     { name: '/recap', description: 'Show the session recap (last session · open tasks · plan progress)' },
     { name: '/reset', description: 'Reset routing (alias)' },
     { name: '/rewind', description: 'Undo a write from this session — restore an object to a pre-write snapshot (Esc Esc)' },
-    { name: '/ui', description: 'View or change rendering mode (auto / ink / classic)' },
+    { name: '/ui', description: 'View or change rendering mode (auto / ink), or the look: /ui look panels|legacy' },
     { name: '/reroute', description: 'Re-dispatch the previous prompt to a different skill' },
     { name: '/transport', description: 'View or set the active transport for this session' },
     { name: '/safety-mode', description: 'Toggle structured Forge Rule confirmation cards (on / off / status)' },
 ];
 /**
  * Builtin command heads for routing checks. Superset of BUILTIN_ENTRIES:
- * `/files` is a real REPL builtin (repl.tsx handles it in both paths) but
- * is deliberately absent from the picker catalogue, so it's added here.
+ * `/files` is a real REPL builtin (repl.tsx handles it in both paths) and
+ * `/cancel` is still handled by the classic loop, but neither is listed in the
+ * picker catalogue, so both are added here.
  */
 const BUILTIN_HEADS = new Set([
     ...BUILTIN_ENTRIES.map((e) => e.name),
     '/files',
+    '/cancel',
 ]);
 /** True when `head` (e.g. '/help', as typed, any case) is a builtin command. */
 export function isBuiltinCommandHead(head) {

package/dist/repl/credential-handover-gate.js

@@ -0,0 +1,28 @@
+/**
+ * Credential handover gate (L1-6 R1-6, owner decision 2026-09-21).
+ *
+ * A tool that hands the stored SAP login to a local child process (today only
+ * `fiori_preview` start) ALWAYS raises a human prompt the first time per
+ * session per alias — even as the first mutating call of a turn, where the
+ * Rule 8 batch gate stays silent, and whatever auto_approve says. Later calls
+ * for the same alias in the same session do not re-ask.
+ *
+ * The gate itself lives in agent/tool-dispatch.ts; a tool opts in through
+ * `Tool.credentialHandover`. This module only remembers the approvals.
+ *
+ * Module-scope, per CLI process, never persisted: a new CLI process, or a new
+ * session id inside one, asks again. Tests call the reset in beforeEach.
+ */
+const approved = new Set();
+function key(sessionId, alias) {
+    return `${sessionId ?? '(no session)'}\u0000${alias}`;
+}
+export function isCredentialHandoverApproved(sessionId, alias) {
+    return approved.has(key(sessionId, alias));
+}
+export function markCredentialHandoverApproved(sessionId, alias) {
+    approved.add(key(sessionId, alias));
+}
+export function __resetCredentialHandoverGateForTests() {
+    approved.clear();
+}

package/dist/repl/current-transport.js

@@ -57,6 +57,19 @@ export function noteWriteTransport(trkorr) {
         return;
     globalStore.update({ lastWriteTransport: trkorr });
 }
+/**
+ * Footer-only wire (UI fix round, 1.1.20): record a transport a read-only
+ * lookup CONFIRMED (sap_transport_for_object found the object locked in one
+ * open transport the connected user may write to). Live incident: the user
+ * named S4HK903731, the lookup confirmed it, and the footer still read
+ * "no transport". Like noteWriteTransport it never touches the session write
+ * pointer — the lookup is read-only and must not change where writes go.
+ */
+export function noteConfirmedTransport(trkorr) {
+    if (!trkorr)
+        return;
+    globalStore.update({ confirmedTransport: trkorr });
+}
 /**
  * Handles the `/transport [<trkorr>|clear]` slash command. Returns user-facing
  * status text. Mirrors the shape of handleSafetyModeCommand in safety-mode-state.ts.

package/dist/repl/early-line-buffer.js

@@ -34,10 +34,13 @@ export function stripBom(s) {
  * Call once, immediately after readline creation, BEFORE any awaits —
  * piped data starts flowing on the next tick.
  */
-export function attachEarlyLineBuffer(rl) {
+export function attachEarlyLineBuffer(rl, input) {
     const queue = [];
     let firstLine = true;
-    let isClosed = false;
+    // Round 8 item 3 — the piped-prompt probe (lib/piped-prompt.ts) can see an
+    // EMPTY stdin reach EOF before readline exists; readline then never emits
+    // 'close'. An input that already ended counts as closed from the start.
+    let isClosed = input?.readableEnded === true;
     rl.on('line', (l) => {
         let line = String(l);
         if (firstLine) {

package/dist/repl/file-picker.js

@@ -139,6 +139,25 @@ function textActionsFor() {
         { label: '/abap-explain               (plain-language explanation)', command: '/abap-explain' },
     ];
 }
+/**
+ * Three discrete outcomes a `/files` invocation can produce. The caller
+ * (REPL handler) needs to distinguish them because the right UX differs:
+ *   - 'command'   — user picked a file + action; REPL dispatches it.
+ *   - 'empty'     — workspace has no files; REPL prints a helpful
+ *                   listing ("drop something here to start").
+ *   - 'cancelled' — user pressed Cancel or Ctrl+C; REPL prints NOTHING
+ *                   and returns to the main prompt cleanly.
+ *
+ * Earlier revision returned `string | null` for all three, which
+ * collapsed 'empty' and 'cancelled' into the same null path — the REPL
+ * then dumped the full file list every time the user cancelled. This
+ * tagged result removes the conflation.
+ */
+/** Action menu for a picked file (shared by the inquirer and Ink paths). */
+function actionsForFile(file) {
+    const designShape = file.artefactType === 'design' ? detectDesignShape(file.path) : 'unknown';
+    return file.kind === 'text' ? textActionsFor() : envelopeActionsFor(file.artefactType, designShape);
+}
 /**
  * Open the picker. Returns one of three tagged outcomes — see
  * `FilePickerResult`. Caller is responsible for dispatching the
@@ -153,11 +172,15 @@ function textActionsFor() {
  * slips through and exits the REPL silently. One guard around the
  * whole flow avoids that gap.
  */
-export async function openFilePicker() {
+export async function openFilePicker(opts = {}) {
     const files = await listProjectFiles();
     if (files.length === 0) {
         return { kind: 'empty' };
     }
+    // Piece 2 §6.4 — under Ink, cards in the card slot; inquirer never runs
+    // while Ink owns the terminal. Same result shapes as the inquirer flow.
+    if (opts.ink)
+        return openFilePickerInk(files);
     try {
         return await withInquirer(async () => {
             // Step 1 — pick a file.
@@ -186,17 +209,8 @@ export async function openFilePicker() {
             const pickedFile = files.find((f) => f.filename === fileResult);
             if (!pickedFile)
                 return { kind: 'cancelled' };
-            // Step 2 — pick an action for the file. Action menu depends on
-            // file kind: envelopes get promote/inspect, text files get the
-            // skill-input commands that ingest the file contents. For design
-            // envelopes, additionally inspect the object list to pick the
-            // right BUILD skill recommendation (RAP vs classic).
-            const designShape = pickedFile.artefactType === 'design'
-                ? detectDesignShape(pickedFile.path)
-                : 'unknown';
-            const actionsList = pickedFile.kind === 'text'
-                ? textActionsFor()
-                : envelopeActionsFor(pickedFile.artefactType, designShape);
+            // Step 2 — pick an action for the file (see actionsForFile).
+            const actionsList = actionsForFile(pickedFile);
             const action = await select({
                 message: `What with ${pickedFile.filename}?`,
                 choices: [
@@ -217,3 +231,31 @@ export async function openFilePicker() {
         return { kind: 'cancelled' };
     }
 }
+async function openFilePickerInk(files) {
+    const { withFocusClaim } = await import('../ui/card-slot.js');
+    const { filesCardEmitter } = await import('../ui/files-card-emitter.js');
+    const { askConfirm } = await import('../ui/confirm-request.js');
+    const picked = await withFocusClaim(() => filesCardEmitter.requestPick({
+        id: 'files',
+        title: 'Pick a project file',
+        items: files.map((f) => ({ value: f.filename, label: f.filename, detail: `${f.artefactType} v${f.version ?? '?'}` })),
+    }));
+    if (picked.value == null)
+        return { kind: 'cancelled' };
+    const pickedFile = files.find((f) => f.filename === picked.value);
+    if (!pickedFile)
+        return { kind: 'cancelled' };
+    const res = await askConfirm({
+        id: 'files-action',
+        tag: 'QUESTION',
+        title: `What with ${pickedFile.filename}?`,
+        choices: [
+            ...actionsForFile(pickedFile).map((a) => ({ value: a.command, label: a.label })),
+            { value: CANCEL_VALUE, label: 'Cancel' },
+        ],
+        initial: 0,
+    }, { trace: false });
+    if (res.value == null || res.value === CANCEL_VALUE)
+        return { kind: 'cancelled' };
+    return { kind: 'command', command: `${res.value} @${pickedFile.filename}` };
+}

package/dist/repl/ink-stdin-guard.js

@@ -41,6 +41,7 @@
  * path (no regression, same as the classic-mode caveat).
  */
 import { BracketedPasteDecoder } from './bracketed-paste.js';
+import { splitControlKeys } from '../ui/key-burst.js';
 export class InkStdinPasteGuard extends BracketedPasteDecoder {
     /**
      * Mirror the REAL stdin's TTY-ness (the base class hardcodes true for
@@ -52,6 +53,71 @@ export class InkStdinPasteGuard extends BracketedPasteDecoder {
     constructor() {
         super({ emitVerbatim: true });
     }
+    /** Keys split off a coalesced control-key chunk, handed out one per read(). */
+    keyQueue = [];
+    /**
+     * Fix round 3 (item 6) — ConPTY coalesces held Backspace / arrow repeats
+     * into ONE read, and Ink parses a chunk as ONE key (three Lefts moved the
+     * cursor once; DEL bytes were inserted as text). Ink drains with a
+     * `while (read() !== null)` loop (App.js handleReadable), so returning one
+     * key per read() gives every key its own useInput event.
+     */
+    /**
+     * Round 4 (item 6) — Ink drained a whole split burst in ONE synchronous
+     * loop, so 80+ keys meant 80+ nested React updates and React printed
+     * "Maximum update depth exceeded" into the transcript. The guard now yields
+     * between keys: after a burst key it ends the drain (read() → null) and
+     * re-signals 'readable' on the next macrotask, so React commits each key
+     * before the next one. Every key still reaches Ink as its own event.
+     */
+    yieldNext = false;
+    resumeScheduled = false;
+    scheduleResume() {
+        if (this.resumeScheduled)
+            return;
+        this.resumeScheduled = true;
+        setImmediate(() => {
+            this.resumeScheduled = false;
+            if (!this.destroyed)
+                this.emit('readable');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    read(size) {
+        // Round 6 item 1 — Node's Readable calls read(0) itself (to refill the
+        // buffer when new data arrives, e.g. typing right after a burst) and
+        // DISCARDS the result. Handing it a queued key threw that key away: one
+        // Backspace of the burst was lost. read(0) never takes a key or data.
+        if (size === 0)
+            return super.read(0);
+        if (this.keyQueue.length > 0) {
+            if (this.yieldNext) {
+                this.yieldNext = false;
+                this.scheduleResume();
+                return null;
+            }
+            this.yieldNext = true;
+            return this.keyQueue.shift();
+        }
+        if (this.yieldNext) {
+            // The burst's last key was just handed out: let React commit it
+            // before anything that arrived after the burst.
+            this.yieldNext = false;
+            if (this.readableLength > 0) {
+                this.scheduleResume();
+                return null;
+            }
+        }
+        const chunk = super.read(size);
+        if (typeof chunk !== 'string')
+            return chunk;
+        const keys = splitControlKeys(chunk);
+        if (keys.length <= 1)
+            return chunk;
+        this.keyQueue = keys.slice(1);
+        this.yieldNext = true;
+        return keys[0];
+    }
     /** Ink calls stdin.ref()/unref() around raw-mode enable/disable. */
     ref() {
         process.stdin.ref?.();

package/dist/repl/inquirer-guard.js

@@ -26,7 +26,14 @@
  * function — no pause, no suppress — which is safe because there is no
  * main readline to disturb.
  */
-import { clearActiveSpinner } from '../renderer/tool-widget.js';
+import { suspendActiveSpinner } from '../renderer/tool-widget.js';
+import { resetTtyStdin } from './reset-tty-stdin.js';
+/**
+ * Live fix 2026-09-26 (fix 8) — true while the REPL readline's input is
+ * unpiped from stdin for an inquirer prompt (sequence). Re-piped by the
+ * final release.
+ */
+let inputDetached = false;
 let state = null;
 /**
  * UX-5 #4 (2026-06-12) — sequence-scoped (debounced) release.
@@ -66,6 +73,12 @@ export const RELEASE_DEBOUNCE_MS = 50;
 let pendingRelease = null;
 /** Re-entrancy depth — release is scheduled only when the OUTERMOST call exits. */
 let activeDepth = 0;
+/**
+ * Piece 2 §11.3 — one spinner resume per prompt of the current sequence, all
+ * fired by the sequence's release (symmetric suspend/resume, fix round 1: a
+ * spinner replaced between prompts is resumed too, not left suspended).
+ */
+let spinnerResumes = [];
 function cancelPendingRelease() {
     if (pendingRelease) {
         clearTimeout(pendingRelease);
@@ -77,13 +90,16 @@ function cancelPendingRelease() {
  * callback must flip the same boolean the readline 'close' handler
  * inspects — otherwise the guard has no effect.
  */
-export function registerReadline(rl, setSuppress) {
-    state = { rl, setSuppress };
+export function registerReadline(rl, setSuppress, opts = {}) {
+    state = { rl, setSuppress, input: opts.input, stdin: opts.stdin ?? process.stdin };
+    inputDetached = false;
 }
 /** Clear the guard — call when the REPL is shutting down. */
 export function unregisterReadline() {
     cancelPendingRelease();
     activeDepth = 0;
+    spinnerResumes = [];
+    inputDetached = false;
     state = null;
 }
 /**
@@ -106,18 +122,30 @@ export function unregisterReadline() {
 export async function withInquirer(fn) {
     if (!state)
         return fn();
-    const { rl, setSuppress } = state;
-    // 2026-05-01: silence any active tool-dispatch spinner so it doesn't fight
+    const { rl, setSuppress, input, stdin } = state;
+    // 2026-05-01: pause any active tool-dispatch spinner so it doesn't fight
     // inquirer for stdout/cursor. The spinner uses \r + erase-line every 80ms,
     // which collides with inquirer's prompt rendering — visible as ghost-text
     // and a cursor that hides under the rotating frame while the user types.
-    clearActiveSpinner();
+    // Piece 2 §11.3: SUSPEND (not stop) — the tool is still running after the
+    // prompt, so the spinner comes back when the terminal is released.
+    spinnerResumes.push(suspendActiveSpinner());
     // UX-5 #4 — continuing an ask SEQUENCE: a release from the previous
     // prompt is still pending, so cancel it. The readline stays parked
     // (paused + close-suppressed) across the gap — no stale-line repaint
     // between consecutive prompts.
     cancelPendingRelease();
     activeDepth++;
+    // Live fix 2026-09-26 (fix 8) — detach the REPL readline's input from
+    // stdin for the prompt. rl.pause() only stops the decoder's READABLE side:
+    // stdin kept writing into it, so every key typed into the prompt was
+    // buffered there and replayed into the REPL line on release (echoed onto
+    // the spinner line: `⠋ thinking…https://…`). Done BEFORE the listener
+    // snapshot below so the pipe's own 'data' handler is never re-attached.
+    if (input && !inputDetached) {
+        stdin.unpipe(input);
+        inputDetached = true;
+    }
     // 2026-05-08: snapshot stdin 'data' / 'keypress' listeners BEFORE the
     // inquirer prompt runs. Some inquirer widgets (notably `search`, used
     // by /files step 1) strip ALL listeners on cleanup — including
@@ -125,8 +153,8 @@ export async function withInquirer(fn) {
     // rl.question() shows its prompt with terminal echo on but ignores
     // Enter (no input handler is wired). Surfaced after Diff 8 stopped
     // hiding this with an immediate "Goodbye" exit.
-    const beforeData = process.stdin.listeners('data').slice();
-    const beforeKeypress = process.stdin.listeners('keypress').slice();
+    const beforeData = stdin.listeners('data').slice();
+    const beforeKeypress = stdin.listeners('keypress').slice();
     setSuppress(true);
     rl.pause();
     // 2026-05-08: explicitly engage raw mode BEFORE the inquirer prompt
@@ -146,9 +174,15 @@ export async function withInquirer(fn) {
     // intends — matching what every working "consecutive inquirer prompt"
     // path already does (e.g. /files step 1 → step 2). rl.resume() in
     // finally will re-engage readline keypress mode on its own.
-    if (process.stdin.isTTY && !process.stdin.isRaw) {
-        process.stdin.setRawMode(true);
-    }
+    //
+    // Live fix 2026-09-26 (fix 8): `setRawMode(true)` alone is not enough. The
+    // previous inquirer prompt's readline.close() did setRawMode(false) +
+    // pause(), and our finally resume()d — so a COOKED console read is pending,
+    // and on Windows it survives setRawMode(true) (isRaw even reports true):
+    // keys were held until Enter ("press Enter first, then type"). The fix 1
+    // pty experiments showed only the full cycle ends that read. It is
+    // harmless when stdin was fine: it ends raw + flowing, as before.
+    resetTtyStdin(stdin);
     try {
         return await fn();
     }
@@ -157,16 +191,16 @@ export async function withInquirer(fn) {
         // didn't replace. The has() check avoids double-binding any
         // listener inquirer DID restore (different instance is OK; the
         // same function reference is the only thing we re-add).
-        const afterData = new Set(process.stdin.listeners('data'));
+        const afterData = new Set(stdin.listeners('data'));
         for (const lf of beforeData) {
             if (!afterData.has(lf)) {
-                process.stdin.on('data', lf);
+                stdin.on('data', lf);
             }
         }
-        const afterKeypress = new Set(process.stdin.listeners('keypress'));
+        const afterKeypress = new Set(stdin.listeners('keypress'));
         for (const lf of beforeKeypress) {
             if (!afterKeypress.has(lf)) {
-                process.stdin.on('keypress', lf);
+                stdin.on('keypress', lf);
             }
         }
         // Order matters here:
@@ -181,13 +215,22 @@ export async function withInquirer(fn) {
         //  3. inside the deferred release, still defer the suppress-clear by
         //     one tick so the spurious 'close' that inquirer synchronously
         //     emits on release is ignored.
-        process.stdin.resume();
+        stdin.resume();
         activeDepth = Math.max(0, activeDepth - 1);
         if (activeDepth === 0) {
             cancelPendingRelease();
             pendingRelease = setTimeout(() => {
                 pendingRelease = null;
+                // Fix 8: hand stdin back to the REPL readline (only NEW keys from here).
+                if (input && inputDetached) {
+                    inputDetached = false;
+                    stdin.pipe(input);
+                }
                 rl.resume();
+                const resumes = spinnerResumes;
+                spinnerResumes = [];
+                for (const resumeSpinner of resumes)
+                    resumeSpinner();
                 process.nextTick(() => setSuppress(false));
             }, RELEASE_DEBOUNCE_MS);
         }