@cspeach/cli 1.1.18 → 1.1.20

package/dist/repl.js

@@ -6,37 +6,60 @@ import chalk from 'chalk';
 // callback-module's InterfaceConstructor signature or import from
 // 'node:readline' directly for that specific operation.
 import * as readline from 'node:readline/promises';
-import { select, password as promptPassword } from '@inquirer/prompts';
-import { loadConfig, resolveLocalBuild, resolveStandalone } from './config/loader.js';
+import { select, password as promptPassword } from './repl/themed-prompts.js';
+import { loadConfig, resolveLocalBuild, resolveStandalone, DEFAULT_CONFIG } from './config/loader.js';
+import { getLook, setLook, setBackground } from './renderer/look.js';
+import { applyColorMode } from './renderer/color-mode.js';
+import { startEarlyBrand, aliasSourceNote, panelsHintLine, panelsResumeLine, panelsStartTail, panelsInterruptedNote, formatPromptEcho } from './renderer/startup-lines.js';
+import { formatAttention, formatFailure, formatInfo } from './renderer/notice-shape.js';
+import { formatPanel } from './renderer/panel-rows.js';
+import { sanitizeControlChars } from './renderer/sanitize.js';
+import { formatRoutingLine } from './renderer/routing-line.js';
+import { handleUiLook, handleUiRendering } from './repl/ui-look-command.js';
+import { CLI_VERSION } from './lib/version.js';
 import { createOfflineAdtClient } from './sap/offline-adt-client.js';
 import { STANDALONE_ALIAS } from './tools/index.js';
+import { resumeStandaloneDecision, applySystemSwitch } from './repl/resume-standalone.js';
+import { applyResumedSkill, isShortFollowUp } from './router/resume-routing.js';
+import { readableInterruptReason, isUserStopReason } from './session/interrupt-reason.js';
 import { getStore } from './auth/api-key.js';
 import { readAuthFile } from './auth/auth-file.js';
 import { fetchMe } from './auth/me.js';
-import { formatLoginBanner } from './ui/login-banner.js';
-import { printStartupBanner, printKeytarFallbackBanner } from './renderer/banners.js';
+import { formatLoginBanner, signInFragment } from './ui/login-banner.js';
+import { printStartupBanner, printKeytarFallbackBanner, keychainFallbackNotice } from './renderer/banners.js';
+import { paint } from './renderer/theme.js';
+import { steeringEchoLine, classifyMidTurnLine, midTurnSlashHint } from './renderer/steering-echo.js';
 import { runAddSapWizard } from './sap/onboarding.js';
 import { getConnection } from './sap/connection-manager.js';
+import { unreachableCode, unreachableMessage } from './sap/unreachable.js';
 import { AdtClient, snapshots } from '@cspeach/sap-client';
-import { makeSessionId, saveSession } from './session/store.js';
+import { makeSessionId, saveSession, sessionSaved } from './session/store.js';
 import { newSession } from './session/schema.js';
 import { resolveModelRole } from './models/resolve.js';
-import { loadServerModelConfig } from './models/server-config.js';
+import { loadServerModelConfig, loadCustomerModelConfig, fetchToolLoadingMode } from './models/server-config.js';
+import { repinResumedSessionModel } from './session/repin-model.js';
 import { computeCost } from './cost/pricing.js';
-import { formatSessionSpendLine } from './repl/session-spend-line.js';
+import { formatSessionSpendValue } from './repl/session-spend-line.js';
+import { formatGoodbye } from './renderer/goodbye.js';
 import { globalCredits } from './cost/credits.js';
 import { initCredits } from './cost/credits-wire.js';
 import { createProviderForMode } from './agent/providers/factory.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
+import { IdleKeepalive } from './agent/cache-keepalive.js';
 import { renderTurnError } from './agent/turn-error-ux.js';
+import { runRerouteTurn } from './repl/reroute-turn.js';
 // BUG-2b (2026-07-05 live smoke) — pure (no-Ink) modules, safe to import
 // statically even though App itself is lazy-loaded to keep Ink out of
 // classic mode. Used by the single-flight dispatch guard below.
 import { turnStatusEmitter } from './ui/turn-status-emitter.js';
+import { decideInterrupt, createPendingTurnCancel, pendingCancelLine, queuedWorkLabel, autoDispatchDecision, settleWithin, EXIT_TAIL_CAP_MS } from './ui/interrupt.js';
+import { setTraceEmitter } from './renderer/trace.js';
 import { enqueueSteering } from './agent/steering-queue.js';
 import { classifyPrompt, parseShortcut, rejectUnknownSkill } from './router/classifier.js';
+import { pipedRoutingPick } from './router/piped-routing.js';
 import { decideRouting } from './router/routing-decision.js';
+import { routingFailureFromError, routingFailureFromResult, routingFailureNotice, routingFailureOutcome, routingFailureText } from './router/routing-failure.js';
 import { coachingPickerClassic } from './ui/coaching-picker-classic.js';
 import { coachingPickerEmitter } from './ui/coaching-picker-emitter.js';
 import { globalStore as sapStateStore } from './ui/sap-state-store.js';
@@ -51,6 +74,9 @@ import { approvalEmitter } from './ui/approval-emitter.js';
 import { collectRewindCandidates } from './rewind/candidates.js';
 import { executeRestore, runClassicRewind } from './rewind/cli.js';
 import { registerReadline, withInquirer } from './repl/inquirer-guard.js';
+import { pipeRevivedStdin } from './repl/reset-tty-stdin.js';
+import { logsDir } from './config/paths.js';
+import { noticeLogPathFor, pruneNoticeLogs, setNoticeLogPath } from './renderer/notice-log.js';
 import { maybePromptWorkspaceMigration, maybeOfferAbapforgeMigration } from './projects/migration.js';
 import { findProjectRoot } from './projects/workspace.js';
 import { slashCompleter } from './repl/slash-completer.js';
@@ -81,19 +107,26 @@ function prefillReadline(rl, text) {
 import { BracketedPasteDecoder, enableBracketedPaste, disableBracketedPaste, } from './repl/bracketed-paste.js';
 import { InkStdinPasteGuard } from './repl/ink-stdin-guard.js';
 import { printHelp } from './commands/help.js';
-import { shouldUseInk, setRenderingOverride } from './renderer/tty.js';
+import { shouldUseInk, setOneShotOverride } from './renderer/tty.js';
+import { applyStartupRendering } from './renderer/rendering-mode.js';
 import { createClassicOutputEmitter } from './renderer/notices.js';
 import { saveConfig } from './config/loader.js';
 import { EventEmitter } from 'node:events';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { streamsRoot } from './agent/turn-stream.js';
 import { parseAndValidateReroute } from './commands/reroute.js';
+import { emitPlanTurnEnd } from './repl/plan-turn-end.js';
 import { SKILL_CATALOG } from './skill-catalog.js';
-import { replPreviewHook } from './repl/update-method-preview-hook.js';
+import { replPreviewHook, inkPreviewHook } from './repl/update-method-preview-hook.js';
 import { getCurrentTransport, handleTransportCommand } from './repl/current-transport.js';
 import { matchSafetyModeCommand } from './repl/safety-mode-state.js';
 import { getEffectiveWriteMode, runModeCommand } from './repl/mode-cycle.js';
 import { maybeExpandNumberSelection, lastAssistantText } from './repl/numbered-menu.js';
 import { attachEarlyLineBuffer, noopEarlyLineBuffer } from './repl/early-line-buffer.js';
-import { snapshotTurnStart, pushPostTurnStatus } from './repl/post-turn-status.js';
+import { createRestoreGuard } from './repl/restore-guard.js';
+import { gracefulExit } from './lib/graceful-exit.js';
+import { snapshotTurnStart, pushPostTurnStatus, seedFooterSpend } from './repl/post-turn-status.js';
 import { looksLikeCspeachShellCommand, CSPEACH_SHELL_NUDGE } from './repl/cspeach-shell-detect.js';
 import { applyLocalBuildConfig, applyStandaloneFileTools } from './tools/local-build.js';
 // Side-effect imports so tool registrations happen before listTools() is called.
@@ -106,6 +139,8 @@ import './tools/ask-question.js';
 import './tools/dispatch-skill.js';
 import './tools/todo.js';
 import './tools/filesystem/file-read.js';
+import './tools/tool-output-read.js';
+import { pruneSpillFiles } from './tools/result-spill.js';
 import './tools/filesystem/read-document.js';
 import './tools/filesystem/file-edit.js';
 import './tools/filesystem/file-write.js';
@@ -127,7 +162,7 @@ import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
 import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
-const PEACH = '#FFCBA4';
+import './tools/subagent/read_agent.js';
 const HISTORY_SIZE = 500;
 // Persistence (read + dedup-guarded append) lives in ./repl/history.ts —
 // the single writer shared with the Ink Footer (Task 8, ux-wave1).
@@ -228,6 +263,15 @@ function isAckContinuation(trimmed, sessionSkill) {
  * shell shows only the startup banner + a bare "session saved" line,
  * which feels like everything they just did vanished.
  */
+/** `~/.cspeach/streams/<id>/` when that folder exists, else null (fix round 3, item 11b). */
+function existingStreamDir(sessionId) {
+    try {
+        return existsSync(join(streamsRoot(), sessionId)) ? `~/.cspeach/streams/${sessionId}/` : null;
+    }
+    catch {
+        return null;
+    }
+}
 function printGoodbye(session) {
     const userTurns = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
     const sessionCost = computeCost(session.model, {
@@ -240,16 +284,18 @@ function printGoodbye(session) {
         (session.usage.output_tokens ?? 0) +
         (session.usage.cache_read_input_tokens ?? 0) +
         (session.usage.cache_creation_input_tokens ?? 0);
-    console.log('');
-    console.log(chalk.bold(`Session ${session.id}`));
-    console.log(chalk.dim(`  turns:     ${userTurns}`));
-    console.log(chalk.dim(`  last skill: ${session.skill ?? '(none)'}`));
-    console.log(chalk.dim(`  tokens:    ${totalTokens.toLocaleString()}  (input+output+cache)`));
-    console.log(chalk.dim(formatSessionSpendLine(sessionCost, globalCredits.snapshot())));
-    console.log('');
-    console.log(chalk.cyan(`Resume with: cspeach --resume ${session.id}`));
-    console.log(chalk.dim(`Full log: ~/.cspeach/streams/${session.id}.md`));
-    console.log('');
+    for (const line of formatGoodbye({
+        sessionId: session.id,
+        turns: userTurns,
+        lastSkill: session.skill ?? null,
+        tokens: totalTokens,
+        spend: formatSessionSpendValue(sessionCost, globalCredits.snapshot()),
+        logDir: existingStreamDir(session.id),
+        // Round 6 review I1 — gate on the file: a start-then-quit (or a double
+        // Ctrl+C in the first turn before it saved) has no session to resume.
+        saved: sessionSaved(session),
+    }))
+        console.log(line);
 }
 function isBareAck(trimmed) {
     const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
@@ -308,7 +354,29 @@ function buildCoachingParams(result, prompt, preSelect, lastSkill) {
     };
 }
 export async function runRepl(opts) {
-    printStartupBanner();
+    applyColorMode(); // NO_COLOR (piece 2 §1.2) — idempotent; main() already did it for the CLI path
+    // 2026-09-26 — the look must be known before the first startup line prints.
+    // A config read failure keeps the default look; the real loadConfig below
+    // still runs and reports errors exactly as before.
+    try {
+        const early = await loadConfig();
+        setLook(early.ui.look);
+        setBackground(early.ui.background);
+    }
+    catch {
+        setLook(DEFAULT_CONFIG.ui.look);
+    }
+    // Piece 2 §10: the account folds into the panels brand line; "!" notices
+    // collect here and print last. Owner decision 2026-09-27: the panels brand
+    // line prints FIRST (no blank terminal during the sign-in check and the
+    // rest of startup); the sign-in completes the same line below. Legacy keeps
+    // its pinned banner exactly as before.
+    const startupNotices = [];
+    if (getLook() !== 'panels')
+        printStartupBanner();
+    const earlyBrand = getLook() === 'panels'
+        ? startEarlyBrand({ version: CLI_VERSION, tty: process.stdout.isTTY === true, write: (s) => { process.stdout.write(s); } })
+        : undefined;
     // v0.6 — surface interrupted sessions at startup so the developer doesn't
     // have to remember the session id from the crash UX. Like `git stash list`
     // for resilience: if you have any unfinished work, you see it immediately.
@@ -318,8 +386,10 @@ export async function runRepl(opts) {
             const { countInterruptedSessions } = await import('./session/store.js');
             const n = await countInterruptedSessions();
             if (n > 0) {
-                console.log(chalk.yellow.bold(`⚠  You have ${n} interrupted session${n === 1 ? '' : 's'}.`));
-                console.log(chalk.yellow(`   Recover with: cspeach --resume    (picks the right one from a list)\n`));
+                if (getLook() === 'panels')
+                    startupNotices.push(panelsInterruptedNote(n) + '\n');
+                else
+                    console.log(formatAttention({ text: `You have ${n} interrupted session${n === 1 ? '' : 's'}`, next: 'cspeach --resume  (picks the right one from a list)' }));
             }
         }
         catch { /* startup banner is best-effort */ }
@@ -331,7 +401,7 @@ export async function runRepl(opts) {
     // flag is process-scoped, so this prints at most once per CLI launch.
     try {
         const { isFlagOn } = await import('./agent/maybe-build-project-context.js');
-        if (isFlagOn()) {
+        if (isFlagOn() && getLook() !== 'panels') {
             console.log(chalk.cyan(`[project-context] enabled (cwd=${process.cwd()})`));
             console.log(chalk.dim('  unset CSPEACH_PROJECT_CONTEXT to disable; run `cspeach analyze project-context` later to compare.\n'));
         }
@@ -341,6 +411,7 @@ export async function runRepl(opts) {
     // and render the verbose login banner. Falls through to the legacy keytar
     // flow below when the file is absent (back-compat for pre-`cspeach login`
     // users).
+    let signIn;
     try {
         const authFile = await readAuthFile();
         if (authFile) {
@@ -348,25 +419,44 @@ export async function runRepl(opts) {
             const meResult = await fetchMe({ proxyUrl: cfgEarly.proxy_url, apiKey: authFile.apiKey });
             if (!meResult.ok) {
                 if (meResult.status === 401) {
-                    console.log(chalk.yellow('Your CSPeach session is invalid or expired. Run `cspeach login` to re-authenticate.'));
+                    earlyBrand?.close();
+                    console.log(formatFailure({ what: 'Your CSPeach sign-in is no longer valid', next: 'cspeach login' }));
                     return 1;
                 }
-                console.log(chalk.dim(`(could not refresh /v1/me — ${meResult.error})`));
+                const note = formatInfo(`Could not refresh your account (${meResult.error})`);
+                if (getLook() === 'panels')
+                    startupNotices.push(note);
+                else
+                    console.log(note.trimEnd());
             }
             else {
                 const banner = formatLoginBanner(meResult.profile);
-                console.log(banner.line);
-                if (banner.warningLine)
-                    console.log(chalk.yellow(banner.warningLine));
+                if (getLook() === 'panels') {
+                    signIn = signInFragment(meResult.profile);
+                    if (banner.warningLine)
+                        startupNotices.push(formatAttention({ text: banner.warningLine }));
+                }
+                else {
+                    console.log(banner.line);
+                    if (banner.warningLine)
+                        console.log(formatAttention({ text: banner.warningLine }).trimEnd());
+                }
             }
         }
     }
     catch { /* banner is best-effort — never block REPL startup */ }
+    earlyBrand?.finish(signIn);
     const store = await getStore();
-    if (!(await store.isKeychainAvailable())) {
-        printKeytarFallbackBanner();
-    }
+    const keychainMissing = !(await store.isKeychainAvailable());
     let apiKey = await store.get();
+    if (keychainMissing) {
+        // Panels: a "!" line with the other notices — unless the API key prompt is
+        // about to open, which needs the explanation right now.
+        if (getLook() === 'panels' && apiKey)
+            startupNotices.push(keychainFallbackNotice());
+        else
+            printKeytarFallbackBanner();
+    }
     if (!apiKey) {
         const entered = await promptPassword({
             message: 'Paste your CSPeach API key (from invite email):',
@@ -376,19 +466,40 @@ export async function runRepl(opts) {
         apiKey = entered;
     }
     let cfg = await loadConfig();
-    // Apply user-configured rendering override BEFORE any shouldUseInk() call.
-    setRenderingOverride(cfg.ui.rendering);
+    setLook(cfg.ui.look);
+    // Apply the rendering mode BEFORE any shouldUseInk() call. This is the
+    // interactive entry point, so it is never one-shot whatever argv holds. A
+    // stored `classic` is retiring: read as auto, rewritten once, one dim notice
+    // (CSPEACH_UI=classic is the escape hatch) — see renderer/rendering-mode.ts.
+    setOneShotOverride(false);
+    const classicRetiringNotice = await applyStartupRendering(cfg, saveConfig);
+    if (classicRetiringNotice) {
+        if (getLook() === 'panels')
+            startupNotices.push(classicRetiringNotice);
+        else
+            process.stdout.write(classicRetiringNotice);
+    }
+    setBackground(cfg.ui.background);
     // Standalone (2026-09-16) — run with no SAP system at all. Decided BEFORE
     // the onboarding wizard: someone who asked for --no-sap (or persisted
     // no_sap) must never be pushed through the SAP setup they don't have.
     // Having aliases configured does NOT override the request.
     // A session that WAS standalone stays standalone on `--resume`: its
     // sap_system is the reserved 'none' alias, which has no entry in cfg.sap.
-    let standalone = resolveStandalone(cfg, opts?.noSap === true) ||
-        opts?.resumedSession?.sap_system === STANDALONE_ALIAS;
+    // Round 6 item 2 — …unless an explicit --sap-alias asks for a SAP system:
+    // then the flag wins and the resumed session moves to it.
+    const standaloneDecision = resumeStandaloneDecision({
+        requestedStandalone: resolveStandalone(cfg, opts?.noSap === true),
+        resumedSapSystem: opts?.resumedSession?.sap_system,
+        sapAlias: opts?.sapAlias,
+        standaloneSource: opts?.noSap === true ? '--no-sap' : 'no_sap setting',
+    });
+    let standalone = standaloneDecision.standalone;
     const enterStandalone = async () => {
-        console.log(chalk.dim('\nStandalone mode: no SAP system connected — skills work from pasted code. ' +
-            'Connect later with: cspeach config add-sap'));
+        if (getLook() !== 'panels') {
+            console.log(chalk.dim('\nStandalone mode: no SAP system connected — skills work from pasted code. ' +
+                'Connect later with: cspeach config add-sap'));
+        }
         // Ask the profile questions ONCE — they become the <sap_system> element
         // every skill reads, so without them a design would target "unknown".
         if (!cfg.standalone) {
@@ -421,11 +532,22 @@ export async function runRepl(opts) {
             cfg = await loadConfig();
         }
     }
-    // model-governance step 2d — fire-and-forget fetch of the served model-config
-    // (managed mode only). NEVER blocks startup: a turn that starts before the
-    // fetch lands simply uses the built-ins (fail-safe). Precedence when it does
-    // land: env > local config > server > built-in.
-    void loadServerModelConfig(cfg);
+    // model-governance step 2d — fetch the served model-config (managed mode
+    // only). Task 3 (2026-09-27): AWAITED, but startup waits at most 1.5 s — a
+    // slower fetch aborts and falls back to a fresh disk cache, else the
+    // built-ins. The session model is resolved ONCE at newSession below and
+    // pinned, so call 0 and call 1 never run on different models (a switch
+    // forces a full cache rewrite). Precedence: env > local config > server >
+    // built-in. Never throws.
+    // Task 12 — the customer layer (/v1/me/model-config, every mode with a
+    // key) loads in parallel under the SAME 1.5 s cap: no extra wait. Final
+    // precedence: env > local > customer > server > built-in. Fails open.
+    await Promise.all([
+        loadServerModelConfig(cfg, { timeoutMs: 1500 }),
+        loadCustomerModelConfig(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
+        // Task 16 (F13) — BYOK reads only the served tool_loading (signed in only).
+        fetchToolLoadingMode(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
+    ]);
     // Credits (2026-09-16) — resolve ONCE, before any cost figure can render.
     // A managed customer is billed in credits at a multiplier we do not
     // disclose, so the dollar figures (our Anthropic COGS) must never reach
@@ -444,12 +566,20 @@ export async function runRepl(opts) {
     // identity, so print here exactly as before (byte-identical output); when
     // any alias declares a role, defer the banner until the alias is resolved.
     const anyRoleConfigured = Object.values(cfg.sap).some((s) => s.role !== undefined);
+    const advisoryNotice = (capped) => formatAttention({
+        text: 'Write mode: advisory',
+        fact: `writes are proposed, never executed${capped}`,
+        // The config hint only makes sense when config CAUSED advisory.
+        next: capped === '' ? 'cspeach config set write_mode approval-gated' : undefined,
+    });
     if (!anyRoleConfigured) {
         if (cfg.write_mode === 'advisory-only') {
-            console.log(chalk.yellow.bold('⚠  Write mode: ADVISORY (writes proposed, never executed)'));
-            console.log(chalk.yellow('   Change via: cspeach config set write_mode approval-gated\n'));
+            if (getLook() === 'panels')
+                startupNotices.push(advisoryNotice(''));
+            else
+                console.log(advisoryNotice(''));
         }
-        else {
+        else if (getLook() !== 'panels') {
             console.log(chalk.gray(`Write mode: ${cfg.write_mode}\n`));
         }
     }
@@ -460,15 +590,28 @@ export async function runRepl(opts) {
     // visibly: the toggle is persisted, not re-consented each session, so the user
     // must see that local file access + command execution are live this session.
     // Printed to stdout here (before any Ink frame mounts).
+    // 2026-09-26 — panels folds this announce into the one status line below.
+    // 2026-09-26 (I1) — the panels status line must say WHICH tools are live:
+    // local_build = file tools + shell command execution; standalone alone =
+    // file tools writing to ./cspeach-out.
+    let localTools = 'none';
     {
         const announce = applyLocalBuildConfig(resolveLocalBuild(cfg), process.cwd());
-        if (announce)
-            console.log(chalk.dim(announce + '\n'));
-        // 2026-09-17 — standalone writes its outputs to files by contract, so the
-        // file tools must be on without a separate local_build step (the RAP
-        // stack landed in the transcript with "There are no files" otherwise).
-        else if (standalone)
-            console.log(chalk.dim(applyStandaloneFileTools(process.cwd()) + '\n'));
+        localTools = announce ? 'files+commands' : standalone ? 'files' : 'none';
+        if (getLook() === 'panels') {
+            // The side effect (turning the file tools on) must still happen.
+            if (!announce && standalone)
+                applyStandaloneFileTools(process.cwd());
+        }
+        else {
+            if (announce)
+                console.log(chalk.dim(announce + '\n'));
+            // 2026-09-17 — standalone writes its outputs to files by contract, so the
+            // file tools must be on without a separate local_build step (the RAP
+            // stack landed in the transcript with "There are no files" otherwise).
+            else if (standalone)
+                console.log(chalk.dim(applyStandaloneFileTools(process.cwd()) + '\n'));
+        }
     }
     const aliases = Object.keys(cfg.sap);
     // C.1 — --sap-alias flag override skips the interactive picker
@@ -479,13 +622,17 @@ export async function runRepl(opts) {
         selectedAlias = STANDALONE_ALIAS;
     }
     else if (opts?.sapAlias) {
-        console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+        const note = aliasSourceNote('flag', opts.sapAlias);
+        if (note !== null)
+            console.log(note);
         selectedAlias = opts.sapAlias;
     }
     else if (opts?.resumedSession?.sap_system) {
         // v0.6 — resumed session knows its SAP. Skip the picker.
         selectedAlias = opts.resumedSession.sap_system;
-        console.log(chalk.dim(`Resumed on SAP ${selectedAlias}`));
+        const note = aliasSourceNote('resume', selectedAlias);
+        if (note !== null)
+            console.log(note);
     }
     else {
         selectedAlias =
@@ -507,25 +654,35 @@ export async function runRepl(opts) {
             ? ` (capped by sap.${selectedAlias}.role = ${aliasRole})`
             : '';
         if (startupWriteMode === 'advisory-only') {
-            console.log(chalk.yellow.bold(`⚠  Write mode: ADVISORY (writes proposed, never executed)${capped}`));
-            // The config hint only makes sense when config CAUSED advisory —
-            // a role-capped advisory can't be lifted by a config change.
-            if (capped === '') {
-                console.log(chalk.yellow('   Change via: cspeach config set write_mode approval-gated\n'));
-            }
-            else {
-                console.log('');
-            }
+            // A role-capped advisory can't be lifted by a config change (no Next:).
+            if (getLook() === 'panels')
+                startupNotices.push(advisoryNotice(capped));
+            else
+                console.log(advisoryNotice(capped));
         }
-        else {
+        else if (getLook() !== 'panels') {
             console.log(chalk.gray(`Write mode: ${startupWriteMode}${capped}\n`));
         }
     }
     // Standalone: the offline stand-in rejects every call with an actionable
     // message. This is the single construction site the AdtClient cast lives at.
-    const adt = standalone
-        ? createOfflineAdtClient()
-        : new AdtClient(await getConnection(selectedAlias, cfg.sap[selectedAlias]));
+    let adt;
+    if (standalone) {
+        adt = createOfflineAdtClient();
+    }
+    else {
+        try {
+            adt = new AdtClient(await getConnection(selectedAlias, cfg.sap[selectedAlias]));
+        }
+        catch (err) {
+            // Dry run 2026-09-25: unreachable SAP host → one clear line, not a stack.
+            const code = unreachableCode(err);
+            if (!code)
+                throw err;
+            console.error(unreachableMessage(selectedAlias, cfg.sap[selectedAlias].host, cfg.sap[selectedAlias].port, code));
+            return 1;
+        }
+    }
     // Phase A #3 (2026-05-16) — sidebar SAP-state wire, trigger 1 of 4.
     // Push system + user the moment we know the alias. Before this commit
     // the sidebar showed "no system / user: —" forever because the store
@@ -541,15 +698,49 @@ export async function runRepl(opts) {
         system: standalone ? 'standalone' : selectedAlias,
         user: standalone ? '' : cfg.sap[selectedAlias].username,
         writeMode: startupWriteMode,
+        standalone,
     });
     // v0.6 — when resuming, adopt the on-disk SessionState verbatim. This
     // preserves messages[], usage, last_skill, awaitingSkillAnswer, and the
     // turnInterrupted flag from the prior run. Skipping newSession() avoids
     // overwriting the saved file with an empty fresh one.
+    // Task 3 fix I1 — except the model: a resumed session re-resolves it ONCE
+    // through the same role resolution new sessions use (after the awaited
+    // served config), marks it 'predicted', saves, then stays pinned. Every
+    // resume entry (picker, --resume <id>) lands here via session/resume.ts.
     const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg));
-    if (!opts?.resumedSession) {
-        await saveSession(session);
+    // Round 6 item 4c — a resumed session keeps its skill for the first plain prompt.
+    let resumeKeepsSkill = Boolean(opts?.resumedSession?.skill);
+    // Round 7 item 8c — the footer shows a resumed session's spend at once.
+    if (opts?.resumedSession)
+        seedFooterSpend(session);
+    // Round 6 item 4b — a new session is written by its first turn (the loop
+    // saves after every round); a start-then-quit no longer leaves a 0-turn file.
+    // Round 6 item 2 + review I3 — an explicit --sap-alias moved a resumed
+    // session (standalone → SAP, or to another SAP system): update + save it.
+    await applySystemSwitch({
+        session,
+        decision: { ...standaloneDecision, standalone },
+        selectedAlias,
+        save: saveSession,
+        notify: (line) => {
+            if (getLook() === 'panels')
+                startupNotices.push(line);
+            else
+                console.log(line.trimEnd());
+        },
+    });
+    // Merge (cost branch Task 3 + UI round 6) — a resumed session re-pins its
+    // model from the current config (after any --sap-alias switch above).
+    if (opts?.resumedSession) {
+        await repinResumedSessionModel(session, cfg);
     }
+    // Live fix 2026-09-26 — notices cut to one screen line keep their full text here.
+    // Review M6: sanitised id; notice logs older than 14 days are collected.
+    pruneNoticeLogs(logsDir());
+    // Task 17 — saved large tool outputs (tool-*.txt) older than 14 days go too.
+    pruneSpillFiles();
+    setNoticeLogPath(noticeLogPathFor(logsDir(), session.id));
     // License gate: non-managed modes (byok/local/ai-hub) bypass our proxy for
     // inference, so without this anyone who never logged in could use the bundled
     // skills untracked. Require a valid CSPeach login before the REPL starts.
@@ -569,30 +760,70 @@ export async function runRepl(opts) {
             throw new Error('No API key configured');
         return key;
     });
+    // Task 15 — keep the prompt cache warm while the user is idle between
+    // turns: armed after a turn, disarmed on the next submit and on exit;
+    // `[keepalive] idle_pings` per idle period (managed / BYOK only).
+    const idleKeepalive = new IdleKeepalive({
+        provider,
+        maxPings: () => (cfg.keepalive?.enabled === false ? 0 : (cfg.keepalive?.idle_pings ?? 4)),
+    });
+    // Panels status line — writeMode is the same EFFECTIVE (role-clamped) mode
+    // the legacy line prints.
+    const panelsStatus = {
+        system: selectedAlias,
+        standalone,
+        tools: localTools,
+        writeMode: startupWriteMode,
+        cwd: process.cwd(),
+    };
     if (opts?.resumedSession) {
         const turnCount = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
-        console.log(chalk.cyan(`\nResumed session ${session.id} on ${selectedAlias} — ${turnCount} prior turn(s).`));
-        if (session.turnInterrupted) {
-            const reason = session.turnInterruptedReason ?? 'unknown';
-            console.log(chalk.yellow(`⚠  Last turn was interrupted (${reason}).`));
-            console.log(chalk.yellow(`   Type \"continue\" to ask the model to finish where it left off.`));
-        }
-        // Task 6 (ux-wave2) — session recap: three dim lines (last session ·
-        // open todos · unsatisfied plan) so the returning developer is oriented
-        // without scrolling. Covers BOTH resume entries — the `cspeach --resume`
-        // picker (session/resume.ts) and any direct --resume <id> — since both
-        // land here with opts.resumedSession set. Best-effort: buildRecap never
-        // throws, and a workspace-resolution failure just drops the plan line.
-        try {
-            const { buildRecap } = await import('./session/recap.js');
-            const { resolveWorkspacePath } = await import('./projects/workspace.js');
-            const recapWs = await resolveWorkspacePath().catch(() => undefined);
-            for (const recapLine of buildRecap(session, process.cwd(), { workspaceDir: recapWs })) {
-                console.log(chalk.dim(recapLine));
+        // Task 6 (ux-wave2) — session recap (last session · open todos ·
+        // unsatisfied plan) so the returning developer is oriented without
+        // scrolling. Covers BOTH resume entries — the `cspeach --resume` picker
+        // (session/resume.ts) and any direct --resume <id> — since both land here
+        // with opts.resumedSession set. Best-effort: the recap never throws, and a
+        // workspace-resolution failure just drops the plan fact.
+        if (getLook() === 'panels') {
+            let recap = { last: null, tasks: null, plan: null };
+            try {
+                const { buildRecapParts } = await import('./session/recap.js');
+                const { resolveWorkspacePath } = await import('./projects/workspace.js');
+                const recapWs = await resolveWorkspacePath().catch(() => undefined);
+                recap = buildRecapParts(session, process.cwd(), { workspaceDir: recapWs });
+            }
+            catch { /* recap is best-effort — never block resume */ }
+            // Piece 2 §10: same three-line shape. Open tasks show in the checklist
+            // (restored from session.todos), so only the plan becomes a "!" line.
+            if (session.turnInterrupted) {
+                // Round 7 item 8d — a stop the user asked for is not an error.
+                startupNotices.push(isUserStopReason(session.turnInterruptedReason)
+                    ? formatAttention({ text: 'Last turn was stopped by you', next: 'type continue to finish where it left off' })
+                    : formatAttention({ text: 'Last turn was interrupted', fact: readableInterruptReason(session.turnInterruptedReason), next: 'type continue to finish where it left off' }));
+            }
+            if (recap.plan)
+                startupNotices.push(formatAttention({ text: `Unfinished plan ${recap.plan.text}`, next: recap.plan.next }));
+            process.stdout.write(panelsStartTail({ status: panelsStatus, third: panelsResumeLine(recap.last, turnCount), notices: startupNotices }));
+        }
+        else {
+            console.log(chalk.cyan(`\nResumed session ${session.id} on ${selectedAlias} — ${turnCount} prior turn(s).`));
+            if (session.turnInterrupted) {
+                console.log(formatAttention({ text: isUserStopReason(session.turnInterruptedReason) ? 'Last turn was stopped by you' : `Last turn was interrupted (${readableInterruptReason(session.turnInterruptedReason)})`, next: 'type "continue" to ask the model to finish where it left off' }).trimEnd());
+            }
+            try {
+                const { buildRecap } = await import('./session/recap.js');
+                const { resolveWorkspacePath } = await import('./projects/workspace.js');
+                const recapWs = await resolveWorkspacePath().catch(() => undefined);
+                for (const recapLine of buildRecap(session, process.cwd(), { workspaceDir: recapWs })) {
+                    console.log(chalk.dim(recapLine));
+                }
             }
+            catch { /* recap is best-effort — never block resume */ }
+            console.log(chalk.gray(`Type /exit to quit.\n`));
         }
-        catch { /* recap is best-effort — never block resume */ }
-        console.log(chalk.gray(`Type /exit to quit.\n`));
+    }
+    else if (getLook() === 'panels') {
+        process.stdout.write(panelsStartTail({ status: panelsStatus, third: panelsHintLine(localTools), notices: startupNotices }));
     }
     else {
         console.log(chalk.gray(`\nSession ${session.id} on ${selectedAlias}. Type /exit to quit.\n`));
@@ -625,6 +856,8 @@ export async function runRepl(opts) {
         const { App } = await import('./ui/app.js');
         const React = (await import('react')).default;
         const chunkEmitter = new EventEmitter();
+        setTraceEmitter(chunkEmitter); // piece 2 §1.5 — answered/decided traces land in <Static>
+        const inkPreview = inkPreviewHook(chunkEmitter); // piece 2 §6.3 — Ink sites: diff to scrollback + Apply/Cancel card
         // Phase D6 (2026-05-17) — INLINE Ink mode (no alt-screen).
         //
         // After Laeeq pointed out CC achieves great scrolling without any
@@ -674,6 +907,50 @@ export async function runRepl(opts) {
         // it. When null, we're at idle and should exit on Ctrl+C.
         let currentTurnAbort = null;
         let interruptCount = 0;
+        // Review I2/I3 — a cancel asked for before the turn has its controller
+        // (routing / prep). Applied at controller creation; cleared when the
+        // dispatch ends without a turn.
+        const pendingCancel = createPendingTurnCancel();
+        // Re-review 2/3 — where a busy dispatch without a controller is, so the
+        // cancel line says only what will actually happen. postTurn: the turn's
+        // controller has been cleared (saving, audit, next-phase offer);
+        // postTurnMayChain: that post-turn work may auto-start a plan phase.
+        let postTurn = false;
+        let postTurnMayChain = false;
+        let cancelAnnouncedPhase = null;
+        /** Round 4 item 5 — the in-flight classifier request, while routing. */
+        let routingAbort = null;
+        const cancelPhase = () => turnStatusEmitter.snapshot().routing ? 'routing' : postTurn ? 'post' : 'prep';
+        const canChainNow = () => postTurnMayChain || pendingDispatchAccessor.get() !== null;
+        /** Queue a cancel; print its one truthful line the first time. */
+        const announcePendingCancel = (exiting) => {
+            if (!pendingCancel.request())
+                return;
+            const phase = cancelPhase();
+            cancelAnnouncedPhase = phase;
+            // Round 4 item 5 — stop the classifier request (and its spinner) now.
+            routingAbort?.abort();
+            const line = phase === 'post' && !canChainNow()
+                ? 'Exiting when this turn has finished saving'
+                // Round 4 item 9a — name what is queued (a skill switch is not a plan phase).
+                : pendingCancelLine(phase, exiting, queuedWorkLabel(pendingDispatchAccessor.get()));
+            chunkEmitter.emit('chunk', '\n' + formatInfo(line));
+        };
+        /** Auto-dispatch of the next plan phase, unless a post-turn cancel stopped it. */
+        const autoDispatch = (cmd) => {
+            // Round 4 item 9b — the exit is already under way: start nothing new.
+            // Final review B-I2 — `/exit` typed mid-turn (exitAfterTurn) stops it too.
+            const decision = autoDispatchDecision({ done, exitRequested: exitAfterTurn, cancelPending: pendingCancel.pending }, cmd);
+            if (decision.kind === 'skip')
+                return;
+            if (decision.kind === 'not-started') {
+                pendingCancel.clear();
+                chunkEmitter.emit('chunk', formatInfo(decision.line));
+                return;
+            }
+            chunkEmitter.emit('chunk', formatInfo(`Auto-routed: ${cmd}`));
+            setImmediate(() => { void handleSubmit(cmd); });
+        };
         // BUG-2b — the actual dispatch. Wrapped by handleSubmit (below) which
         // owns the single-flight reserve()/release() lifecycle. All re-entrant
         // callers (the setImmediate auto-dispatch / re-audit legs) go through the
@@ -682,6 +959,10 @@ export async function runRepl(opts) {
             const trimmed = line.trim();
             if (!trimmed)
                 return;
+            // Round 6 review I2 — the resumed skill is offered to the FIRST submit
+            // only (slash commands included), then cleared.
+            const resumedSkill = resumeKeepsSkill ? session.skill ?? null : null;
+            resumeKeepsSkill = false;
             // Task 8 (ux-wave1) — shared dedup-guarded writer. On the Ink path
             // the Footer has already persisted this submission (flattened), so
             // the consecutive-dup guard makes this a no-op instead of the old
@@ -694,8 +975,7 @@ export async function runRepl(opts) {
             // new turn's content touched with no separator and looked like
             // garbled overlap).
             if (trimmed !== '/exit' && trimmed !== '/quit') {
-                chunkEmitter.emit('chunk', chalk.dim('\n──────────────────────────────────\n') +
-                    chalk.cyan(`› ${trimmed}\n`));
+                chunkEmitter.emit('chunk', formatPromptEcho(trimmed, process.stdout.columns || 80));
             }
             if (trimmed === '/exit' || trimmed === '/quit') {
                 done = true;
@@ -719,7 +999,9 @@ export async function runRepl(opts) {
             // from the JSONL log written each turn. Read-only, no network.
             if (trimmed === '/cost') {
                 const { runCostCommand } = await import('./commands/cost.js');
-                await runCostCommand(session.id);
+                // Piece 2: through the chunkEmitter (like /context and /export) — a
+                // console.log here would land above the Ink frame.
+                await runCostCommand(session.id, undefined, (l) => chunkEmitter.emit('chunk', l + '\n'));
                 return;
             }
             // Task 4 (ux-wave3) — /export audit [filename]: write the signable
@@ -764,7 +1046,7 @@ export async function runRepl(opts) {
             if (trimmed === '/mode' || trimmed.startsWith('/mode ')) {
                 const modeArg = trimmed === '/mode' ? undefined : (trimmed.slice('/mode '.length).trim() || undefined);
                 const { line: modeLine, mode } = runModeCommand(modeArg, cfg.write_mode, cfg.sap[selectedAlias]?.role, selectedAlias);
-                chunkEmitter.emit('chunk', chalk.dim(modeLine) + '\n');
+                chunkEmitter.emit('chunk', formatInfo(modeLine));
                 sapStateStore.update({ writeMode: mode });
                 return;
             }
@@ -777,8 +1059,8 @@ export async function runRepl(opts) {
                 const recapWs = await resolveWorkspacePath().catch(() => undefined);
                 const recapLines = buildRecap(session, process.cwd(), { workspaceDir: recapWs });
                 const body = recapLines.length === 0
-                    ? chalk.dim('nothing to recap yet')
-                    : recapLines.map((l) => chalk.dim(l)).join('\n');
+                    ? formatInfo('Nothing to recap yet').trimEnd()
+                    : formatPanel('Recap', recapLines.map((l) => '  ' + paint('dim', sanitizeControlChars(l)))).join('\n');
                 chunkEmitter.emit('chunk', '\n' + body + '\n');
                 return;
             }
@@ -794,15 +1076,15 @@ export async function runRepl(opts) {
                     return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), 
                     // model-governance step 2d — compact model resolves env > local >
                     // server > built-in (== COMPACTION_MODEL when nothing set).
-                    { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                    { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact', 'X-CSPeach-Model-Role': 'compact' } });
                 };
                 try {
-                    chunkEmitter.emit('chunk', chalk.dim('\nCompacting older turns into a summary...\n'));
+                    chunkEmitter.emit('chunk', '\n' + formatInfo('Compacting older turns into a summary…'));
                     const result = await runCompact({ session, summarise, keepRecentTurns: compactCfg.keep_recent_turns });
                     chunkEmitter.emit('chunk', formatCompactResult(result, compactCfg.keep_recent_turns));
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n/compact failed: ${err instanceof Error ? err.message : String(err)}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Compact failed', detail: [err instanceof Error ? err.message : String(err)] }));
                 }
                 return;
             }
@@ -812,9 +1094,9 @@ export async function runRepl(opts) {
             if (trimmed === '/files') {
                 try {
                     const { openFilePicker } = await import('./repl/file-picker.js');
-                    const result = await openFilePicker();
+                    const result = await openFilePicker({ ink: true });
                     if (result.kind === 'command') {
-                        chunkEmitter.emit('chunk', chalk.dim(`↪ ${result.command}\n`));
+                        chunkEmitter.emit('chunk', formatInfo(result.command));
                     }
                     else if (result.kind === 'empty') {
                         // Empty workspace — print the listing so the user sees the
@@ -828,7 +1110,7 @@ export async function runRepl(opts) {
                     // result.kind === 'cancelled' — print nothing.
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[/files] ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Could not open the file list', detail: [err.message] }));
                 }
                 return;
             }
@@ -837,32 +1119,12 @@ export async function runRepl(opts) {
             // lands in Body, not above the React frame.
             if (trimmed === '/ui' || trimmed.startsWith('/ui ')) {
                 if (!cfg.ui)
-                    cfg.ui = { rendering: 'auto' };
+                    cfg.ui = { rendering: 'auto', look: DEFAULT_CONFIG.ui.look };
                 const arg = trimmed.slice(3).trim().toLowerCase();
                 const emit = (s) => chunkEmitter.emit('chunk', s + '\n');
-                if (arg === '') {
-                    emit('');
-                    emit(`Current UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
-                        `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})`);
-                    emit(chalk.dim('  /ui classic  — chalk REPL (default)'));
-                    emit(chalk.dim('  /ui ink      — Ink frame (opt-in)'));
-                    emit(chalk.dim('  /ui auto     — choose automatically'));
-                    emit(chalk.dim('Change takes effect after /exit + relaunch.'));
-                }
-                else if (arg === 'auto' || arg === 'ink' || arg === 'classic') {
-                    cfg.ui.rendering = arg;
-                    try {
-                        await saveConfig(cfg);
-                        emit(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
-                        emit(chalk.dim('Relaunch cspeach to apply.'));
-                    }
-                    catch (err) {
-                        emit(chalk.red(`\n✗ Failed to save config: ${err.message}`));
-                    }
-                }
-                else {
-                    emit(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.`));
-                }
+                if (await handleUiLook(arg, cfg, saveConfig, emit))
+                    return;
+                await handleUiRendering(arg, cfg, saveConfig, emit, shouldUseInk() ? 'ink' : 'classic');
                 return;
             }
             // /reroute — re-dispatch session.lastUserPrompt to a different skill
@@ -874,23 +1136,42 @@ export async function runRepl(opts) {
                     return;
                 }
                 const preview = rr.prompt.length > 60 ? rr.prompt.slice(0, 57) + '...' : rr.prompt;
-                chunkEmitter.emit('chunk', chalk.dim(`\n↪ Rerouting "${preview}" → /${rr.skill}\n`));
+                chunkEmitter.emit('chunk', '\n' + formatInfo(`Rerouting "${preview}" to /${rr.skill}`));
                 if (rr.warning)
                     chunkEmitter.emit('chunk', chalk.dim(`  (${rr.warning})\n`));
+                // Re-review 1 — its own AbortController, wired like the main path, so
+                // Ctrl+C and `/exit` stop a rerouted turn the same way.
+                const rerouteAbort = new AbortController();
+                currentTurnAbort = rerouteAbort;
+                interruptCount = 0;
+                if (pendingCancel.applyTo(rerouteAbort))
+                    interruptCount = 1;
                 turnStatusEmitter.start(`/${rr.skill}`);
-                try {
-                    await runTurn({
+                // A turn error is rendered into the conversation like the normal turn
+                // path (never an unhandled rejection out of `void handleSubmit`).
+                await runRerouteTurn({
+                    run: () => runTurn({
                         provider,
                         userMessage: rr.prompt,
                         skill: rr.skill,
-                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                         chunkEmitter,
                         pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
-                    });
-                }
-                finally {
-                    turnStatusEmitter.stop();
-                }
+                        autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
+                        signal: rerouteAbort.signal,
+                    }),
+                    session,
+                    print: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                    signal: rerouteAbort.signal,
+                    onFinally: () => {
+                        turnStatusEmitter.stop();
+                        currentTurnAbort = null;
+                        postTurn = true;
+                        // P2 fix round 1 — /reroute skips pushPostTurnStatus, so run its
+                        // turn-end plan step here (close line / 'close' when finished).
+                        emitPlanTurnEnd(session);
+                    },
+                });
                 return;
             }
             // /new — clear any "awaiting skill answer" state so the next prompt
@@ -898,7 +1179,11 @@ export async function runRepl(opts) {
             // previous skill's Q&A chain.
             if (trimmed === '/new' || trimmed === '/reset') {
                 session.awaitingSkillAnswer = false;
-                chunkEmitter.emit('chunk', chalk.dim('\n↩ fresh start — next prompt will be classified normally\n'));
+                // P2 — /new clears the plan checklist (spec §4 lifecycle): the session
+                // list AND the live view, so Ctrl+T / --resume can't bring it back.
+                session.todos = [];
+                todoEmitter.emit('update', []);
+                chunkEmitter.emit('chunk', '\n' + formatInfo('Fresh start · the next prompt picks a skill again'));
                 return;
             }
             // /transport — session current-transport state for Rule 9 (transport isolation)
@@ -990,63 +1275,119 @@ export async function runRepl(opts) {
                         chalk.dim('Type a new question, /new to reset, or /exit to quit.\n'));
                     return;
                 }
-                if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
-                    chunkEmitter.emit('chunk', chalk.dim(`↪ Continuing /${session.skill}\n`));
+                // Round 6 item 4c / review I2 — after a resume, a short follow-up
+                // ("continue", a number) stays in the session's skill; anything else
+                // is classified (applyResumedSkill below).
+                if ((session.awaitingSkillAnswer || (resumedSkill !== null && isShortFollowUp(trimmed)) || isAckContinuation(trimmed, session.skill)) && session.skill) {
+                    chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: session.skill }));
                     skill = session.skill;
                 }
                 else if (isBareAck(trimmed)) {
                     // Bare "y" / "n" / "cancel" with no skill to continue — typing this
                     // after an aborted turn is almost always a stray keystroke, NOT a
                     // request to start work. Don't burn a classifier round-trip on it.
-                    chunkEmitter.emit('chunk', chalk.dim('↩ no active skill — type /help or a full prompt\n'));
+                    chunkEmitter.emit('chunk', formatInfo('No active skill · type /help or a full prompt'));
                     return;
                 }
                 else {
                     try {
-                        const c = await classifyPrompt(prompt, {
-                            sap_system: selectedAlias,
-                            last_skill: session.last_skill ?? null,
-                            last_object: extractedObject ?? session.last_object ?? null,
-                        });
-                        if (c.offline) {
-                            // Remote classify failed twice — local-rules fallback fired.
-                            // Tell the user so they know the picker preselection came
-                            // from regex, not the LLM, and surface the real cause.
-                            chunkEmitter.emit('chunk', chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]\n`));
+                        // Fix round 3 (item 8) — the status row reads "routing…" for
+                        // the whole classifier wait (was a blank screen for up to 16 s).
+                        turnStatusEmitter.routingStart();
+                        // Round 4 item 5 — Ctrl+C during routing aborts the classifier
+                        // request at once (the spinner used to run until it answered,
+                        // up to ~17 s). A cancel queued before routing started aborts
+                        // it before any request is made.
+                        const routingCtl = new AbortController();
+                        routingAbort = routingCtl;
+                        if (pendingCancel.pending)
+                            routingCtl.abort();
+                        let c;
+                        try {
+                            c = await classifyPrompt(prompt, {
+                                sap_system: selectedAlias,
+                                last_skill: session.last_skill ?? null,
+                                last_object: extractedObject ?? session.last_object ?? null,
+                            }, { signal: routingCtl.signal });
                         }
-                        if (c.screenshot) {
-                            chunkEmitter.emit('chunk', chalk.dim(`┄ Screenshot: ${c.screenshot}
-`));
+                        catch (err) {
+                            if (!routingCtl.signal.aborted)
+                                throw err;
                         }
-                        const decision = decideRouting(c);
-                        // 2026-05-17 — pass the just-used skill so the picker can
-                        // default cursor to it (one-Enter "continue" UX for follow-up
-                        // questions). session.skill = immediately-previous turn's
-                        // skill, NOT session.last_skill which is from TWO turns ago.
-                        const continueSkill = session.skill ?? null;
-                        let pickedResult;
-                        if (cfg.classifier.safe_mode) {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(c, trimmed, false, continueSkill));
+                        finally {
+                            routingAbort = null;
+                            turnStatusEmitter.routingEnd();
                         }
-                        else if (decision.kind === 'silent') {
-                            chunkEmitter.emit('chunk', chalk.dim(`┄ Routed to /${decision.skill}\n`));
-                            pickedResult = decision.skill;
+                        // Review I2/I3 — cancelled while routing: never start the turn.
+                        // One line only (re-review 3): the press already printed it when
+                        // it came during routing.
+                        if (pendingCancel.pending || c === undefined) {
+                            pendingCancel.clear();
+                            if (cancelAnnouncedPhase !== 'routing') {
+                                chunkEmitter.emit('chunk', formatInfo('Turn cancelled · nothing was sent'));
+                            }
+                            return;
+                        }
+                        if (c.screenshot) {
+                            chunkEmitter.emit('chunk', formatInfo(`Screenshot: ${c.screenshot}`));
                         }
-                        else if (decision.kind === 'coach') {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, true, continueSkill));
+                        // Fix 10 (2026-09-26): routing failed mid-skill → stay in the
+                        // active skill (one dim line), never the picker. Shared decision
+                        // with the classic path (routingFailureOutcome).
+                        const failed = routingFailureOutcome(routingFailureFromResult(c), session.skill);
+                        if (failed.kind === 'stay') {
+                            chunkEmitter.emit('chunk', formatInfo(failed.line));
+                            skill = failed.skill;
                         }
                         else {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, false, continueSkill));
+                            if (c.offline) {
+                                // Remote classify failed twice — local-rules fallback fired.
+                                // Tell the user so they know the picker preselection came
+                                // from regex, not the LLM, and surface the real cause.
+                                // Fix 9: true wording from the failure kind (a timeout is not "offline").
+                                chunkEmitter.emit('chunk', formatAttention(routingFailureNotice(routingFailureFromResult(c), c.transport_error)));
+                            }
+                            // Round 6 review I2 — after a resume the classifier's confident pick
+                            // wins; the resumed skill replaces only the "Pick a skill" card.
+                            const decision = resumedSkill ? applyResumedSkill(decideRouting(c), resumedSkill) : decideRouting(c);
+                            // 2026-05-17 — pass the just-used skill so the picker can
+                            // default cursor to it (one-Enter "continue" UX for follow-up
+                            // questions). session.skill = immediately-previous turn's
+                            // skill, NOT session.last_skill which is from TWO turns ago.
+                            const continueSkill = session.skill ?? null;
+                            let pickedResult;
+                            if (cfg.classifier.safe_mode) {
+                                pickedResult = await coachingPickerEmitter.request(buildCoachingParams(c, trimmed, false, continueSkill));
+                            }
+                            else if (decision.kind === 'silent') {
+                                chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'using', skill: decision.skill }));
+                                pickedResult = decision.skill;
+                            }
+                            else if (decision.kind === 'coach') {
+                                pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, true, continueSkill));
+                            }
+                            else {
+                                pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, false, continueSkill));
+                            }
+                            if (pickedResult === PICK_CANCELLED) {
+                                chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'cancelled' }));
+                                return;
+                            }
+                            skill = pickedResult;
+                        } // end fix-10 fallback branch
+                    }
+                    catch (err) {
+                        const failure = routingFailureFromError(err);
+                        const failed = routingFailureOutcome(failure, session.skill);
+                        if (failed.kind === 'stay') {
+                            // Fix 10: HTTP routing failure mid-skill → stay in the active skill.
+                            chunkEmitter.emit('chunk', formatInfo(failed.line));
+                            skill = failed.skill;
                         }
-                        if (pickedResult === PICK_CANCELLED) {
-                            chunkEmitter.emit('chunk', chalk.dim('↩ cancelled — type a new prompt\n'));
+                        else {
+                            chunkEmitter.emit('chunk', '\n' + formatFailure({ what: failure ? routingFailureText(failure) : 'Could not pick a skill for this prompt', detail: [err.message], next: 'start the prompt with a skill, e.g. /abap-explain' }));
                             return;
                         }
-                        skill = pickedResult;
-                    }
-                    catch (err) {
-                        chunkEmitter.emit('chunk', chalk.red(`\n[classifier error] ${err.message}\n`));
-                        return;
                     }
                 }
             }
@@ -1076,7 +1417,7 @@ export async function runRepl(opts) {
                     });
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[--status] ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Could not show the status', detail: [err.message] }));
                 }
                 session.last_skill = previousSkill ?? null;
                 session.last_object = extractedObject ?? previousObject ?? null;
@@ -1108,7 +1449,7 @@ export async function runRepl(opts) {
             if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
                 try {
                     const { preparePlanResume } = await import('./commands/plan-resume.js');
-                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                     planResume = await preparePlanResume({
                         body: prompt,
                         cwd: process.cwd(),
@@ -1120,11 +1461,12 @@ export async function runRepl(opts) {
                         // resume guard; inkAwarePrompt answers '' in headless = decline).
                         sessionId: session.id,
                         prompt: inkAwarePrompt,
+                        confirm: inkAwareConfirm,
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                     });
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[--resume] ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Could not resume the plan', detail: [err.message] }));
                 }
                 if (!planResume) {
                     session.last_skill = previousSkill ?? null;
@@ -1139,7 +1481,7 @@ export async function runRepl(opts) {
                 if (planResume.reauditPhaseId) {
                     try {
                         const { runReauditPass } = await import('./commands/plan-chain.js');
-                        const { inkAwarePrompt } = await import('./agent/loop.js');
+                        const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                         await runReauditPass({
                             savedPath: planResume.path,
                             phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
@@ -1152,12 +1494,13 @@ export async function runRepl(opts) {
                             auditMode: planResume.auditMode,
                             auditFlag: planResume.auditFlag,
                             prompt: inkAwarePrompt,
+                            confirm: inkAwareConfirm,
                             queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                             log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                         });
                     }
                     catch (err) {
-                        chunkEmitter.emit('chunk', chalk.red(`\n[plan] re-audit failed: ${err.message}\n`));
+                        chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan re-audit failed', detail: [err.message] }));
                     }
                     session.last_skill = previousSkill ?? null;
                     session.last_object = extractedObject ?? previousObject ?? null;
@@ -1175,8 +1518,7 @@ export async function runRepl(opts) {
                     }
                     if (reauditDispatched) {
                         pendingDispatchAccessor.set(null);
-                        chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${reauditDispatched}\n`));
-                        setImmediate(() => { void handleSubmit(reauditDispatched); });
+                        autoDispatch(reauditDispatched);
                     }
                     return;
                 }
@@ -1188,7 +1530,7 @@ export async function runRepl(opts) {
                 {
                     const { resetContextForPlanResume } = await import('./commands/plan-resume.js');
                     if (resetContextForPlanResume(session)) {
-                        chunkEmitter.emit('chunk', chalk.dim('↪ Plan phase starts in a fresh bounded context — prior transcript cleared\n'));
+                        chunkEmitter.emit('chunk', formatInfo('Plan phase starts in a fresh bounded context · earlier conversation cleared'));
                     }
                 }
                 planResumeMsgStart = session.messages.length;
@@ -1244,7 +1586,7 @@ export async function runRepl(opts) {
                     planContinue = { prepared: r.prepared, marker };
                     planPhaseStartedAt = marker.attemptStartedAt;
                     planResumeMsgStart = session.messages.length;
-                    chunkEmitter.emit('chunk', chalk.dim(`↪ re-attaching to in-flight plan phase ${marker.phaseId} (${r.prepared.path})\n`));
+                    chunkEmitter.emit('chunk', formatInfo(`Re-attaching to in-flight plan phase ${marker.phaseId} (${r.prepared.path})`));
                 }
                 else if (r.stale) {
                     session.plan_in_flight = null; // plan/phase gone for good — marker is noise
@@ -1271,12 +1613,18 @@ export async function runRepl(opts) {
             // modes. (Pre-fix this whole block didn't exist in the Ink path —
             // sidebar stayed frozen at "0 tok / no turns yet" forever.)
             const turnSnapshot = snapshotTurnStart(session);
+            // Round 6 item 4d — the user cancelled this turn (no receipt when it used no tokens).
+            let turnCancelledByUser = false;
             // Phase D5 (2026-05-17) — install per-turn abort. onInterrupt
             // (Ctrl+C handler) calls currentTurnAbort.abort() while this is
             // non-null, which tears the in-flight provider stream down via
             // the signal we thread into runTurn.
             currentTurnAbort = new AbortController();
             interruptCount = 0;
+            // Review I2/I3 — `/exit` or Ctrl+C arrived during prep: stop the turn
+            // at its very start (the press already said "Stopping…").
+            if (pendingCancel.applyTo(currentTurnAbort))
+                interruptCount = 1;
             // 2026-06-07 — persistent status row lifecycle. Started here (not in
             // loop.ts) so the try/finally GUARANTEES the row clears even when the
             // turn throws; loop.ts only narrates activity changes in between.
@@ -1308,7 +1656,7 @@ export async function runRepl(opts) {
                     if ((planPhaseCtx.effectiveMode ?? 'step') === 'guarded') {
                         setGuardedRunActive(true);
                         guardedRunFlagSet = true;
-                        chunkEmitter.emit('chunk', chalk.dim('▶ guarded mode — auto_approve disabled for this run\n'));
+                        chunkEmitter.emit('chunk', formatInfo('Guarded mode · auto-approve is off for this run'));
                     }
                     // Off-switch (2026-07-06, owner) — announce plainly that this run's
                     // phases are NOT audited (honesty: off is a choice, never a lie).
@@ -1320,13 +1668,18 @@ export async function runRepl(opts) {
                     provider,
                     userMessage: prompt,
                     skill: skill,
-                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     signal: currentTurnAbort.signal,
                     suppressSaveHook: planResume !== null || planContinue !== null,
+                    // Task 19 — auto-compact at turn end, except plan resume/continue
+                    // turns (their post-turn persist indexes messages from turn start).
+                    autoCompact: planResume === null && planContinue === null,
                     // A4 — undefined on every non-plan turn (and when tiering is off).
                     modelOverride: planModelOverride,
+                    // Task 9 — a tier-down, never the session role (proxy must not enforce it).
+                    modelRole: planModelOverride ? 'audit' : undefined,
                     // Persist the plan revision the instant its manifest is finalised
                     // (before the continuation modal) so a Ctrl+C can't lose the phase.
                     onPlanManifest: planResumeForHook
@@ -1346,7 +1699,7 @@ export async function runRepl(opts) {
                                 planSavedEarly = true;
                             }
                             catch (err) {
-                                chunkEmitter.emit('chunk', chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                                chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan revision not saved', detail: [err.message] }));
                             }
                         }
                         : planContinueForHook
@@ -1373,7 +1726,7 @@ export async function runRepl(opts) {
                                     // owns the foreign save / quiet-none handling.
                                 }
                                 catch (err) {
-                                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] early continuation save failed: ${err.message}\n`));
+                                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan continuation not saved', detail: [err.message] }));
                                 }
                             }
                             : undefined,
@@ -1386,10 +1739,11 @@ export async function runRepl(opts) {
                 // to do. Same block classic mode prints; in-session it leads with
                 // "type continue" (the partial turn is already saved).
                 const { renderTurnError } = await import('./agent/turn-error-ux.js');
+                turnCancelledByUser = currentTurnAbort?.signal.aborted ?? false;
                 await renderTurnError({
                     err,
                     session,
-                    userInterrupted: currentTurnAbort?.signal.aborted ?? false,
+                    userInterrupted: turnCancelledByUser,
                     inSession: true,
                     print: (line) => chunkEmitter.emit('chunk', line + '\n'),
                 });
@@ -1397,6 +1751,11 @@ export async function runRepl(opts) {
             finally {
                 turnStatusEmitter.stop();
                 currentTurnAbort = null;
+                // Re-review 2 — from here on a Ctrl+C can only stop an automatic
+                // next plan phase (and only when this is a plan turn or a dispatch
+                // is already queued); otherwise it behaves as idle.
+                postTurn = true;
+                postTurnMayChain = planResume !== null || planContinue !== null;
                 // Task 6/7/10 — neither the guarded auto_approve override, the
                 // plan-phase enforcement flag, nor the phase-writes declaration may
                 // outlive the phase turn. (The deviation flag DOES survive this
@@ -1439,7 +1798,7 @@ export async function runRepl(opts) {
                     });
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan revision not saved', detail: [err.message] }));
                 }
             }
             // A1 (defect D23) + Task 6 — harness-owned continuation, now the full
@@ -1452,7 +1811,7 @@ export async function runRepl(opts) {
             if (planResume && planOutcome) {
                 try {
                     const { runPostPhaseChain } = await import('./commands/plan-chain.js');
-                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                     await runPostPhaseChain({
                         savedPath: planOutcome.savedPath,
                         executedPhaseId: planResume.nextPhaseId,
@@ -1470,12 +1829,13 @@ export async function runRepl(opts) {
                         // finally; thread the captured value for the report line.
                         subagentDispatches: planSubagentDispatches,
                         prompt: inkAwarePrompt,
+                        confirm: inkAwareConfirm,
                         queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                     });
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] post-phase chain failed: ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan follow-up steps failed', detail: [err.message] }));
                 }
             }
             // C1 — continuation post-turn: fallback-persist (hook may not have
@@ -1514,13 +1874,13 @@ export async function runRepl(opts) {
                     }
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] continuation save failed: ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan continuation not saved', detail: [err.message] }));
                 }
             }
             if (planContinue && planOutcome) {
                 try {
                     const { runContinuationChain } = await import('./commands/plan-continue.js');
-                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                     await runContinuationChain({
                         prepared: planContinue.prepared,
                         marker: planContinue.marker,
@@ -1529,12 +1889,13 @@ export async function runRepl(opts) {
                         cwd: process.cwd(),
                         subagentDispatches: planSubagentDispatches,
                         prompt: inkAwarePrompt,
+                        confirm: inkAwareConfirm,
                         queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                     });
                 }
                 catch (err) {
-                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] continuation chain failed: ${err.message}\n`));
+                    chunkEmitter.emit('chunk', '\n' + formatFailure({ what: 'Plan follow-up steps failed', detail: [err.message] }));
                 }
             }
             // C1 — the phase reached a resolved terminal (revision persisted, chain
@@ -1565,6 +1926,7 @@ export async function runRepl(opts) {
                 snapshot: turnSnapshot,
                 chunkEmitter,
                 turnModel: planModelOverride ?? session.model,
+                cancelled: turnCancelledByUser,
             });
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
@@ -1582,11 +1944,11 @@ export async function runRepl(opts) {
                 // the transcript reset — it runs for typed AND dispatched resumes,
                 // and only AFTER preparePlanResume succeeds, so a failed prepare
                 // never destroys the session context.
-                chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
                 // Schedule on next tick so the current handleSubmit's promise
                 // resolves cleanly before the next one starts. Recursion via
                 // setImmediate keeps the call stack flat across long chains.
-                setImmediate(() => { void handleSubmit(dispatched); });
+                // (autoDispatch skips it when a post-turn Ctrl+C / /exit asked to stop.)
+                autoDispatch(dispatched);
             }
         };
         // BUG-2b (2026-07-05 live smoke) — single-flight dispatch guard.
@@ -1605,47 +1967,149 @@ export async function runRepl(opts) {
         // check here is a backstop for any direct caller that bypasses
         // beginSubmit's guard — it queues the line as steering, exactly like
         // beginSubmit does mid-turn, instead of starting a twin.
+        /** Round 4 item 9b — the in-flight (or last) dispatch; settled before unmount on exit. */
+        let dispatchTail = null;
         const handleSubmit = async (line) => {
             if (turnStatusEmitter.isBusy()) {
                 const t = line.trim();
+                // Fix round 3 (item 5): slash commands are never steering text.
+                const kind = classifyMidTurnLine(t);
+                if (kind.kind === 'exit') {
+                    onExitRequest();
+                    return;
+                }
+                if (kind.kind === 'slash') {
+                    chunkEmitter.emit('chunk', midTurnSlashHint(kind.command));
+                    return;
+                }
                 if (t.length > 0) {
                     enqueueSteering(t);
-                    const echo = t.split('\n')[0].slice(0, 60);
-                    chunkEmitter.emit('chunk', chalk.cyan(`↳ queued ▸ ${echo}${t.length > echo.length ? '…' : ''}\n`));
+                    chunkEmitter.emit('chunk', steeringEchoLine(t));
                 }
                 return;
             }
+            idleKeepalive.disarm(); // Task 15 — a submit ends the idle period
             turnStatusEmitter.reserve();
+            postTurn = false;
+            postTurnMayChain = false;
             try {
-                await dispatchSubmit(line);
+                // Round 4 item 9b — the exit path waits (capped) for this to finish.
+                const run = dispatchSubmit(line);
+                dispatchTail = run;
+                await run;
             }
             finally {
                 turnStatusEmitter.release();
+                postTurn = false;
+                postTurnMayChain = false;
+                cancelAnnouncedPhase = null;
+                // A cancel asked for during prep of a dispatch that never started a
+                // turn must not leak into the next one.
+                pendingCancel.clear();
+                interruptCount = 0;
+                // `/exit` typed mid-turn: the turn has now stopped and saved — exit.
+                if (exitAfterTurn) {
+                    done = true;
+                    if (resolveDone)
+                        resolveDone();
+                }
+                // Task 15 — back at the prompt: warm the cache while the user reads
+                // (no-op unless this submit made a new cacheable request). Not when
+                // the submit ended in an exit (merge: UI round-3 /exit mid-turn).
+                if (!done)
+                    idleKeepalive.armAfterTurn(session);
+            }
+        };
+        // Fix round 3 (item 5) — `/exit` / `/quit` typed while a turn runs:
+        // cancel the turn the same way Ctrl+C does, then exit once dispatch
+        // returns (handleSubmit's finally). Mid-prep (no abort controller yet)
+        // the cancel is held and applied when the turn creates its controller,
+        // or stops routing outright (review I2).
+        let exitAfterTurn = false;
+        // Final review B-I1 — a /rewind restore is not a turn and runs outside
+        // handleSubmit: interrupts during it are decided as idle, /exit waits for
+        // it, and the cancel/exit state is reset when it ends.
+        const restoreGuard = createRestoreGuard({
+            resetDispatchState: () => {
+                cancelAnnouncedPhase = null;
+                pendingCancel.clear();
+                interruptCount = 0;
+            },
+            exit: () => { done = true; if (resolveDone)
+                resolveDone(); },
+        });
+        const onExitRequest = () => {
+            if (restoreGuard.active) {
+                restoreGuard.requestExit();
+                chunkEmitter.emit('chunk', '\n' + formatInfo('Exiting when the restore has finished'));
+                return;
+            }
+            if (!turnStatusEmitter.isBusy() && !currentTurnAbort) {
+                done = true;
+                if (resolveDone)
+                    resolveDone();
+                return;
+            }
+            exitAfterTurn = true;
+            if (currentTurnAbort && interruptCount === 0) {
+                interruptCount++;
+                chunkEmitter.emit('chunk', '\n' + formatInfo('Stopping the turn · exiting when it has saved'));
+                currentTurnAbort.abort();
+            }
+            else if (!currentTurnAbort) {
+                announcePendingCancel(true);
             }
         };
         // Phase D5 (2026-05-17) — Ctrl+C handler routed through Ink.
         // First press during turn: abort the turn (preserves partial work).
         // Second press during the SAME turn: hard-exit (escape hatch in case
         // the abort doesn't take effect for some reason).
-        // Press at idle: clean exit (printGoodbye + leaveAltScreen).
+        // Press at idle (fix round 3, item 4): the first press only arms the
+        // exit — App shows "Press Ctrl+C again to exit" — and a second press
+        // within IDLE_EXIT_WINDOW_MS exits cleanly (printGoodbye + leaveAltScreen).
+        // Cards / sheets / palettes eat their own Ctrl+C and never get here.
+        let idleInterruptAt = 0;
         const onInterrupt = () => {
-            if (currentTurnAbort) {
+            const now = Date.now();
+            const action = decideInterrupt({
+                turnActive: currentTurnAbort !== null,
+                // Review I3 — routing / prep in flight without a controller yet is
+                // not idle: cancel the pending turn, never arm "press again".
+                busy: turnStatusEmitter.isBusy() && !restoreGuard.active,
+                phase: cancelPhase(),
+                canChain: canChainNow(),
+                turnPresses: interruptCount,
+                lastIdleAt: idleInterruptAt,
+                now,
+            });
+            if (action === 'abort-turn') {
                 interruptCount++;
-                if (interruptCount === 1) {
-                    chunkEmitter.emit('chunk', chalk.yellow('\n⚠  Interrupting turn — saving partial work...\n'));
-                    currentTurnAbort.abort();
-                }
-                else {
-                    // Second Ctrl+C during the same turn — give up and exit.
-                    chunkEmitter.emit('chunk', chalk.red('\n✗ Force-exit on second Ctrl+C.\n'));
-                    unmount();
-                    process.stdout.write('\x1b[?25h'); // restore cursor
-                    printGoodbye(session);
-                    process.exit(130); // 128 + SIGINT
-                }
+                chunkEmitter.emit('chunk', '\n' + formatInfo('Stopping the turn · saving the work done so far'));
+                currentTurnAbort.abort();
+            }
+            else if (action === 'cancel-pending') {
+                interruptCount++;
+                announcePendingCancel(false);
+            }
+            else if (action === 'force-exit') {
+                // Second Ctrl+C during the same turn — give up and exit.
+                chunkEmitter.emit('chunk', '\n' + formatInfo('Exiting · second Ctrl+C'));
+                unmount();
+                process.stdout.write('\x1b[?25h'); // restore cursor
+                printGoodbye(session);
+                // Final review B M-2 — through gracefulExit (fetch drain, capped).
+                // Re-review item 3 — mark the session done first, so nothing queued
+                // (auto-dispatch, the loop) starts during the drain window.
+                done = true;
+                exitAfterTurn = true;
+                void gracefulExit(130); // 128 + SIGINT
+            }
+            else if (action === 'arm') {
+                idleInterruptAt = now;
+                return 'armed';
             }
             else {
-                // Idle — clean exit, same path as /exit.
+                // Second idle press inside the window — clean exit, same path as /exit.
                 done = true;
                 if (resolveDone)
                     resolveDone();
@@ -1665,7 +2129,10 @@ export async function runRepl(opts) {
         enableBracketedPaste();
         process.on('exit', () => disableBracketedPaste());
         const inkStdin = new InkStdinPasteGuard();
-        process.stdin.pipe(inkStdin);
+        // Live fix 2026-09-26 — an @inquirer prompt that ran before this point
+        // (resume picker, SAP picker, API key, first run, onboarding) leaves
+        // Windows console stdin dead to the pipe. Cycle raw mode + flow first.
+        pipeRevivedStdin(inkStdin, process.stdin);
         // Task 3 (ux-wave3) — rewind wiring, shared with the classic path through
         // executeRestore (which holds the single-flight reserve for the FULL
         // restore — review I1a: a restore counts as busy, submits become steering —
@@ -1676,25 +2143,25 @@ export async function runRepl(opts) {
         const inkRequestApproval = (change, risk, transport) => new Promise((resolve) => {
             approvalEmitter.emit('request', { change, effectiveRisk: risk, transport, resolve });
         });
-        const runInkRestore = (c) => executeRestore(c, {
+        const runInkRestore = (c) => restoreGuard.run(() => executeRestore(c, {
             adt, cfg, alias: selectedAlias,
-            toolCtx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+            toolCtx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
             suppliedTransport: currentTransportAccessor.get() ?? undefined,
             requestApproval: inkRequestApproval,
             // deps.log streams each pipeline step dim to scrollback live; the final
-            // ✓ / ↩ cancelled / ✗ summary comes from executeRestore's print.
+            // the done / cancelled / failed summary comes from executeRestore's print.
             log: (line) => chunkEmitter.emit('chunk', chalk.dim(line) + '\n'),
-        }, (line) => chunkEmitter.emit('chunk', line + '\n'));
+        }, (line) => chunkEmitter.emit('chunk', line + '\n')));
         const { unmount } = render(React.createElement(App, {
             chunkEmitter,
             onSubmit: (line) => { void handleSubmit(line); },
             onSlashTrigger: () => { },
             onHistoryTrigger: () => { },
             getToolCalls: () => session.toolCalls,
-            // Task 5 (ux-wave2) — todo-panel seed accessor (getToolCalls
-            // pattern): App reads persisted todos on mount and on every
-            // Ctrl+T open, so a resumed session shows its list before any
-            // todo_set fires in this process.
+            // Live-checklist seed accessor (getToolCalls pattern; piece 2 P2):
+            // App reads persisted todos on mount and when the rewind panel
+            // closes, so a resumed session shows its plan before any todo_set
+            // fires in this process.
             getTodos: () => session.todos ?? [],
             // Task 3 (ux-wave3) — rewind panel accessors. Candidates join
             // session.toolCalls with the on-disk snapshot list (async fs read),
@@ -1711,6 +2178,7 @@ export async function runRepl(opts) {
             sapRole: cfg.sap[selectedAlias]?.role,
             sapAlias: selectedAlias,
             onInterrupt,
+            onExitRequest,
         }), {
             // Bug 2 (wave1 live-fix) — Ink reads from the paste guard, not
             // process.stdin directly. The guard satisfies Ink's full stdin
@@ -1732,7 +2200,13 @@ export async function runRepl(opts) {
             patchConsole: true,
         });
         await donePromise;
+        // Round 4 item 9b — a second idle Ctrl+C right after a turn resolved the
+        // exit while post-turn work (saving, audit) still ran. Let it finish,
+        // capped so a stuck step can never hold the exit.
+        const exitTail = await settleWithin(dispatchTail, EXIT_TAIL_CAP_MS);
         unmount();
+        setTraceEmitter(undefined);
+        idleKeepalive.disarm(); // Task 15 — no pings after /exit
         // Bug 2 (wave1 live-fix) — undo the paste plumbing so the user's
         // shell doesn't keep receiving marker-wrapped pastes after exit.
         process.stdin.unpipe(inkStdin);
@@ -1744,6 +2218,11 @@ export async function runRepl(opts) {
         // line lands in the user's shell scrollback alongside the session
         // history. In inline mode the conversation IS in scrollback (no
         // alt-screen erased it), so this is just a friendly bookend.
+        // Review M7 — the cap expired: the process exits next, so say the save may
+        // not have landed instead of cutting it off silently.
+        if (exitTail === 'timeout') {
+            console.log(formatAttention({ text: 'Post-turn work did not finish', fact: 'the session file may be incomplete' }).trimEnd());
+        }
         printGoodbye(session);
         return 0;
     }
@@ -1756,7 +2235,10 @@ export async function runRepl(opts) {
     // a single line before readline sees it. See src/repl/bracketed-paste.ts.
     enableBracketedPaste();
     const pasteInput = new BracketedPasteDecoder();
-    process.stdin.pipe(pasteInput);
+    // Review I2: the classic path is reached through the same pre-REPL inquirer
+    // prompts (resume picker, SAP picker, password, first run) — revive stdin
+    // with the full reset cycle before piping, exactly like the Ink branch.
+    pipeRevivedStdin(pasteInput, process.stdin);
     const history = loadHistory();
     const rl = readline.createInterface({
         input: pasteInput,
@@ -1790,7 +2272,7 @@ export async function runRepl(opts) {
     // empty. Attached ONLY for non-TTY stdin: interactive type-ahead during
     // a turn keeps its existing semantics.
     const pipedStdin = !process.stdin.isTTY;
-    const earlyLines = pipedStdin ? attachEarlyLineBuffer(rl) : noopEarlyLineBuffer();
+    const earlyLines = pipedStdin ? attachEarlyLineBuffer(rl, process.stdin) : noopEarlyLineBuffer();
     // B2 fix (2026-06-12) — classic-mode notice channel. Tool handlers emit
     // 'warn'/'info' (and pre-formatted 'chunk' lines like the write verify
     // chain) on ctx.chunkEmitter; in classic mode that slot used to be
@@ -1800,8 +2282,9 @@ export async function runRepl(opts) {
     // keep their direct-stdout classic path (spinner stays enabled).
     const classicOutputEmitter = createClassicOutputEmitter();
     // Prompt string: 'CSPeach ' + '›' in peach colour
-    const promptStr = 'CSPeach ' + chalk.hex(PEACH)('›') + ' ';
-    // When we dispatch an inquirer sub-prompt (coaching picker, pickSkill),
+    // I1 — the classic prompt is not legacy-pinned; it takes the brand role (spec §1.1).
+    const promptStr = 'CSPeach ' + paint('brand', '›') + ' ';
+    // When we dispatch an inquirer sub-prompt (e.g. the coaching picker),
     // readline is paused to give inquirer exclusive stdin access. On resolve
     // inquirer sometimes disturbs the stdin stream in a way that makes our
     // readline fire 'close' even though the user did NOT press Ctrl-D. Suppress
@@ -1835,7 +2318,7 @@ export async function runRepl(opts) {
     // v0.6 — module-scope flag the per-turn SIGINT handler sets to true while
     // a turn is in flight. Both `rl.on('close')` and `rl.on('SIGINT')` below
     // check this flag and bail out so they don't race against the turn-scoped
-    // handler that wants to abort the LLM stream and render "✋ Turn cancelled."
+    // handler that wants to abort the LLM stream and render "· Turn cancelled"
     // Without this flag, Ctrl+C during a stream lands in the readline SIGINT
     // path first (line buffer is empty during streaming → "Goodbye" + exit),
     // killing the CLI before the turn handler can do anything useful.
@@ -1875,7 +2358,7 @@ export async function runRepl(opts) {
         // v0.6 — turn-scoped SIGINT handler (registered just before runTurn
         // and torn down right after) takes precedence. If a turn is in flight,
         // the user wants to interrupt THE TURN, not exit the CLI. Returning
-        // early lets the turn handler run its abort + "✋ Turn cancelled." UX.
+        // early lets the turn handler run its abort + "· Turn cancelled" UX.
         if (turnInProgress)
             return;
         // Inspect the readline's internal line buffer + our prefill state.
@@ -2001,9 +2484,11 @@ export async function runRepl(opts) {
     // can pause us and suppress the spurious 'close' inquirer emits on
     // release. See src/repl/inquirer-guard.ts for the failure mode this
     // prevents (CSPeach silently exiting after a tool-mediated prompt).
+    // Fix 8 (2026-09-26): pass pasteInput so a prompt detaches it from stdin —
+    // keys typed into the prompt must not be replayed into the REPL line.
     registerReadline(rl, (v) => {
         suppressRlClose = v;
-    });
+    }, { input: pasteInput });
     // 2026-05-08: one-time workspace-default migration. The default workspace
     // changed from `~/CSPeach/` to project-rooted `<git-root>/.cspeach/`.
     // Existing users with files in ~/CSPeach/ get asked once how to handle
@@ -2058,7 +2543,7 @@ export async function runRepl(opts) {
             // transcript reset — it runs for typed AND dispatched resumes, and
             // only AFTER preparePlanResume succeeds, so a failed prepare never
             // destroys the session context.
-            console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
+            console.log(formatInfo(`Auto-routed: ${dispatchedCmd}`).trimEnd());
             line = dispatchedCmd;
         }
         else if (earlyLines.size() > 0) {
@@ -2076,8 +2561,12 @@ export async function runRepl(opts) {
         }
         else {
             const effectivePrompt = pendingPrefill ? promptStr + pendingPrefill : promptStr;
+            // Task 15 — idle at the prompt: warm the cache (no-op unless the last
+            // turn made a new cacheable request); disarmed once the line arrives.
+            idleKeepalive.armAfterTurn(session);
             try {
                 line = await rl.question(effectivePrompt);
+                idleKeepalive.disarm();
             }
             catch {
                 // rl.question rejects for two distinct reasons:
@@ -2091,6 +2580,7 @@ export async function runRepl(opts) {
                 // discriminates the two cases reliably.
                 const rlAny = rl;
                 if (rlAny.closed) {
+                    idleKeepalive.disarm();
                     // UX-5 #5 — piped stdin: a multi-line chunk can resolve the
                     // pending question with line 1 and QUEUE line 2+ before EOF
                     // closes the readline. Drain the queue before exiting.
@@ -2114,6 +2604,9 @@ export async function runRepl(opts) {
         const trimmed = line.trim();
         if (!trimmed)
             continue;
+        // Round 6 review I2 — see the Ink path.
+        const resumedSkill = resumeKeepsSkill ? session.skill ?? null : null;
+        resumeKeepsSkill = false;
         // Persist non-empty input to history file (Task 8: consecutive
         // duplicates are skipped inside the shared writer).
         appendHistoryEntry(trimmed);
@@ -2147,7 +2640,7 @@ export async function runRepl(opts) {
             continue;
         }
         if (trimmed.endsWith(' /cancel')) {
-            console.log(chalk.dim('↩ cancelled'));
+            console.log(formatRoutingLine({ kind: 'cancelled' }).trimEnd());
             continue;
         }
         if (trimmed === '/exit' || trimmed === '/quit') {
@@ -2215,7 +2708,7 @@ export async function runRepl(opts) {
         if (trimmed === '/mode' || trimmed.startsWith('/mode ')) {
             const modeArg = trimmed === '/mode' ? undefined : (trimmed.slice('/mode '.length).trim() || undefined);
             const { line: modeLine, mode } = runModeCommand(modeArg, cfg.write_mode, cfg.sap[selectedAlias]?.role, selectedAlias);
-            console.log(chalk.dim(modeLine));
+            console.log(formatInfo(modeLine).trimEnd());
             sapStateStore.update({ writeMode: mode });
             continue;
         }
@@ -2228,13 +2721,9 @@ export async function runRepl(opts) {
             const recapWs = await resolveWorkspacePath().catch(() => undefined);
             const recapLines = buildRecap(session, process.cwd(), { workspaceDir: recapWs });
             console.log('');
-            if (recapLines.length === 0) {
-                console.log(chalk.dim('nothing to recap yet'));
-            }
-            else {
-                for (const recapLine of recapLines)
-                    console.log(chalk.dim(recapLine));
-            }
+            console.log(recapLines.length === 0
+                ? formatInfo('Nothing to recap yet').trimEnd()
+                : formatPanel('Recap', recapLines.map((l) => '  ' + paint('dim', sanitizeControlChars(l)))).join('\n'));
             continue;
         }
         // Phase 2 conversation hygiene (2026-05-16) — classic-mode /compact.
@@ -2249,15 +2738,15 @@ export async function runRepl(opts) {
                 return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), 
                 // model-governance step 2d — compact model resolves env > local >
                 // server > built-in (== COMPACTION_MODEL when nothing set).
-                { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact', 'X-CSPeach-Model-Role': 'compact' } });
             };
             try {
-                console.log(chalk.dim('\nCompacting older turns into a summary...'));
+                console.log('\n' + formatInfo('Compacting older turns into a summary…').trimEnd());
                 const result = await runCompact({ session, summarise, keepRecentTurns: compactCfg.keep_recent_turns });
                 console.log(formatCompactResult(result, compactCfg.keep_recent_turns));
             }
             catch (err) {
-                console.log(chalk.red(`\n/compact failed: ${err instanceof Error ? err.message : String(err)}\n`));
+                console.log('\n' + formatFailure({ what: 'Compact failed', detail: [err instanceof Error ? err.message : String(err)] }));
             }
             continue;
         }
@@ -2278,7 +2767,7 @@ export async function runRepl(opts) {
                 const { openFilePicker } = await import('./repl/file-picker.js');
                 const result = await openFilePicker();
                 if (result.kind === 'command') {
-                    console.log(chalk.dim(`↪ Picked. Press Enter to run, or edit first.`));
+                    console.log(formatInfo('Picked · press Enter to run, or edit first').trimEnd());
                     pendingPrefill = result.command;
                 }
                 else if (result.kind === 'empty') {
@@ -2293,7 +2782,7 @@ export async function runRepl(opts) {
                 // result.kind === 'cancelled' — print nothing.
             }
             catch (err) {
-                console.log(chalk.red(`\n[/files] ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Could not open the file list', detail: [err.message] }));
             }
             continue;
         }
@@ -2302,31 +2791,11 @@ export async function runRepl(opts) {
             // Defensive: a config that predates the [ui] section may have cfg.ui === undefined
             // if loaded before loader.ts's deep-merge fix. Initialise to the default.
             if (!cfg.ui)
-                cfg.ui = { rendering: 'auto' };
+                cfg.ui = { rendering: 'auto', look: DEFAULT_CONFIG.ui.look };
             const arg = trimmed.slice(3).trim().toLowerCase();
-            if (arg === '') {
-                console.log(`\nCurrent UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
-                    `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})\n`);
-                console.log(chalk.dim('  /ui classic  — chalk REPL (v0.2 style — default, fully tested)'));
-                console.log(chalk.dim('  /ui ink      — Ink frame (v0.3 — opt-in while polish is pending)'));
-                console.log(chalk.dim('  /ui auto     — choose automatically based on terminal'));
-                console.log(chalk.dim('\nChanges are written to ~/.cspeach/config.toml and'));
-                console.log(chalk.dim('take effect the next time you launch cspeach.\n'));
-            }
-            else if (arg === 'auto' || arg === 'ink' || arg === 'classic') {
-                cfg.ui.rendering = arg;
-                try {
-                    await saveConfig(cfg);
-                    console.log(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
-                    console.log(chalk.dim('Relaunch cspeach (`/exit` then `cspeach`) to apply.\n'));
-                }
-                catch (err) {
-                    console.log(chalk.red(`\n✗ Failed to save config: ${err.message}\n`));
-                }
-            }
-            else {
-                console.log(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.\n`));
-            }
+            if (await handleUiLook(arg, cfg, saveConfig, (s) => console.log(s)))
+                continue;
+            await handleUiRendering(arg, cfg, saveConfig, (s) => console.log(s), shouldUseInk() ? 'ink' : 'classic');
             continue;
         }
         // /reroute — re-dispatch session.lastUserPrompt to a different skill
@@ -2338,15 +2807,26 @@ export async function runRepl(opts) {
                 continue;
             }
             const preview = rr.prompt.length > 60 ? rr.prompt.slice(0, 57) + '...' : rr.prompt;
-            console.log(chalk.dim(`↪ Rerouting "${preview}" → /${rr.skill}`));
+            console.log(formatInfo(`Rerouting "${preview}" to /${rr.skill}`).trimEnd());
             if (rr.warning)
                 console.log(chalk.dim(`  (${rr.warning})`));
-            await runTurn({
-                provider,
-                userMessage: rr.prompt,
-                skill: rr.skill,
-                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
-                pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
+            // A turn error prints the same stderr block as the normal turn path.
+            await runRerouteTurn({
+                run: () => runTurn({
+                    provider,
+                    userMessage: rr.prompt,
+                    skill: rr.skill,
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
+                    autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
+                }),
+                session,
+                print: (line) => console.error(line),
+                onFinally: () => {
+                    // P2 fix round 1 — /reroute skips pushPostTurnStatus, so run its
+                    // turn-end plan step here (classic prints the block once).
+                    emitPlanTurnEnd(session);
+                },
             });
             continue;
         }
@@ -2354,7 +2834,8 @@ export async function runRepl(opts) {
         // classified afresh instead of continuing the previous skill's Q&A chain.
         if (trimmed === '/new' || trimmed === '/reset') {
             session.awaitingSkillAnswer = false;
-            console.log(chalk.dim('↩ fresh start — next prompt will be classified normally'));
+            session.todos = []; // P2 — /new clears the plan (spec §4)
+            console.log(formatInfo('Fresh start · the next prompt picks a skill again').trimEnd());
             continue;
         }
         // /transport — session current-transport state for Rule 9 (transport isolation)
@@ -2409,7 +2890,7 @@ export async function runRepl(opts) {
                 // the prefilled buffer so iter 3 starts fresh, clear the
                 // guard, and skip dispatch.
                 lastCancelledSlashLine = null;
-                console.log(chalk.dim('↩ dropped'));
+                console.log(formatInfo('Dropped').trimEnd());
                 process.nextTick(() => prefillReadline(rl, ''));
                 continue;
             }
@@ -2421,7 +2902,7 @@ export async function runRepl(opts) {
             const prefix = head.slice(1); // drop the leading /
             const picked = await openSlashPicker(prefix);
             if (picked === null) {
-                console.log(chalk.dim('↩ cancelled — edit, or press Enter again to drop'));
+                console.log(formatInfo('Cancelled · edit, or press Enter again to drop').trimEnd());
                 lastCancelledSlashLine = trimmed;
                 process.nextTick(() => prefillReadline(rl, trimmed));
                 continue;
@@ -2448,13 +2929,13 @@ export async function runRepl(opts) {
                     // Without this the line went to the LLM with a bare/partial
                     // @ — wasted a turn and confused the user who'd just cancelled.
                     lastCancelledAtLine = null;
-                    console.log(chalk.dim('↩ dropped'));
+                    console.log(formatInfo('Dropped').trimEnd());
                     process.nextTick(() => prefillReadline(rl, ''));
                     continue;
                 }
                 const pickedFile = await openAtPicker(atPrefix);
                 if (pickedFile === null) {
-                    console.log(chalk.dim('↩ cancelled — edit, or press Enter again to drop'));
+                    console.log(formatInfo('Cancelled · edit, or press Enter again to drop').trimEnd());
                     lastCancelledAtLine = resolvedTrimmed;
                     process.nextTick(() => prefillReadline(rl, resolvedTrimmed));
                     continue;
@@ -2499,9 +2980,7 @@ export async function runRepl(opts) {
                     // then asked an unanswerable question. Every skill now carries an
                     // `asks` line with an example (skill-catalog.ts).
                     const asks = SKILL_CATALOG.find((e) => `/${e.name}` === head)?.asks;
-                    console.log(chalk.dim(asks
-                        ? `↪ ${head} — ${asks}`
-                        : `${'↪'} ${head} — type your prompt and press Enter`));
+                    console.log(formatInfo(asks ? `${head} — ${asks}` : `${head} — type your prompt and press Enter`).trimEnd());
                     console.log(chalk.dim('  Enter to send · /cancel to abandon'));
                     lastEmptyPrefill = head;
                 }
@@ -2567,15 +3046,16 @@ export async function runRepl(opts) {
                     chalk.dim('Type a new question, /new to reset, or /exit to quit.'));
                 continue;
             }
-            if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
-                console.log(chalk.dim(`↪ Continuing /${session.skill}`));
+            // Round 6 item 4c / review I2 — see the Ink path.
+            if ((session.awaitingSkillAnswer || (resumedSkill !== null && isShortFollowUp(trimmed)) || isAckContinuation(trimmed, session.skill)) && session.skill) {
+                console.log(formatRoutingLine({ kind: 'continuing', skill: session.skill }).trimEnd());
                 skill = session.skill;
             }
             else if (isBareAck(trimmed)) {
                 // Bare "y" / "n" / "cancel" with no skill to continue — almost always
                 // a stray keystroke after an aborted turn, not a request to start
                 // work. Don't burn a classifier round-trip on it.
-                console.log(chalk.dim('↩ no active skill — type /help or a full prompt'));
+                console.log(formatInfo('No active skill · type /help or a full prompt').trimEnd());
                 continue;
             }
             else {
@@ -2585,46 +3065,76 @@ export async function runRepl(opts) {
                         last_skill: session.last_skill ?? null,
                         last_object: extractedObject ?? session.last_object ?? null,
                     });
-                    if (c.offline) {
-                        console.log(chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
-                    }
                     if (c.screenshot)
-                        console.log(chalk.dim(`┄ Screenshot: ${c.screenshot}`));
-                    const decision = decideRouting(c);
-                    // 2026-05-17 — pass the just-used skill so the picker can
-                    // default cursor to it. session.skill = immediately-previous
-                    // turn's skill, NOT session.last_skill (TWO turns ago).
-                    const continueSkillClassic = session.skill ?? null;
-                    let pickedResult;
-                    // Coaching picker path — inquirer takes over stdin. Use the shared
-                    // withInquirer guard so the suppress-close window stays active
-                    // across the close-fire tick (inline guard cleared the flag
-                    // synchronously, leaking the close-fire and dropping CSPeach to
-                    // the shell mid-session).
-                    const runPicker = async (params) => {
-                        return withInquirer(() => coachingPickerClassic(params));
-                    };
-                    if (cfg.classifier.safe_mode) {
-                        // Safe mode overrides the decision — always open the full picker.
-                        pickedResult = await runPicker(buildCoachingParams(c, trimmed, false, continueSkillClassic));
-                    }
-                    else if (decision.kind === 'silent') {
-                        console.log(chalk.dim(`┄ Routed to /${decision.skill}`));
-                        pickedResult = decision.skill;
+                        console.log(formatInfo(`Screenshot: ${c.screenshot}`).trimEnd());
+                    // Fix 10 (2026-09-26): routing failed mid-skill → stay in the
+                    // active skill (one dim line), never the picker. Same decision as
+                    // the Ink path (routingFailureOutcome).
+                    const failed = routingFailureOutcome(routingFailureFromResult(c), session.skill);
+                    if (failed.kind === 'stay') {
+                        console.log(formatInfo(failed.line).trimEnd());
+                        skill = failed.skill;
                     }
                     else {
-                        const preSelect = decision.kind === 'coach';
-                        pickedResult = await runPicker(buildCoachingParams(decision.result, trimmed, preSelect, continueSkillClassic));
+                        if (c.offline) {
+                            // Fix 9: true wording from the failure kind (a timeout is not "offline").
+                            console.log(formatAttention(routingFailureNotice(routingFailureFromResult(c), c.transport_error)).trimEnd());
+                        }
+                        // Round 6 review I2 — see the Ink path.
+                        const decision = resumedSkill ? applyResumedSkill(decideRouting(c), resumedSkill) : decideRouting(c);
+                        // 2026-05-17 — pass the just-used skill so the picker can
+                        // default cursor to it. session.skill = immediately-previous
+                        // turn's skill, NOT session.last_skill (TWO turns ago).
+                        const continueSkillClassic = session.skill ?? null;
+                        let pickedResult;
+                        // Coaching picker path — inquirer takes over stdin. Use the shared
+                        // withInquirer guard so the suppress-close window stays active
+                        // across the close-fire tick (inline guard cleared the flag
+                        // synchronously, leaking the close-fire and dropping CSPeach to
+                        // the shell mid-session).
+                        const runPicker = async (params) => {
+                            return withInquirer(() => coachingPickerClassic(params));
+                        };
+                        if (pipedStdin) {
+                            // Round 7 item 8a — piped stdin has no keyboard to answer the
+                            // picker (it ended in "readline was closed"): run the router's
+                            // top pick, like one-shot.
+                            const p = pipedRoutingPick(c);
+                            for (const l of p.lines)
+                                console.log(l);
+                            pickedResult = p.skill;
+                        }
+                        else if (cfg.classifier.safe_mode) {
+                            // Safe mode overrides the decision — always open the full picker.
+                            pickedResult = await runPicker(buildCoachingParams(c, trimmed, false, continueSkillClassic));
+                        }
+                        else if (decision.kind === 'silent') {
+                            console.log(formatRoutingLine({ kind: 'using', skill: decision.skill }).trimEnd());
+                            pickedResult = decision.skill;
+                        }
+                        else {
+                            const preSelect = decision.kind === 'coach';
+                            pickedResult = await runPicker(buildCoachingParams(decision.result, trimmed, preSelect, continueSkillClassic));
+                        }
+                        if (pickedResult === PICK_CANCELLED) {
+                            console.log(formatRoutingLine({ kind: 'cancelled' }).trimEnd());
+                            continue;
+                        }
+                        skill = pickedResult;
+                    } // end fix-10 fallback branch
+                }
+                catch (err) {
+                    const failure = routingFailureFromError(err);
+                    const failed = routingFailureOutcome(failure, session.skill);
+                    if (failed.kind === 'stay') {
+                        // Fix 10: HTTP routing failure mid-skill → stay in the active skill.
+                        console.log(formatInfo(failed.line).trimEnd());
+                        skill = failed.skill;
                     }
-                    if (pickedResult === PICK_CANCELLED) {
-                        console.log(chalk.dim('↩ cancelled — type a new prompt'));
+                    else {
+                        console.log('\n' + formatFailure({ what: failure ? routingFailureText(failure) : 'Could not pick a skill for this prompt', detail: [err.message], next: 'start the prompt with a skill, e.g. /abap-explain' }).trimEnd());
                         continue;
                     }
-                    skill = pickedResult;
-                }
-                catch (err) {
-                    console.log(chalk.red(`\n[classifier error] ${err.message}`));
-                    continue;
                 }
             }
         }
@@ -2652,7 +3162,7 @@ export async function runRepl(opts) {
                 });
             }
             catch (err) {
-                console.log(chalk.red(`\n[--status] ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Could not show the status', detail: [err.message] }));
             }
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
@@ -2677,7 +3187,7 @@ export async function runRepl(opts) {
         if (skill === 'abap-plan' && /(^|\s)--resume(\s|$)/.test(prompt)) {
             try {
                 const { preparePlanResume } = await import('./commands/plan-resume.js');
-                const { inkAwarePrompt } = await import('./agent/loop.js');
+                const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                 planResume = await preparePlanResume({
                     body: prompt,
                     cwd: process.cwd(),
@@ -2688,11 +3198,12 @@ export async function runRepl(opts) {
                     // Task 9 — run-lease identity + takeover prompt (classic mirror).
                     sessionId: session.id,
                     prompt: inkAwarePrompt,
+                    confirm: inkAwareConfirm,
                     log: (...lines) => lines.forEach((l) => console.log(l)),
                 });
             }
             catch (err) {
-                console.log(chalk.red(`\n[--resume] ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Could not resume the plan', detail: [err.message] }));
             }
             if (!planResume) {
                 session.last_skill = previousSkill ?? null;
@@ -2706,7 +3217,7 @@ export async function runRepl(opts) {
             if (planResume.reauditPhaseId) {
                 try {
                     const { runReauditPass } = await import('./commands/plan-chain.js');
-                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                     await runReauditPass({
                         savedPath: planResume.path,
                         phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
@@ -2718,12 +3229,13 @@ export async function runRepl(opts) {
                         auditMode: planResume.auditMode,
                         auditFlag: planResume.auditFlag,
                         prompt: inkAwarePrompt,
+                        confirm: inkAwareConfirm,
                         queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                         log: (...lines) => lines.forEach((l) => console.log(l)),
                     });
                 }
                 catch (err) {
-                    console.log(chalk.red(`\n[plan] re-audit failed: ${err.message}\n`));
+                    console.log('\n' + formatFailure({ what: 'Plan re-audit failed', detail: [err.message] }));
                 }
                 // Task 9 (review fix) — release ONLY when the re-audit leg queued no
                 // follow-up (classic mirror; the loop-top pre-prompt consumer picks
@@ -2742,7 +3254,7 @@ export async function runRepl(opts) {
             {
                 const { resetContextForPlanResume } = await import('./commands/plan-resume.js');
                 if (resetContextForPlanResume(session)) {
-                    console.log(chalk.dim('↪ Plan phase starts in a fresh bounded context — prior transcript cleared'));
+                    console.log(formatInfo('Plan phase starts in a fresh bounded context · earlier conversation cleared').trimEnd());
                 }
             }
             planResumeMsgStart = session.messages.length;
@@ -2788,7 +3300,7 @@ export async function runRepl(opts) {
                 planContinue = { prepared: r.prepared, marker };
                 planPhaseStartedAt = marker.attemptStartedAt;
                 planResumeMsgStart = session.messages.length;
-                console.log(chalk.dim(`↪ re-attaching to in-flight plan phase ${marker.phaseId} (${r.prepared.path})`));
+                console.log(formatInfo(`Re-attaching to in-flight plan phase ${marker.phaseId} (${r.prepared.path})`).trimEnd());
             }
             else if (r.stale) {
                 session.plan_in_flight = null; // plan/phase gone for good — marker is noise
@@ -2805,6 +3317,8 @@ export async function runRepl(opts) {
         let planSubagentDispatches;
         const planResumeForHook = planResume;
         const turnStart = Date.now();
+        // UI fix round (1.1.20) — card waits are excluded from the receipt's time.
+        const turnStartPausedMs = turnStatusEmitter.pausedMs();
         // H1 — `session.usage` is session-LIFETIME (initialised once in
         // newSession, saved across turns). The footer's "this turn" label was
         // misleading — it actually showed cumulative lifetime tokens. Snapshot
@@ -2843,7 +3357,7 @@ export async function runRepl(opts) {
                 return;
             turnSigintFired = true;
             interruptedByUser = true;
-            process.stderr.write(chalk.yellow('\n⚠  Interrupting turn — saving partial work...\n'));
+            process.stderr.write('\n' + formatInfo('Stopping the turn · saving the work done so far'));
             turnAbort.abort();
             // Remove ourselves so a SECOND Ctrl+C falls through to the
             // existing rl SIGINT handler (which clears the line / exits) once
@@ -2871,7 +3385,7 @@ export async function runRepl(opts) {
                 if ((planPhaseCtx.effectiveMode ?? 'step') === 'guarded') {
                     setGuardedRunActive(true);
                     guardedRunFlagSet = true;
-                    console.log(chalk.dim('▶ guarded mode — auto_approve disabled for this run'));
+                    console.log(formatInfo('Guarded mode · auto-approve is off for this run').trimEnd());
                 }
                 // Off-switch (2026-07-06, owner) — announce plainly that this run's
                 // phases are NOT audited (honesty: off is a choice, never a lie).
@@ -2887,8 +3401,13 @@ export async function runRepl(opts) {
                 pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                 signal: turnAbort.signal,
                 suppressSaveHook: planResume !== null || planContinue !== null,
+                // Task 19 — auto-compact at turn end, except plan resume/continue
+                // turns (their post-turn persist indexes messages from turn start).
+                autoCompact: planResume === null && planContinue === null,
                 // A4 — undefined on every non-plan turn (and when tiering is off).
                 modelOverride: planModelOverride,
+                // Task 9 — a tier-down, never the session role (proxy must not enforce it).
+                modelRole: planModelOverride ? 'audit' : undefined,
                 onPlanManifest: planResumeForHook
                     ? async (assistantText) => {
                         try {
@@ -2906,7 +3425,7 @@ export async function runRepl(opts) {
                             planSavedEarly = true;
                         }
                         catch (err) {
-                            console.log(chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
+                            console.log('\n' + formatFailure({ what: 'Plan revision not saved', detail: [err.message] }));
                         }
                     }
                     : planContinueForHook
@@ -2933,7 +3452,7 @@ export async function runRepl(opts) {
                                 // owns the foreign save / quiet-none handling.
                             }
                             catch (err) {
-                                console.log(chalk.red(`\n[plan] early continuation save failed: ${err.message}\n`));
+                                console.log('\n' + formatFailure({ what: 'Plan continuation not saved', detail: [err.message] }));
                             }
                         }
                         : undefined,
@@ -2990,7 +3509,7 @@ export async function runRepl(opts) {
                 });
             }
             catch (err) {
-                console.log(chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Plan revision not saved', detail: [err.message] }));
             }
         }
         // A1 (defect D23) + Task 6 — harness-owned continuation, now the full
@@ -3001,7 +3520,7 @@ export async function runRepl(opts) {
         if (planResume && planOutcome) {
             try {
                 const { runPostPhaseChain } = await import('./commands/plan-chain.js');
-                const { inkAwarePrompt } = await import('./agent/loop.js');
+                const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                 await runPostPhaseChain({
                     savedPath: planOutcome.savedPath,
                     executedPhaseId: planResume.nextPhaseId,
@@ -3018,12 +3537,13 @@ export async function runRepl(opts) {
                     // Fix-wave (item 1) — counter consumed in the runTurn finally.
                     subagentDispatches: planSubagentDispatches,
                     prompt: inkAwarePrompt,
+                    confirm: inkAwareConfirm,
                     queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                     log: (...lines) => lines.forEach((l) => console.log(l)),
                 });
             }
             catch (err) {
-                console.log(chalk.red(`\n[plan] post-phase chain failed: ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Plan follow-up steps failed', detail: [err.message] }));
             }
         }
         // C1 — continuation post-turn: fallback-persist (hook may not have
@@ -3062,13 +3582,13 @@ export async function runRepl(opts) {
                 }
             }
             catch (err) {
-                console.log(chalk.red(`\n[plan] continuation save failed: ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Plan continuation not saved', detail: [err.message] }));
             }
         }
         if (planContinue && planOutcome) {
             try {
                 const { runContinuationChain } = await import('./commands/plan-continue.js');
-                const { inkAwarePrompt } = await import('./agent/loop.js');
+                const { inkAwarePrompt, inkAwareConfirm } = await import('./agent/loop.js');
                 await runContinuationChain({
                     prepared: planContinue.prepared,
                     marker: planContinue.marker,
@@ -3077,12 +3597,13 @@ export async function runRepl(opts) {
                     cwd: process.cwd(),
                     subagentDispatches: planSubagentDispatches,
                     prompt: inkAwarePrompt,
+                    confirm: inkAwareConfirm,
                     queueDispatch: (cmd) => pendingDispatchAccessor.set(cmd),
                     log: (...lines) => lines.forEach((l) => console.log(l)),
                 });
             }
             catch (err) {
-                console.log(chalk.red(`\n[plan] continuation chain failed: ${err.message}\n`));
+                console.log('\n' + formatFailure({ what: 'Plan follow-up steps failed', detail: [err.message] }));
             }
         }
         // C1 — the phase reached a resolved terminal (revision persisted, chain
@@ -3118,10 +3639,13 @@ export async function runRepl(opts) {
                 cacheRead: turnStartCostSnapshot.cacheRead,
                 cacheCreate: turnStartCostSnapshot.cacheCreate,
                 startedAt: turnStart,
+                pausedMs: turnStartPausedMs,
             },
             // A4 — price the turn at the model that actually ran it (classic-path
             // mirror of the Ink call site above).
             turnModel: planModelOverride ?? session.model,
+            // Review M4 — a user cancel with no tokens prints no receipt here too.
+            cancelled: interruptedByUser,
         });
         // Post-turn roll-forward (Step 7c.2 / 7c.5) — the skill from the turn that
         // JUST finished becomes `last_skill` for the next turn's classifier context.