@cspeach/cli 1.1.17 → 1.1.19

package/dist/repl/safety-confirm.js

@@ -7,9 +7,8 @@
  *
  * Three presentation surfaces, decided per call (headless first):
  *   - headless        → fail-fast decline, no prompt (B5)
- *   - Ink             → askQuestionEmitter choice modal (UX-5 review I1) —
- *                       inquirer must NEVER run under Ink: it fights the
- *                       React frame for stdin and paints over it
+ *   - Ink             → confirm card in the card slot via askConfirm
+ *                       (piece 2 §5) — inquirer must NEVER run under Ink
  *   - classic         → inquirer select via withInquirer (unchanged)
  */
 import chalk from 'chalk';
@@ -17,9 +16,11 @@ import { select } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
 import { isHeadless, shouldUseInk } from '../renderer/tty.js';
-import { askQuestionEmitter } from '../ui/ask-question-emitter.js';
-import { clearActiveSpinner } from '../renderer/tool-widget.js';
-import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
+import { askConfirm } from '../ui/confirm-request.js';
+import { emitTrace } from '../renderer/trace.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { clean, hasToolLabel, toolActivityLabel, toolLabel } from '../renderer/tool-labels.js';
+import { cardSlotEmitter, withFocusClaim } from '../ui/card-slot.js';
 const RULE_LABEL = {
     RULE_7_SNAPSHOT_BEFORE_WRITE: 'RULE 7 — snapshot before write',
     RULE_7A_USE_UPDATE_METHOD: 'RULE 7a — use sap_update_method (not sap_set_source)',
@@ -27,7 +28,98 @@ const RULE_LABEL = {
     RULE_9_TRANSPORT_RELEASE: 'RULE 9 — transport release (irreversible)',
     RULE_9_TRANSPORT_ISOLATION: 'RULE 9 — transport isolation',
     RULE_10_VERIFY_AFTER_WRITE: 'RULE 10 — verify after write',
+    CREDENTIAL_HANDOVER: 'SAP login handed to a local process',
 };
+/** Piece 2 §5 — plain-words heading: what could go wrong. No rule codes, no tool names. */
+export const SAFETY_HEADING = {
+    RULE_7_SNAPSHOT_BEFORE_WRITE: 'This replaces an object in SAP',
+    RULE_7A_USE_UPDATE_METHOD: 'A full rewrite could change code you did not ask to change',
+    RULE_8_BATCH_PLAN: 'Another SAP change in this turn, without an approved plan',
+    RULE_9_TRANSPORT_RELEASE: 'Releasing a transport cannot be undone',
+    RULE_9_TRANSPORT_ISOLATION: 'This change may land in a transport shared with other work',
+    RULE_10_VERIFY_AFTER_WRITE: 'This change is not proven until it is checked',
+    CREDENTIAL_HANDOVER: 'Your SAP login will be handed to a local program',
+};
+/** Bottom-edge note: which rule is asking. */
+export const SAFETY_FOOTNOTE = {
+    RULE_7_SNAPSHOT_BEFORE_WRITE: 'Forge Rule 7',
+    RULE_7A_USE_UPDATE_METHOD: 'Forge Rule 7a',
+    RULE_8_BATCH_PLAN: 'Forge Rule 8',
+    RULE_9_TRANSPORT_RELEASE: 'Forge Rule 9',
+    RULE_9_TRANSPORT_ISOLATION: 'Forge Rule 9',
+    RULE_10_VERIFY_AFTER_WRITE: 'Forge Rule 10',
+    CREDENTIAL_HANDOVER: 'Credential handover',
+};
+/** Rule 7 covers both overwrite and delete; the delete says so. */
+export function safetyHeading(a) {
+    if (a.rule === 'RULE_7_SNAPSHOT_BEFORE_WRITE' && /delete/.test(a.op))
+        return 'This deletes an object from SAP';
+    return SAFETY_HEADING[a.rule];
+}
+/** 'set_source' → 'sap_set_source' so piece 1's tool labels apply. */
+function toolNameFor(op) {
+    if (hasToolLabel(op))
+        return op;
+    if (hasToolLabel(`sap_${op}`))
+        return `sap_${op}`;
+    return op;
+}
+/**
+ * The card keeps at most this many what_will_happen lines (the Rule 8 batch
+ * summary lists every write this turn — 15+ on a Fiori build). The spec §2
+ * height cap (rows − 2) holds only while fact rows stay bounded; the full
+ * text goes to scrollback first (presentSafetyConfirmation), like the plan gate.
+ */
+export const SAFETY_WHAT_MAX_LINES = 4;
+/** what_will_happen as display-safe, non-blank lines. */
+function whatLines(a) {
+    return a.what_will_happen.split('\n').map(clean).filter((t) => t.length > 0);
+}
+/**
+ * At most SAFETY_WHAT_MAX_LINES rows. The Rule 8 summary puts the op being
+ * approved on its LAST line ("… ← about to dispatch"), so an over-long text
+ * keeps its header line, a "… N earlier, listed above" row, and the last lines.
+ */
+function boundedWhatLines(lines) {
+    if (lines.length <= SAFETY_WHAT_MAX_LINES)
+        return lines;
+    const tail = SAFETY_WHAT_MAX_LINES - 2;
+    const hidden = lines.length - 1 - tail;
+    return [lines[0], `${getGlyphs().more} ${hidden} earlier, listed above`, ...lines.slice(lines.length - tail)];
+}
+/**
+ * Piece 1's present-tense tool label, fed the real tool args when the caller
+ * passed them. A label with no readable object (sap_update_method without
+ * class_name/method_name renders "Updating  → ") falls back to the op words
+ * plus the object type and name.
+ */
+function whatLabel(a) {
+    const tool = toolNameFor(a.op);
+    const fallback = clean(`${a.op.replace(/_/g, ' ')} ${a.object.type} ${a.object.name}`);
+    if (!hasToolLabel(tool))
+        return fallback;
+    const args = a.args ?? { name: a.object.name, type: a.object.type, transport: a.object.name, path: a.object.name };
+    if (!/[\p{L}\p{N}]/u.test(toolLabel(tool, args).object))
+        return fallback;
+    return toolActivityLabel(tool, args);
+}
+/** What / Where / Undo rows (plain text; the card paints them dim). */
+export function safetyFacts(a) {
+    const what = a.rule === 'CREDENTIAL_HANDOVER'
+        ? `Hand the SAP login for ${clean(a.object.name)} to a local program`
+        : whatLabel(a);
+    const facts = [`What   ${what}`];
+    for (const t of boundedWhatLines(whatLines(a)))
+        facts.push(`       ${t}`);
+    const transport = clean(a.transport ?? '');
+    const where = transport.length > 0 ? `transport ${transport}` : 'no transport';
+    const batch = a.rule === 'RULE_8_BATCH_PLAN' && typeof a.batch_count === 'number'
+        ? ` · ${a.batch_count} objects this turn`
+        : '';
+    facts.push(`Where  ${where}${batch}`);
+    facts.push(`Undo   ${a.rollback_available ? 'A snapshot is taken first, so it can be restored' : 'Cannot be undone'}`);
+    return facts;
+}
 export async function presentSafetyConfirmation(action) {
     // B5 (2026-06-11) — headless fail-fast. This card is a stdin modal (the
     // Rule 8 batch gate reaches it on the 2nd+ mutating call per turn even in
@@ -43,86 +135,70 @@ export async function presentSafetyConfirmation(action) {
             headless: true,
         };
     }
-    const card = renderCard(action);
-    // UX-5 review I1 (2026-06-12) — Ink-native branch. /safety-mode on made
-    // this card reachable under Ink, where the raw inquirer select() below
-    // toggled raw mode out from under the React frame and painted over it.
-    // Mirror of renderPlanGate (approvals/render.ts): route through the
-    // askQuestionEmitter choice modal — one input system, no stdin handoff.
-    // The modal renders `context` itself in dimColor, so strip the chalk ANSI
-    // codes (they'd show as raw escape text). Same choice semantics as the
-    // classic path below: Apply/Cancel, plus the Rule 9 irreversibility ack.
-    // Esc / no listener resolve as cancelled → decline (safe default).
+    // Piece 2 §5 — Ink: a SAFETY CHECK (or CANNOT BE UNDONE) confirm card in
+    // the card slot. The card slot claims input focus first (requestConfirm
+    // runs inside withFocusClaim: suspendActiveSpinner + turnStatusEmitter.pause,
+    // both resumed after) — the 2026-06-13 doubled-card / Enter-leak / wedge fix,
+    // now in one place.
+    // Same values as the classic path: anything but 'apply' declines; Rule 9
+    // release asks a second time with Cancel first. Reasons byte-identical.
     if (shouldUseInk()) {
-        // CRITICAL race fix (2026-06-13) — this gate fires from INSIDE
-        // dispatchTool, on the 2nd+ mutating op of a turn. For local-FS ops
-        // (file_write / shell_exec, the fiori-build path) the agent loop
-        // classifies the tool as NON-interactive: it starts the in-place tool
-        // spinner, a per-second labelled heartbeat, AND keeps the turn-status
-        // row ticking — none of which it pauses (only ask_question /
-        // request_approval get paused at the loop level). So when this modal
-        // opens, three render sources are still repainting the Ink frame
-        // underneath it. That produced the observed live bug: the RULE 8 card
-        // rendered DOUBLED, Enter was not consumed by the modal, the keystroke
-        // LEAKED to the outer prompt (history-replay of the slash command), and
-        // the turn wedged for ~10 minutes while the tool spinner kept ticking.
-        //
-        // The gate must claim exclusive input focus itself (it can't rely on the
-        // loop, which doesn't know a non-interactive tool is about to block on
-        // the user). Mirror what the loop does for interactive tools:
-        //   - clearActiveSpinner(): stop the live in-place tool spinner so only
-        //     ONE surface (this modal) renders.
-        //   - turnStatusEmitter.pause(): freeze the ticking status row so it
-        //     stops repainting the dynamic frame and overdrawing the modal.
-        // resume() in the finally restores normal rendering the moment the gate
-        // resolves. (The per-second heartbeat is loop-local and is stopped on
-        // the loop side by ordering the gate ahead of heartbeat start — see
-        // tool-dispatch.ts / loop.ts.)
-        clearActiveSpinner();
-        const statusWasActive = turnStatusEmitter.snapshot().active;
-        if (statusWasActive)
-            turnStatusEmitter.pause();
-        try {
-            const first = await askQuestionEmitter.request({
-                id: 'safety-confirm',
-                question: `⚠  ${RULE_LABEL[action.rule]}`,
-                context: stripAnsi(card).trim(),
-                kind: 'choice',
-                choices: [
-                    { value: 'apply', label: 'Apply' },
-                    { value: 'cancel', label: 'Cancel' },
-                ],
-            });
-            if (first.cancelled || first.answer !== 'apply') {
-                return { confirmed: false, reason: 'user declined first prompt' };
-            }
-            // RULE 9 transport-release is irreversible — require a second explicit ack.
-            if (action.rule === 'RULE_9_TRANSPORT_RELEASE') {
-                const second = await askQuestionEmitter.request({
-                    id: 'safety-confirm-irreversible',
-                    question: `IRREVERSIBLE — releasing ${action.transport} cannot be undone from this side. ` +
-                        `Are you absolutely sure?`,
-                    kind: 'choice',
-                    // Cancel first → the modal cursor starts there (mirrors the classic
-                    // path's `default: 'cancel'`).
-                    choices: [
-                        { value: 'cancel', label: 'Cancel' },
-                        { value: 'release', label: 'Release transport' },
-                    ],
-                });
-                if (second.cancelled || second.answer !== 'release') {
-                    return { confirmed: false, reason: 'user declined irreversibility ack' };
-                }
-            }
-            return { confirmed: true };
+        // Rule 9 asks twice. One focus claim spans both cards (refcounted with
+        // the claim each card takes), so the status row never resumes and ticks
+        // for a moment between them (C2 fix round 1). No listener → no claim.
+        if (action.rule === 'RULE_9_TRANSPORT_RELEASE' && cardSlotEmitter.listenerCount('confirm') > 0) {
+            return withFocusClaim(() => confirmOnCards(action));
         }
-        finally {
-            // Restore normal rendering. resume() is a no-op if the turn already
-            // ended (e.g. the user Ctrl+C'd mid-modal) or was never paused.
-            if (statusWasActive)
-                turnStatusEmitter.resume();
+        return confirmOnCards(action);
+    }
+    const card = renderCard(action);
+    return confirmClassic(action, card);
+}
+/** The Ink cards (see presentSafetyConfirmation). */
+async function confirmOnCards(action) {
+    const release = action.rule === 'RULE_9_TRANSPORT_RELEASE';
+    const what = whatLines(action);
+    if (what.length > SAFETY_WHAT_MAX_LINES) {
+        // The card keeps the header and the last lines; the whole text lands above it.
+        emitTrace(what.join('\n'));
+    }
+    const first = await askConfirm({
+        id: 'safety-confirm',
+        tag: release ? 'CANNOT BE UNDONE' : 'SAFETY CHECK',
+        title: safetyHeading(action),
+        facts: safetyFacts(action),
+        choices: [
+            { value: 'apply', label: 'Apply' },
+            { value: 'cancel', label: 'Cancel' },
+        ],
+        initial: 0,
+        footnote: SAFETY_FOOTNOTE[action.rule],
+    });
+    if (first.cancelled || first.value !== 'apply') {
+        return { confirmed: false, reason: 'user declined first prompt' };
+    }
+    if (release) {
+        const second = await askConfirm({
+            id: 'safety-confirm-irreversible',
+            tag: 'CANNOT BE UNDONE',
+            title: `Release ${clean(action.transport)}? This cannot be undone from here.`,
+            facts: ['Its objects move on to the next system, and the transport can no longer be changed.'],
+            // Cancel first → the cursor starts on the safe option (classic: default 'cancel').
+            choices: [
+                { value: 'cancel', label: 'Cancel' },
+                { value: 'release', label: 'Release transport' },
+            ],
+            initial: 0,
+            footnote: SAFETY_FOOTNOTE[action.rule],
+        });
+        if (second.cancelled || second.value !== 'release') {
+            return { confirmed: false, reason: 'user declined irreversibility ack' };
         }
     }
+    return { confirmed: true };
+}
+/** The classic inquirer path (unchanged). */
+async function confirmClassic(action, card) {
     // 2026-05-01: switched from confirm() to select() to fix the "press Enter
     // first, then 'y'" race observed in dispatched-tool rule-8 prompts. confirm
     // has a brief window after rendering its multi-line message before raw
@@ -161,19 +237,11 @@ export async function presentSafetyConfirmation(action) {
     }
     return { confirmed: true };
 }
-/**
- * Strip chalk ANSI escape codes. The Ink ask-question modal renders the
- * card via its own <Text dimColor> — embedded escapes would display as
- * literal `[33m` noise there. (Same approach as renderPlanGate.)
- */
-function stripAnsi(s) {
-    return s.replace(/\x1b\[[0-9;]*m/g, '');
-}
 /**
  * Minimal indented summary block — replaces the chunky ASCII-art box.
  * Renders as:
  *
- *   ⚠  RULE 8 — no batch without plan
+ *   !  RULE 8 — no batch without plan
  *      op:        sap_set_source
  *      object:    PROG ZTEST_FIXED_2
  *      transport: (none)
@@ -181,7 +249,7 @@ function stripAnsi(s) {
  *      what:      Batch in progress (...)
  *      rollback:  available (snapshot)
  *
- * The `⚠` glyph is yellow (alert) — distinct from peach (brand) and red
+ * The `!` glyph is yellow (alert) — distinct from peach (brand) and red
  * (error) so the user immediately recognises a Forge Rule prompt. Body
  * lines are indented under the header for visual grouping without a box.
  */
@@ -190,7 +258,7 @@ function renderCard(action) {
     const transport = action.transport && action.transport.length > 0 ? action.transport : '(none)';
     const rollback = action.rollback_available ? 'available (snapshot)' : chalk.red('NOT available');
     lines.push('');
-    lines.push(`${chalk.yellow('⚠')}  ${chalk.yellow.bold(RULE_LABEL[action.rule])}`);
+    lines.push(`${chalk.yellow(getGlyphs().attention)}  ${chalk.yellow.bold(RULE_LABEL[action.rule])}`);
     lines.push(`   ${chalk.dim('op:       ')} ${action.op}`);
     lines.push(`   ${chalk.dim('object:   ')} ${action.object.type} ${action.object.name}`);
     lines.push(`   ${chalk.dim('transport:')} ${transport}`);

package/dist/repl/session-spend-line.js

@@ -7,14 +7,18 @@
  */
 import { formatCost } from '../cost/pricing.js';
 import { creditsActive, formatCredits, CREDITS_PENDING } from '../cost/credits.js';
-export function formatSessionSpendLine(sessionCostUsd, credits) {
+/** The spend VALUE in the current display mode (piece 2: goodbye block). */
+export function formatSessionSpendValue(sessionCostUsd, credits) {
     if (!creditsActive())
-        return `  spend:     ${formatCost(sessionCostUsd)}`;
+        return formatCost(sessionCostUsd);
     if (!credits)
-        return `  spend:     ${CREDITS_PENDING}`;
+        return CREDITS_PENDING;
     const value = formatCredits(credits.sessionTotal, credits.unitLabel);
     const balance = credits.balance !== null
         ? ` · balance ${Math.round(credits.balance).toLocaleString('en-US')}`
         : '';
-    return `  spend:     ${value}${balance}`;
+    return `${value}${balance}`;
+}
+export function formatSessionSpendLine(sessionCostUsd, credits) {
+    return `  spend:     ${formatSessionSpendValue(sessionCostUsd, credits)}`;
 }

package/dist/repl/themed-prompts.js

@@ -0,0 +1,19 @@
+// src/repl/themed-prompts.ts
+//
+// Piece 2 §10: the inquirer prompts with the CSPeach theme applied by default.
+// Wizards import from here instead of '@inquirer/prompts'. The flow, choices,
+// defaults and returned values are exactly the underlying prompt's; a
+// caller-supplied `theme` still wins.
+//
+// The underlying prompt is looked up when the wrapper is CALLED (not at import
+// time), so a test that mocks '@inquirer/prompts' with only some of the four
+// prompts can still load a module that imports this one.
+import * as raw from '@inquirer/prompts';
+import { inquirerTheme } from './inquirer-theme.js';
+function themed(pick) {
+    return ((config, context) => pick()({ theme: inquirerTheme, ...config }, context));
+}
+export const select = themed(() => raw.select);
+export const input = themed(() => raw.input);
+export const confirm = themed(() => raw.confirm);
+export const password = themed(() => raw.password);

package/dist/repl/ui-look-command.js

@@ -0,0 +1,75 @@
+// src/repl/ui-look-command.ts — `/ui look [panels|legacy]` and `/ui [auto|ink]`,
+// shared by the Ink and classic /ui handlers. A look change applies immediately
+// (no relaunch needed) and persists; a rendering-mode change applies after relaunch.
+import chalk from 'chalk';
+import { setLook } from '../renderer/look.js';
+import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
+import { panelHeading, panelRow } from '../renderer/panel-rows.js';
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { CLASSIC_ENV } from '../renderer/rendering-mode.js';
+export async function handleUiLook(arg, cfg, save, emit) {
+    const m = /^look(?:\s+(\S+))?$/.exec(arg.trim().toLowerCase());
+    if (!m)
+        return false;
+    const value = m[1];
+    if (!value) {
+        emit(`Current look: ${chalk.bold(cfg.ui.look)}`);
+        emit(panelRow('/ui look panels', 'the new look (default)', 16));
+        emit(panelRow('/ui look legacy', 'the previous look', 16));
+        return true;
+    }
+    if (value !== 'panels' && value !== 'legacy') {
+        emit(formatFailure({ what: `Unknown look: ${value}. Try panels or legacy.` }).trimEnd());
+        return true;
+    }
+    cfg.ui.look = value;
+    setLook(value);
+    try {
+        await save(cfg);
+        emit(`${paint('ok', getGlyphs().done)} Look set to ${value}.`);
+    }
+    catch (err) {
+        emit(formatFailure({ what: `Failed to save config: ${err.message} (applied for this session only)` }).trimEnd());
+    }
+    return true;
+}
+/**
+ * `/ui [auto|ink]` — shared by the Ink and classic /ui handlers.
+ *
+ * Owner ruling 2026-09-27: the classic renderer is retiring. `/ui classic` no
+ * longer persists (a stored `classic` is not honoured anyway — see
+ * renderer/rendering-mode.ts); the renderer cannot switch mid-session, so it
+ * says how to get classic for one launch: the CSPEACH_UI=classic env var.
+ */
+export async function handleUiRendering(arg, cfg, save, emit, effective) {
+    const g = getGlyphs();
+    if (arg === '') {
+        emit('');
+        emit(panelHeading('UI mode', `${cfg.ui.rendering} · effective now: ${effective}`));
+        emit(panelRow('/ui ink', 'the Ink frame', 9));
+        emit(panelRow('/ui auto', 'choose from the terminal', 9));
+        emit(panelRow('/ui look', 'panels (default) or legacy', 9));
+        emit(formatInfo('Mode changes apply after /exit and a relaunch; look changes apply now').trimEnd());
+        emit(formatInfo(`Classic display is retiring · for one launch only: ${CLASSIC_ENV}=classic cspeach`).trimEnd());
+        return;
+    }
+    if (arg === 'classic') {
+        emit(formatInfo('Classic display is retiring · /ui classic is no longer saved').trimEnd());
+        emit(formatInfo(`For one launch only, start cspeach with the environment variable ${CLASSIC_ENV}=classic`).trimEnd());
+        return;
+    }
+    if (arg === 'auto' || arg === 'ink') {
+        cfg.ui.rendering = arg;
+        try {
+            await save(cfg);
+            emit(`${paint('ok', g.done)} UI mode set to ${arg}`);
+            emit(formatInfo('Relaunch cspeach (/exit, then cspeach) to apply').trimEnd());
+        }
+        catch (err) {
+            emit(formatFailure({ what: 'Could not save the config', detail: [err.message] }).trimEnd());
+        }
+        return;
+    }
+    emit(formatFailure({ what: `Unknown UI mode: ${arg}`, next: '/ui auto or /ui ink' }).trimEnd());
+}

package/dist/repl/update-method-preview-hook.js

@@ -5,6 +5,7 @@
  *   - replPreviewHook       — interactive REPL: renders diff + asks confirm
  *   - noopPreviewHook       — auto-confirm (reserved for trusted paths)
  *   - alwaysDeclinePreviewHook — refuse every confirm (one-shot / non-interactive)
+ *   - inkPreviewHook        — Ink REPL: diff to scrollback + Apply/Cancel confirm card
  *
  * B.0a plumbing: factories are wired into ToolContext.previewHook at all 5
  * construction sites. B.1 will consume ctx.previewHook inside sap_update_method.
@@ -12,6 +13,9 @@
 import { confirm } from '@inquirer/prompts';
 import { renderDiff } from './diff-display.js';
 import { withInquirer } from './inquirer-guard.js';
+import { askConfirm } from '../ui/confirm-request.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
+import { withSpinnerSuspended } from '../renderer/tool-widget.js';
 /**
  * B.1 real interactive hook — composes renderDiff + @inquirer/prompts.confirm.
  * Renders a unified diff inside the REPL and asks the user "Apply change?".
@@ -21,13 +25,52 @@ export const replPreviewHook = async ({ className, methodName, currentBody, prop
         label: `${className}->${methodName}`,
         syntaxHighlight: true,
     });
-    process.stdout.write(`\n${diff}\n`);
-    const confirmed = await withInquirer(() => confirm({
-        message: `Apply change to ${className}->${methodName}?`,
-        default: false,
-    }));
+    // Review M1: diff + prompt with the tool spinner suspended throughout, so
+    // no spinner frame repaints around the diff before the prompt opens.
+    const confirmed = await withSpinnerSuspended(async () => {
+        process.stdout.write(`\n${diff}\n`);
+        return withInquirer(() => confirm({
+            message: `Apply change to ${className}->${methodName}?`,
+            default: false,
+        }));
+    });
     return { confirmed };
 };
+/**
+ * Piece 2 §6.3 — the Ink twin of replPreviewHook. inquirer must never run
+ * while Ink is mounted (it steals keystrokes), so the diff goes to
+ * scrollback through the chunk emitter and an Apply / Cancel confirm card
+ * decides. Cursor starts on Cancel and Esc / no listener = false — the
+ * same answer as today's confirm({ default: false }).
+ */
+export function inkPreviewHook(chunkEmitter) {
+    return async ({ className, methodName, currentBody, proposedBody }) => {
+        // Model / SAP text goes to Ink's <Static> scrollback: neutralise ESC, BEL,
+        // lone CR etc. BEFORE diffing (newlines and tabs survive, so the diff is
+        // still line-accurate). renderDiff itself does not sanitize.
+        const diff = renderDiff(sanitizeControlChars(currentBody), sanitizeControlChars(proposedBody), {
+            label: sanitizeControlChars(`${className}->${methodName}`),
+            syntaxHighlight: true,
+        });
+        chunkEmitter.emit('chunk', `\n${diff}\n`);
+        const res = await askConfirm({
+            id: 'update-method-preview',
+            tag: 'APPROVAL',
+            title: `Apply this change to method ${methodName} in ${className}?`,
+            facts: [
+                'The change is shown above.',
+                'Only this method is replaced. The rest of the class is untouched.',
+            ],
+            choices: [
+                { value: 'apply', label: 'Apply' },
+                { value: 'cancel', label: 'Cancel' },
+            ],
+            initial: 1,
+            footnote: 'Forge Rule 7a',
+        });
+        return { confirmed: res.value === 'apply' };
+    };
+}
 /**
  * No-op hook — confirms automatically without prompting. Use for paths where we
  * trust the LLM (classifier; doctor probe-write where the developer initiated