@cspeach/cli 0.9.0 → 1.1.0

package/dist/repl.js

@@ -6,11 +6,8 @@ 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 * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
 import { select, password as promptPassword } from '@inquirer/prompts';
-import { loadConfig } from './config/loader.js';
+import { loadConfig, resolveLocalBuild } from './config/loader.js';
 import { getStore } from './auth/api-key.js';
 import { readAuthFile } from './auth/auth-file.js';
 import { fetchMe } from './auth/me.js';
@@ -18,26 +15,44 @@ import { formatLoginBanner } from './ui/login-banner.js';
 import { printStartupBanner, printKeytarFallbackBanner } from './renderer/banners.js';
 import { runAddSapWizard } from './sap/onboarding.js';
 import { getConnection } from './sap/connection-manager.js';
-import { AdtClient } from '@cspeach/sap-client';
+import { AdtClient, snapshots } from '@cspeach/sap-client';
 import { makeSessionId, saveSession } from './session/store.js';
 import { newSession } from './session/schema.js';
+import { resolveModelRole } from './models/resolve.js';
+import { loadServerModelConfig } from './models/server-config.js';
 import { computeCost, formatCost } from './cost/pricing.js';
 import { createProviderForMode } from './agent/providers/factory.js';
+import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
 import { renderTurnError } from './agent/turn-error-ux.js';
-import { classifyPrompt, parseShortcut } from './router/classifier.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 { enqueueSteering } from './agent/steering-queue.js';
+import { classifyPrompt, parseShortcut, rejectUnknownSkill } from './router/classifier.js';
 import { decideRouting } from './router/routing-decision.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';
+import { todoEmitter } from './ui/todo-emitter.js';
 import { PICK_CANCELLED } from './ui/skill-picker.js';
+// Task 3 (ux-wave3) — rewind. rewindEmitter + approvalEmitter are pure
+// EventEmitters; rewind/* and approvals/render are ink-free, so these are safe
+// static imports in the classic path too (only the Ink render block below
+// actually mounts a panel).
+import { rewindEmitter } from './ui/rewind-emitter.js';
+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 { maybePromptWorkspaceMigration } from './projects/migration.js';
+import { maybePromptWorkspaceMigration, maybeOfferAbapforgeMigration } from './projects/migration.js';
+import { findProjectRoot } from './projects/workspace.js';
 import { slashCompleter } from './repl/slash-completer.js';
 import { openSlashPicker, isExactSlashMatch } from './repl/slash-picker.js';
 import { openAtPicker, pendingAtTokenPrefix } from './repl/at-picker.js';
 import { atCompleter } from './repl/at-completer.js';
-import { isPlanResumeCommand } from './commands/plan-resume.js';
+import { appendHistoryEntry, readHistoryEntries } from './repl/history.js';
 /**
  * Pre-fill the readline buffer with `text`, cursor at end, and trigger
  * a redraw. Bypasses rl.write() — which simulates per-character
@@ -59,16 +74,23 @@ function prefillReadline(rl, text) {
     internal._refreshLine?.();
 }
 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 { createClassicOutputEmitter } from './renderer/notices.js';
 import { saveConfig } from './config/loader.js';
 import { EventEmitter } from 'node:events';
 import { parseAndValidateReroute } from './commands/reroute.js';
 import { SKILL_CATALOG } from './skill-catalog.js';
 import { replPreviewHook } 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 { looksLikeCspeachShellCommand, CSPEACH_SHELL_NUDGE } from './repl/cspeach-shell-detect.js';
+import { applyLocalBuildConfig } from './tools/local-build.js';
 // Side-effect imports so tool registrations happen before listTools() is called.
 import './tools/sap-read.js';
 import './tools/sap-write.js';
@@ -77,54 +99,44 @@ import './tools/approval.js';
 import './tools/snapshot.js';
 import './tools/ask-question.js';
 import './tools/dispatch-skill.js';
+import './tools/todo.js';
 import './tools/filesystem/file-read.js';
+import './tools/filesystem/read-document.js';
 import './tools/filesystem/file-edit.js';
 import './tools/filesystem/file-write.js';
 import './tools/filesystem/glob.js';
 import './tools/filesystem/grep.js';
 import './tools/shell/shell_exec.js';
+import './tools/fiori/tools.js';
+import './tools/extend-model/tool.js';
+import './tools/capability/tool.js';
 import './tools/web/web_fetch.js';
 import './tools/web/web_search.js';
 import './tools/project/project_context_get.js';
 import './tools/project/playbook_get.js';
 import './tools/project/convention_get.js';
+import './tools/project/cca_merge.js';
+import './tools/project/upgrade_merge_progress.js';
 import './tools/subagent/_background-shared.js';
 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';
-const HISTORY_FILE = path.join(os.homedir(), '.cspeach', 'history');
 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).
 function loadHistory() {
-    try {
-        const raw = fs.readFileSync(HISTORY_FILE, 'utf-8');
-        return raw
-            .split('\n')
-            .map((l) => l.trim())
-            .filter((l) => l.length > 0)
-            .slice(-HISTORY_SIZE)
-            // readline expects history[0] to be the MOST RECENT entry (arrow-up
-            // walks from index 0 backwards in time). The on-disk file is
-            // chronologically appended — oldest at top, newest at bottom — so
-            // after slicing the last N lines we need to reverse them. Without
-            // this, arrow-up showed the user the oldest 500 entries first; new
-            // ones (correctly persisted to disk) sat at the far end of the buffer
-            // and were unreachable.
-            .reverse();
-    }
-    catch {
-        return [];
-    }
-}
-function appendHistory(line) {
-    try {
-        fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
-        fs.appendFileSync(HISTORY_FILE, line + '\n', 'utf-8');
-    }
-    catch {
-        // Non-fatal — history persistence failure must never crash the REPL.
-    }
+    return (readHistoryEntries()
+        .slice(-HISTORY_SIZE)
+        // readline expects history[0] to be the MOST RECENT entry (arrow-up
+        // walks from index 0 backwards in time). The on-disk file is
+        // chronologically appended — oldest at top, newest at bottom — so
+        // after slicing the last N lines we need to reverse them. Without
+        // this, arrow-up showed the user the oldest 500 entries first; new
+        // ones (correctly persisted to disk) sat at the far end of the buffer
+        // and were unreachable.
+        .reverse());
 }
 /** Short user inputs that almost always mean "continue what we were doing"
  *  rather than "start a new task." When the previous turn left a skill
@@ -253,7 +265,7 @@ function isBareAck(trimmed) {
  *   instead of having to arrow to the right item.
  */
 const PICKER_FALLBACK_SKILLS = [
-    'abap-explain', 'abap-review', 'abap-document', 'abap-rap', 'abap-radar',
+    'abap-explain', 'abap-review', 'abap-handover', 'abap-rap', 'abap-impact',
 ];
 const MIN_PICKER_OPTIONS = 3;
 function buildCoachingParams(result, prompt, preSelect, lastSkill) {
@@ -366,16 +378,42 @@ export async function runRepl(opts) {
         await runAddSapWizard();
         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);
     // Task C.10 — surface the current write_mode prominently. advisory-only gets
     // a bold yellow banner (no-writes is a surprising-enough state that the user
     // should not miss it). Other modes get a quiet one-liner so the state is
     // always visible without competing with the peach banner above.
-    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'));
+    //
+    // Task 3 (ux-wave1) — the banner must announce the EFFECTIVE mode (config
+    // clamped to the alias role's ceiling), but the role isn't known until the
+    // alias is picked below. With no role configured anywhere the clamp is the
+    // 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);
+    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'));
+        }
+        else {
+            console.log(chalk.gray(`Write mode: ${cfg.write_mode}\n`));
+        }
     }
-    else {
-        console.log(chalk.gray(`Write mode: ${cfg.write_mode}\n`));
+    // local_build toggle — when persisted-on, force-enable the flag-gated
+    // filesystem tools AND shell_exec BEFORE the first listTools()/turn (listTools
+    // reads flag state live per turn). Resolve with backward compat: a stale
+    // legacy `local_files = on` still applies via resolveLocalBuild. Announce
+    // 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).
+    {
+        const announce = applyLocalBuildConfig(resolveLocalBuild(cfg), process.cwd());
+        if (announce)
+            console.log(chalk.dim(announce + '\n'));
     }
     const aliases = Object.keys(cfg.sap);
     // C.1 — --sap-alias flag override skips the interactive picker
@@ -398,24 +436,70 @@ export async function runRepl(opts) {
                     choices: aliases.map((a) => ({ value: a, name: a })),
                 });
     }
+    // Task 3 (ux-wave1) — deferred write-mode banner: now that the alias is
+    // known, announce the EFFECTIVE mode and flag when the role clamped it.
+    // Only reached when a role is configured (no-role path printed above,
+    // byte-identical to pre-role behavior).
+    const aliasRole = cfg.sap[selectedAlias]?.role;
+    const startupWriteMode = getEffectiveWriteMode(cfg.write_mode, aliasRole);
+    if (anyRoleConfigured) {
+        const capped = startupWriteMode !== cfg.write_mode
+            ? ` (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('');
+            }
+        }
+        else {
+            console.log(chalk.gray(`Write mode: ${startupWriteMode}${capped}\n`));
+        }
+    }
     const conn = await getConnection(selectedAlias, cfg.sap[selectedAlias]);
     const adt = new AdtClient(conn);
     // 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
     // had .update() methods but no callers.
+    // Task 3 (ux-wave1) — seed writeMode with the startup-EFFECTIVE mode so
+    // the Task 4 statusline chip is correct before any cycle happens.
+    // Task 4 review fix (2026-07-04) — seed the BARE alias, not
+    // `alias (host)`: an FQDN host pushed the statusline past 100 cols and
+    // wrapped it. store.system has exactly two readers — StatusLine and the
+    // superseded (unmounted) header.tsx — so nothing else loses the host;
+    // the connection banner above already printed it once to scrollback.
     sapStateStore.update({
-        system: `${selectedAlias} (${cfg.sap[selectedAlias].host})`,
+        system: selectedAlias,
         user: cfg.sap[selectedAlias].username,
+        writeMode: startupWriteMode,
     });
     // 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.
-    const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, cfg.default_model);
+    const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg));
     if (!opts?.resumedSession) {
         await saveSession(session);
     }
+    // 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.
+    try {
+        await assertModeLicensed(cfg.llm.mode, async () => (await store.get()) ?? '');
+    }
+    catch (e) {
+        if (e instanceof CspeachLicenseError) {
+            console.error(chalk.yellow(`\n${e.message}\n`));
+            process.exit(1);
+        }
+        throw e;
+    }
     const provider = createProviderForMode(cfg, async () => {
         const key = await store.get();
         if (!key)
@@ -430,6 +514,21 @@ export async function runRepl(opts) {
             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));
+            }
+        }
+        catch { /* recap is best-effort — never block resume */ }
         console.log(chalk.gray(`Type /exit to quit.\n`));
     }
     else {
@@ -474,10 +573,13 @@ export async function runRepl(opts) {
         // Things this delete-line cleanup removes (vs the alt-screen path):
         //   - enterAltScreen / leaveAltScreen calls
         //   - hideCursor interval workaround
-        //   - bracketed-paste enable (now handled the classic-mode way below)
         //   - PgUp/PgDn/Ctrl+B scroll state in App + Body
         //   - termHeight + SIGWINCH resize tracking
         //   - exitOnCtrlC: false render option (default behaviour is fine)
+        //
+        // Bracketed paste: NOT removed anymore. Wave1 live-fix (Bug 2)
+        // enables DEC 2004 for the Ink path too and routes stdin through
+        // InkStdinPasteGuard — see the render() wiring below.
         // Hide the terminal's native cursor while Ink owns the frame. Ink's
         // dynamic frame ends with a newline, parking the real cursor on the
         // line BELOW the Footer ("booger cursor"). ink-text-input's
@@ -509,11 +611,19 @@ export async function runRepl(opts) {
         // it. When null, we're at idle and should exit on Ctrl+C.
         let currentTurnAbort = null;
         let interruptCount = 0;
-        const handleSubmit = async (line) => {
+        // 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
+        // WRAPPER so they are guarded and reserved too.
+        const dispatchSubmit = async (line) => {
             const trimmed = line.trim();
             if (!trimmed)
                 return;
-            appendHistory(trimmed);
+            // 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
+            // double append.
+            appendHistoryEntry(trimmed);
             // Phase A** (2026-05-16) — echo the user's prompt into Body so it
             // appears in the conversation history. Plus a dim divider above
             // the echo so consecutive turns have a clear visual break (closes
@@ -549,16 +659,79 @@ export async function runRepl(opts) {
                 await runCostCommand(session.id);
                 return;
             }
+            // Task 4 (ux-wave3) — /export audit [filename]: write the signable
+            // session audit record (who did what, where, under which approval, at
+            // what cost) to a markdown file in cwd and print the path.
+            if (trimmed === '/export' || trimmed.startsWith('/export ')) {
+                const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
+                const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+                if (sub !== 'audit') {
+                    chunkEmitter.emit('chunk', chalk.dim('\nUsage: /export audit [filename]\n'));
+                    return;
+                }
+                await runExportAuditCommand({
+                    session,
+                    transport: getCurrentTransport(),
+                    filename,
+                    emit: (l) => chunkEmitter.emit('chunk', l + '\n'),
+                });
+                return;
+            }
+            // Task 5 (ux-wave3) — /context: the composition grid. What fills the
+            // model window right now (summary block · recent turns · tool results ·
+            // todos · system+skill+tools), one proportional bar each. Read-only.
+            if (trimmed === '/context' || trimmed.startsWith('/context ')) {
+                // M4 — args are not a thing; one usage line instead of the classifier
+                // fallthrough treating '/context foo' as an unknown-skill prompt.
+                if (trimmed !== '/context') {
+                    chunkEmitter.emit('chunk', chalk.dim('/context takes no arguments — it shows what fills the model window right now\n'));
+                    return;
+                }
+                const { runContextCommand } = await import('./ui/context-grid.js');
+                await runContextCommand({
+                    session,
+                    color: true,
+                    emit: (l) => chunkEmitter.emit('chunk', l + '\n'),
+                });
+                return;
+            }
+            // Task 3 (ux-wave1) — /mode: view-by-cycling / jump the SESSION write
+            // mode (config untouched). Bare cycles; advisory|gated|auto jumps
+            // (still clamped to the alias role's ceiling). Same core as Shift+Tab.
+            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');
+                sapStateStore.update({ writeMode: mode });
+                return;
+            }
+            // Task 6 (ux-wave2) — /recap: reprint the orientation recap (session ·
+            // todos · plan) for the CURRENT session. Same builder as the
+            // resume-time banner; empty recap → one dim placeholder line.
+            if (trimmed === '/recap') {
+                const { buildRecap } = await import('./session/recap.js');
+                const { resolveWorkspacePath } = await import('./projects/workspace.js');
+                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');
+                chunkEmitter.emit('chunk', '\n' + body + '\n');
+                return;
+            }
             // Phase 2 conversation hygiene (2026-05-16) — /compact summarises
             // older turns via Haiku so subsequent turns ingest ~5k tokens of
             // context instead of 500k+. Saves \$3-8 per follow-up turn.
             if (trimmed === '/compact') {
-                const { runCompact, formatCompactResult, buildSummarisationPrompt, serialiseForSummariser, COMPACTION_MODEL } = await import('./commands/compact.js');
+                const { runCompact, formatCompactResult, buildSummarisationPrompt, serialiseForSummariser } = await import('./commands/compact.js');
                 const { summariseViaProvider } = await import('./agent/summarise-via-provider.js');
                 const { loadConfig } = await import('./config/loader.js');
                 const compactCfg = (await loadConfig()).compact;
                 const summarise = async (toSummarise) => {
-                    return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), { model: COMPACTION_MODEL, maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                    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' } });
                 };
                 try {
                     chunkEmitter.emit('chunk', chalk.dim('\nCompacting older turns into a summary...\n'));
@@ -641,19 +814,18 @@ export async function runRepl(opts) {
                 chunkEmitter.emit('chunk', chalk.dim(`\n↪ Rerouting "${preview}" → /${rr.skill}\n`));
                 if (rr.warning)
                     chunkEmitter.emit('chunk', chalk.dim(`  (${rr.warning})\n`));
-                const { turnStatusEmitter: rerouteStatus } = await import('./ui/turn-status-emitter.js');
-                rerouteStatus.start(`/${rr.skill}`);
+                turnStatusEmitter.start(`/${rr.skill}`);
                 try {
                     await runTurn({
                         provider,
                         userMessage: rr.prompt,
                         skill: rr.skill,
-                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                        ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                         chunkEmitter,
                     });
                 }
                 finally {
-                    rerouteStatus.stop();
+                    turnStatusEmitter.stop();
                 }
                 return;
             }
@@ -672,7 +844,54 @@ export async function runRepl(opts) {
                 chunkEmitter.emit('chunk', chalk.cyan(`\n${msg}\n`));
                 return;
             }
-            const parsed = parseShortcut(trimmed);
+            // Task 3 (ux-wave3) — /rewind: open the Ink rewind panel. <App> is a
+            // separate React tree, so signal it through rewindEmitter (Esc-Esc opens
+            // the same panel from inside App). Deps + candidates are wired at the App
+            // render call below; the panel handles the empty-list case itself.
+            if (trimmed === '/rewind' || trimmed.startsWith('/rewind ')) {
+                // M5 — args are not a thing; one usage line instead of the classifier
+                // fallthrough treating '/rewind foo' as an unknown-skill prompt.
+                if (trimmed !== '/rewind') {
+                    chunkEmitter.emit('chunk', chalk.dim('/rewind takes no arguments — it opens the session rewind list (Esc Esc does too)\n'));
+                    return;
+                }
+                rewindEmitter.emit('open');
+                return;
+            }
+            // /safety-mode on|off — structured Forge Rule confirmation cards.
+            // UX-5 #1 (2026-06-12): handleSafetyModeCommand existed (unit-tested)
+            // but no REPL path ever routed to it — the toggle was unreachable at
+            // runtime. Mirrors the /transport dispatch shape above.
+            {
+                const msg = matchSafetyModeCommand(trimmed);
+                if (msg !== null) {
+                    chunkEmitter.emit('chunk', chalk.cyan(`\n${msg}\n`));
+                    return;
+                }
+            }
+            // UX-5 #2 (2026-06-12) — numbered-menu expansion. When the model
+            // ended the previous turn with a plain-text numbered menu and the
+            // user types a bare `2`, expand the input to that item's text (with
+            // a dim echo) so the turn carries real intent instead of a lone
+            // digit. Conservative: fires only on pure 1–2 digit input matching
+            // an item in a 2+-item list in the LAST assistant message.
+            let effectiveInput = trimmed;
+            {
+                const expansion = maybeExpandNumberSelection(trimmed, lastAssistantText(session.messages));
+                if (expansion) {
+                    chunkEmitter.emit('chunk', chalk.dim(`${expansion.echo}\n`));
+                    effectiveInput = expansion.text;
+                }
+            }
+            const parsed = parseShortcut(effectiveInput);
+            // D35 (2026-06-11) — explicit slash naming a skill that isn't in the
+            // catalog: print the notice ("did you mean" / builtin-with-args) and
+            // end the turn. Slash input must NEVER fall through to the classifier
+            // (classifyPrompt asserts on it) and must never dispatch to a
+            // nonexistent skill. Shared gate: rejectUnknownSkill in classifier.ts.
+            if (rejectUnknownSkill(parsed, (m) => chunkEmitter.emit('chunk', chalk.yellow(`\n${m}\n`)))) {
+                return;
+            }
             // Record the prose body (post-shortcut stripping) for /reroute. Using
             // `parsed.prompt` rather than `trimmed` means:
             //   - plain prose: `parsed.prompt === trimmed`, stored as-is
@@ -806,12 +1025,33 @@ export async function runRepl(opts) {
             // persists the version-N+1 REVISION after the turn.
             let planResume = null;
             let planResumeMsgStart = 0;
+            // D-B — the wall-clock start of THIS phase attempt's turn, threaded to
+            // the post-phase audit as the evidence-window cutoff (so an audit never
+            // sees an earlier attempt's tool-call rows in the shared session JSONL).
+            let planPhaseStartedAt = '';
+            // A4 — set only when plan model tiering picks Sonnet for this phase.
+            let planModelOverride;
+            // Task 6 — true while the guarded auto_approve override is active for
+            // this turn; cleared in the runTurn finally (fail-safe: never sticky).
+            let guardedRunFlagSet = false;
+            // Task 7 — true while the plan-phase subagent read-only enforcement is
+            // active for this turn; same lifecycle, cleared in the same finally.
+            let planPhaseFlagSet = false;
             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');
                     planResume = await preparePlanResume({
                         body: prompt,
                         cwd: process.cwd(),
+                        configMode: cfg.plan_mode,
+                        // Audit off-switch (2026-07-06, owner) — config default; per-run
+                        // --audit/--no-audit flags in the body override it (parsed inside).
+                        configAudit: cfg.plan_audit,
+                        // Task 9 — run-lease identity + takeover prompt (concurrent
+                        // resume guard; inkAwarePrompt answers '' in headless = decline).
+                        sessionId: session.id,
+                        prompt: inkAwarePrompt,
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                     });
                 }
@@ -823,13 +1063,138 @@ export async function runRepl(opts) {
                     session.last_object = extractedObject ?? previousObject ?? null;
                     return;
                 }
+                // Task 6 (agentic-flow) — re-audit-on-resume: the last executed phase
+                // has an unresolved audit (crash before the verdict write, auditor
+                // infra outage, or a guarded-mode hand-edit). NO model turn this
+                // dispatch — run the audit chain instead; it re-judges the phase,
+                // persists the verdict, and offers/queues the next phase itself.
+                if (planResume.reauditPhaseId) {
+                    try {
+                        const { runReauditPass } = await import('./commands/plan-chain.js');
+                        const { inkAwarePrompt } = await import('./agent/loop.js');
+                        await runReauditPass({
+                            savedPath: planResume.path,
+                            phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
+                            sessionId: session.id,
+                            cwd: process.cwd(),
+                            mode: planResume.effectiveMode ?? 'step',
+                            modeFlag: planResume.mode,
+                            // Off-switch (I3) — footer honesty on re-audit boards; (I2) the
+                            // per-run audit flag survives onto chain-built resume commands.
+                            auditMode: planResume.auditMode,
+                            auditFlag: planResume.auditFlag,
+                            prompt: inkAwarePrompt,
+                            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`));
+                    }
+                    session.last_skill = previousSkill ?? null;
+                    session.last_object = extractedObject ?? previousObject ?? null;
+                    // Same consume-the-slot mechanics as the post-turn dispatch below.
+                    const reauditDispatched = pendingDispatchAccessor.get();
+                    // Task 9 (review fix) — release ONLY when the re-audit leg queued
+                    // no follow-up. A queued dispatch continues the chain: the lease
+                    // is HELD across the gap (the re-entry's same-session re-acquire
+                    // is idempotent), or a second session could grab the family lock
+                    // mid-chain. A crash before this line leaves a lease that goes
+                    // stale with the pid.
+                    {
+                        const { releaseRunLeaseUnlessChained } = await import('./projects/run-lease.js');
+                        releaseRunLeaseUnlessChained(planResume.path, reauditDispatched);
+                    }
+                    if (reauditDispatched) {
+                        pendingDispatchAccessor.set(null);
+                        chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${reauditDispatched}\n`));
+                        setImmediate(() => { void handleSubmit(reauditDispatched); });
+                    }
+                    return;
+                }
+                // A1 (defect D23) — true bounded phases: EVERY plan-resume turn
+                // (harness-dispatched or manually typed) starts from reset session
+                // messages. The envelope + bounded prompt carry all needed state;
+                // prior transcript is pure context cost (a 6-phase run once
+                // snowballed to a 3.24M-token cache read per call).
+                {
+                    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'));
+                    }
+                }
                 planResumeMsgStart = session.messages.length;
+                planPhaseStartedAt = new Date().toISOString(); // D-B evidence-window cutoff
                 prompt = planResume.llmPrompt;
+                // C1 mid-phase-continue — record the phase now in flight. Cleared
+                // post-turn the moment a revision is persisted; if this turn is
+                // interrupted first, the marker lets a later bare "continue" re-attach
+                // the audit + next-phase chain (plan-continue.ts).
+                {
+                    const { buildPlanInFlight } = await import('./commands/plan-continue.js');
+                    session.plan_in_flight = buildPlanInFlight(planResume, planPhaseStartedAt);
+                }
+                // A4 (2026-06-11) — flag-gated per-phase model tiering: design/test/
+                // document-shaped phases (structural signal: the phase's delegateTo
+                // skill) run on Sonnet; everything else — and the flag-off default —
+                // stays on cfg.default_model. The dim notice keeps cost attribution
+                // auditable next to the cost-log line that records the same model.
+                {
+                    const { isPlanModelTieringEnabled, selectPlanPhaseModel } = await import('./commands/plan-model-tier.js');
+                    const choice = selectPlanPhaseModel({
+                        enabled: isPlanModelTieringEnabled(cfg),
+                        phaseId: planResume.nextPhaseId,
+                        delegateTo: planResume.nextDelegateTo,
+                        // model-governance step 2d — the session default now resolves
+                        // env > local > server > built-in (== cfg.default_model when nothing set).
+                        defaultModel: resolveModelRole('session_default', cfg),
+                    });
+                    if (choice.model) {
+                        planModelOverride = choice.model;
+                        chunkEmitter.emit('chunk', chalk.dim(`${choice.notice}\n`));
+                    }
+                }
+            }
+            // C1 mid-phase-continue — a router-dispatched abap-plan turn (bare
+            // "continue" after an interrupted phase) with an in-flight marker:
+            // re-attach this turn to the interrupted phase so the post-phase chain
+            // (audit + [y/N] offer) runs instead of the generic save hook. The
+            // --resume branch above and this one are mutually exclusive by the
+            // --resume regex (report §4, no-double-fire guarantee). The user's
+            // prompt is NOT replaced and the context is NOT reset — "continue"
+            // needs the accumulated transcript.
+            let planContinue = null;
+            if (skill === 'abap-plan' && planResume === null && session.plan_in_flight) {
+                const marker = session.plan_in_flight;
+                const { preparePlanContinuation } = await import('./commands/plan-continue.js');
+                const r = preparePlanContinuation({
+                    marker,
+                    sessionId: session.id,
+                    log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                });
+                if (r.prepared) {
+                    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`));
+                }
+                else if (r.stale) {
+                    session.plan_in_flight = null; // plan/phase gone for good — marker is noise
+                }
             }
+            const planContinueForHook = planContinue;
             // 2026-06-08 — manifest-on-interrupt. Set true once the mid-turn
             // onPlanManifest hook has persisted the revision, so the post-turn
             // finishPlanResume below doesn't write it a second time.
             let planSavedEarly = false;
+            // A1 — outcome of the persisted revision (exact saved path + the
+            // harness-built resume command). Drives the post-turn next-phase offer.
+            let planOutcome = null;
+            // Fix-wave (item 1) — the phase's subagent-dispatch count, read+reset
+            // in the runTurn finally below (the chain can be skipped on error
+            // paths, so the counter must be consumed HERE) and threaded to
+            // runPostPhaseChain for the phase-end report line.
+            let planSubagentDispatches;
             const planResumeForHook = planResume;
             // Phase A** wiring fix (2026-05-16) — snapshot pre-turn counters so
             // pushPostTurnStatus can compute per-turn deltas. The classic-mode
@@ -847,27 +1212,65 @@ export async function runRepl(opts) {
             // 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.
-            const { turnStatusEmitter } = await import('./ui/turn-status-emitter.js');
+            // (turnStatusEmitter is the module-level singleton import — BUG-2b.)
             turnStatusEmitter.start(`/${skill}`);
             try {
+                // Task 6 (review M-2) — guarded chain start: announce and disable
+                // auto_approve for this phase's turn (request_approval consults the
+                // flag and falls through to interactive prompts). Set INSIDE the try
+                // so nothing between set and runTurn can skip the finally-clear.
+                // C1 — a continuation turn re-attaches to the interrupted phase, so
+                // the SAME enforcement (read-only subagents, guarded gate, writes
+                // declaration, audit-off honesty line) is active for it too.
+                const planPhaseCtx = planResume ?? planContinue?.prepared;
+                if (planPhaseCtx) {
+                    const { setPlanPhaseActive, setGuardedRunActive, setCurrentPhaseWrites, getAndResetPlanDeviation } = await import('./commands/plan-gate.js');
+                    // Task 7 — plan-phase subagent read-only enforcement: set for EVERY
+                    // plan-resume phase turn regardless of mode (guarded AND step);
+                    // agent_run consults the flag and forces its read-only tool filter.
+                    setPlanPhaseActive(true);
+                    // Task 10 — the writes declaration of the phase EXECUTING this turn
+                    // (fail-safe: undefined ⇒ true, the deviation backstop never fires).
+                    // request_approval consults it in guarded mode to deny undeclared
+                    // writes. Discard any stale deviation flag from a chain leg that
+                    // never reached its post-phase chain so it can't block THIS phase.
+                    setCurrentPhaseWrites(planPhaseCtx.nextPhaseWrites ?? true);
+                    getAndResetPlanDeviation();
+                    planPhaseFlagSet = true;
+                    if ((planPhaseCtx.effectiveMode ?? 'step') === 'guarded') {
+                        setGuardedRunActive(true);
+                        guardedRunFlagSet = true;
+                        chunkEmitter.emit('chunk', chalk.dim('▶ guarded mode — auto_approve disabled for this run\n'));
+                    }
+                    // Off-switch (2026-07-06, owner) — announce plainly that this run's
+                    // phases are NOT audited (honesty: off is a choice, never a lie).
+                    if ((planPhaseCtx.auditMode ?? 'on') === 'off') {
+                        chunkEmitter.emit('chunk', chalk.dim('plan audits: off\n'));
+                    }
+                }
                 await runTurn({
                     provider,
                     userMessage: prompt,
                     skill: skill,
-                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                    ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
                     signal: currentTurnAbort.signal,
-                    suppressSaveHook: planResume !== null,
+                    suppressSaveHook: planResume !== null || planContinue !== null,
+                    // A4 — undefined on every non-plan turn (and when tiering is off).
+                    modelOverride: planModelOverride,
                     // 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
                         ? async (assistantText) => {
                             try {
                                 const { finishPlanResume } = await import('./commands/plan-resume.js');
-                                await finishPlanResume({
+                                planOutcome = await finishPlanResume({
                                     prepared: planResumeForHook,
                                     messages: session.messages,
                                     messagesStart: planResumeMsgStart,
+                                    sessionId: session.id,
+                                    attemptStartedAt: planPhaseStartedAt || undefined, // D-B item 1
+                                    auditMode: planResumeForHook.auditMode, // off-switch — no pending injected when 'off'
                                     log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                                     textOverride: assistantText,
                                 });
@@ -877,7 +1280,34 @@ export async function runRepl(opts) {
                                 chunkEmitter.emit('chunk', chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
                             }
                         }
-                        : undefined,
+                        : planContinueForHook
+                            ? async (assistantText) => {
+                                // C1 — early-persist the continuation revision the moment the
+                                // manifest is finalised (same crash-safety as the --resume hook).
+                                try {
+                                    const { finishPlanContinuation } = await import('./commands/plan-continue.js');
+                                    const r = await finishPlanContinuation({
+                                        prepared: planContinueForHook.prepared,
+                                        marker: planContinueForHook.marker,
+                                        messages: session.messages,
+                                        messagesStart: planResumeMsgStart,
+                                        sessionId: session.id,
+                                        textOverride: assistantText,
+                                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                                    });
+                                    if (r.kind === 'saved') {
+                                        planOutcome = r.outcome;
+                                        planSavedEarly = true;
+                                    }
+                                    // 'foreign'/'none'/'not-persisted': leave both flags unset —
+                                    // the post-turn fallback re-classifies the full turn text and
+                                    // owns the foreign save / quiet-none handling.
+                                }
+                                catch (err) {
+                                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] early continuation save failed: ${err.message}\n`));
+                                }
+                            }
+                            : undefined,
                 });
             }
             catch (err) {
@@ -891,6 +1321,25 @@ export async function runRepl(opts) {
             finally {
                 turnStatusEmitter.stop();
                 currentTurnAbort = 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
+                // finally on purpose — runPostPhaseChain below reads+resets it.)
+                if (guardedRunFlagSet || planPhaseFlagSet) {
+                    const { setGuardedRunActive, setPlanPhaseActive, setCurrentPhaseWrites, getAndResetPlanPhaseSubagentDispatches } = await import('./commands/plan-gate.js');
+                    if (guardedRunFlagSet)
+                        setGuardedRunActive(false);
+                    if (planPhaseFlagSet) {
+                        setPlanPhaseActive(false);
+                        setCurrentPhaseWrites(null);
+                        // Fix-wave (item 1) — consume the subagent counter in the SAME
+                        // finally: the post-phase chain may never run (turn throw / no
+                        // manifest ⇒ null planOutcome), and an unconsumed count would
+                        // leak into the NEXT phase's report line. The captured value is
+                        // threaded to runPostPhaseChain below.
+                        planSubagentDispatches = getAndResetPlanPhaseSubagentDispatches();
+                    }
+                }
             }
             // B3 — persist the plan revision from the resume turn's manifest
             // block (runs even after a turn error: partial assistant content is
@@ -903,10 +1352,13 @@ export async function runRepl(opts) {
             if (planResume && !planSavedEarly) {
                 try {
                     const { finishPlanResume } = await import('./commands/plan-resume.js');
-                    await finishPlanResume({
+                    planOutcome = await finishPlanResume({
                         prepared: planResume,
                         messages: session.messages,
                         messagesStart: planResumeMsgStart,
+                        sessionId: session.id,
+                        attemptStartedAt: planPhaseStartedAt || undefined, // D-B item 1
+                        auditMode: planResume.auditMode, // off-switch — no pending injected when 'off'
                         log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
                     });
                 }
@@ -914,35 +1366,187 @@ export async function runRepl(opts) {
                     chunkEmitter.emit('chunk', chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
                 }
             }
-            pushPostTurnStatus({ session, selectedAlias, snapshot: turnSnapshot, chunkEmitter });
+            // A1 (defect D23) + Task 6 — harness-owned continuation, now the full
+            // post-phase chain: audit the just-persisted phase against tool-call
+            // evidence, persist the verdict, handle failures (re-run/waive/block),
+            // gate the transition (step/guarded), then offer or auto-queue the
+            // exact `/abap-plan --resume @<saved-file>` the harness built — the
+            // model never authors this command. The pendingDispatch consumer below
+            // re-enters it, and the resume turn itself resets session messages.
+            if (planResume && planOutcome) {
+                try {
+                    const { runPostPhaseChain } = await import('./commands/plan-chain.js');
+                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    await runPostPhaseChain({
+                        savedPath: planOutcome.savedPath,
+                        executedPhaseId: planResume.nextPhaseId,
+                        sessionId: session.id,
+                        cwd: process.cwd(),
+                        mode: planResume.effectiveMode ?? 'step',
+                        modeFlag: planResume.mode,
+                        // Off-switch — skips the normal post-phase audit when 'off'; the
+                        // per-run flag survives onto chain-built resume commands (I2).
+                        auditMode: planResume.auditMode,
+                        auditFlag: planResume.auditFlag,
+                        // D-B — this attempt's turn-start, so the audit windows the evidence.
+                        attemptStartedAt: planPhaseStartedAt || undefined,
+                        // Fix-wave (item 1) — counter already consumed in the runTurn
+                        // finally; thread the captured value for the report line.
+                        subagentDispatches: planSubagentDispatches,
+                        prompt: inkAwarePrompt,
+                        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`));
+                }
+            }
+            // C1 — continuation post-turn: fallback-persist (hook may not have
+            // fired), then re-attach the chain. Mirrors the --resume blocks above.
+            if (planContinue && !planSavedEarly) {
+                try {
+                    const { finishPlanContinuation } = await import('./commands/plan-continue.js');
+                    const r = await finishPlanContinuation({
+                        prepared: planContinue.prepared,
+                        marker: planContinue.marker,
+                        messages: session.messages,
+                        messagesStart: planResumeMsgStart,
+                        sessionId: session.id,
+                        log: (...lines) => chunkEmitter.emit('chunk', lines.join('\n') + '\n'),
+                    });
+                    if (r.kind === 'saved') {
+                        planOutcome = r.outcome;
+                    }
+                    else if (r.kind === 'foreign') {
+                        // The turn produced a DIFFERENT plan's manifest and the save hook
+                        // was suppressed — run the generic save now so it isn't lost. The
+                        // in-flight marker stays: that phase is still unresolved.
+                        const { maybeOfferSave } = await import('./agent/loop.js');
+                        const { collectTurnAssistantText } = await import('./agent/turn-assistant-text.js');
+                        await maybeOfferSave({
+                            skill: 'abap-plan',
+                            assistantText: collectTurnAssistantText(session.messages, planResumeMsgStart),
+                            userMessage: prompt,
+                            tokensUsed: 0,
+                            model: session.model,
+                            emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                        });
+                    }
+                    else if (r.kind === 'none') {
+                        chunkEmitter.emit('chunk', chalk.dim(`phase ${planContinue.marker.phaseId} still in flight — no completion manifest this turn\n`));
+                    }
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n[plan] continuation save failed: ${err.message}\n`));
+                }
+            }
+            if (planContinue && planOutcome) {
+                try {
+                    const { runContinuationChain } = await import('./commands/plan-continue.js');
+                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    await runContinuationChain({
+                        prepared: planContinue.prepared,
+                        marker: planContinue.marker,
+                        outcome: planOutcome,
+                        sessionId: session.id,
+                        cwd: process.cwd(),
+                        subagentDispatches: planSubagentDispatches,
+                        prompt: inkAwarePrompt,
+                        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`));
+                }
+            }
+            // C1 — the phase reached a resolved terminal (revision persisted, chain
+            // ran or is queued): the marker's job is done. Applies to --resume AND
+            // continuation dispatches; a null outcome keeps the marker (still in flight).
+            if (planOutcome)
+                session.plan_in_flight = null;
+            // Task 9 — the chain leg for this dispatch truly ends here (verdict
+            // writes + failure prompts above still ran under the lease; every
+            // block between runTurn's finally and this point is exception-wrapped,
+            // so this line is reached on success AND on turn error). Release it —
+            // UNLESS a next-phase dispatch is queued (review fix): the auto-chain
+            // must hold the family lock across the gap to the re-entry (which
+            // re-acquires same-session idempotently), or a second session could
+            // grab it mid-chain. Chosen over releasing in the runTurn finally,
+            // which would leave finishPlanResume/runPostPhaseChain envelope writes
+            // unleased. A hard crash skips this — the leftover lease goes stale by
+            // pid-liveness, so no manual cleanup is ever needed.
+            if (planResume || planContinue) {
+                const { releaseRunLeaseUnlessChained } = await import('./projects/run-lease.js');
+                releaseRunLeaseUnlessChained((planResume ?? planContinue.prepared).path, pendingDispatchAccessor.get());
+            }
+            // A4 — turn-cost line must price at the model that actually ran the
+            // turn (planModelOverride on tiered plan phases), not session.model.
+            pushPostTurnStatus({
+                session,
+                selectedAlias,
+                snapshot: turnSnapshot,
+                chunkEmitter,
+                turnModel: planModelOverride ?? session.model,
+            });
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
             // 2026-05-08: post-turn auto-dispatch. The dispatch_skill tool may
             // have queued a slash command (typically after the user picked
-            // "Switch to /abap-X" via ask_question). Consume the slot and
-            // re-enter handleSubmit with that command — no user keypress.
-            // The user's consent was the picker pick.
+            // "Switch to /abap-X" via ask_question), or — A1 — the harness
+            // next-phase offer above queued the plan-resume it built itself.
+            // Consume the slot and re-enter handleSubmit with that command —
+            // no user keypress. The user's consent was the picker pick / y answer.
             const dispatched = pendingDispatchAccessor.get();
             if (dispatched) {
                 pendingDispatchAccessor.set(null);
-                // Auto-fire next phase: a plan resume rebuilds its bounded prompt from
-                // the envelope, so clear the finished phase's transcript first — the
-                // next phase then costs exactly what a manual fresh resume costs.
-                // (The phase is already saved via manifest-on-interrupt, so nothing is
-                // lost; prior prose is mirrored to ~/.cspeach/streams/.)
-                if (isPlanResumeCommand(dispatched)) {
-                    session.messages = [];
-                    chunkEmitter.emit('chunk', chalk.dim('↪ Auto-running next phase in fresh context\n'));
-                }
-                else {
-                    chunkEmitter.emit('chunk', chalk.dim(`↪ Auto-routed: ${dispatched}\n`));
-                }
+                // No context clear here: resetContextForPlanResume (called in the
+                // plan-resume prepare branch of handleSubmit) is the single owner of
+                // 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); });
             }
         };
+        // BUG-2b (2026-07-05 live smoke) — single-flight dispatch guard.
+        //
+        // dispatchSubmit does a large chunk of async pre-turn work (classifier
+        // round-trip, plan-resume prepare, the guarded-mode inquirer gate) BEFORE
+        // it calls turnStatusEmitter.start(). During that window .active was
+        // false, so the Footer's submit guard (App.beginSubmit, which now reads
+        // isBusy()) let a second Enter — a history recall, a live palette pick —
+        // dispatch a SECOND concurrent turn: the twin "Routed to /abap-plan",
+        // twin tracker board, and interleaved tool ⏺/⎿ lines the user saw.
+        //
+        // reserve() marks the dispatch busy synchronously, BEFORE any await, so
+        // isBusy() covers the whole prep window; release() in the finally ends it
+        // (after the post-phase chain + auto-dispatch scheduling). The isBusy()
+        // 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.
+        const handleSubmit = async (line) => {
+            if (turnStatusEmitter.isBusy()) {
+                const t = line.trim();
+                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`));
+                }
+                return;
+            }
+            turnStatusEmitter.reserve();
+            try {
+                await dispatchSubmit(line);
+            }
+            finally {
+                turnStatusEmitter.release();
+            }
+        };
         // 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
@@ -971,15 +1575,72 @@ export async function runRepl(opts) {
                     resolveDone();
             }
         };
+        // Wave1 live-fix (Bug 2) — bracketed paste for the Ink path. Windows
+        // Terminal delivers pasted newlines as `\r`, and a `\r`-only chunk
+        // parses as key.return (ink parse-keypress.js:145-148) → every pasted
+        // line submitted immediately (the live garbled-dispatch bug). With
+        // DEC 2004 on, pastes arrive marker-wrapped; the guard strips the
+        // markers BEFORE Ink's parser sees them (use-input.js:73-75 would
+        // mangle `\x1b[200~` into literal "[200~" text) and re-emits the
+        // whole paste as ONE newline-preserving chunk, which text-input's
+        // Task-7 paste branch buffers without submitting. Cleanup mirrors
+        // classic mode: explicit disable after unmount + a process-exit hook
+        // for the force-exit(130) and crash paths.
+        enableBracketedPaste();
+        process.on('exit', () => disableBracketedPaste());
+        const inkStdin = new InkStdinPasteGuard();
+        process.stdin.pipe(inkStdin);
+        // 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 —
+        // and catches any residual throw, review I2). The Ink approval bridge
+        // produces the exact ApprovalRequest shape render.ts emits onto
+        // approvalEmitter and awaits the resolve — <App> already consumes that
+        // emitter to mount <ApprovalModal>.
+        const inkRequestApproval = (change, risk, transport) => new Promise((resolve) => {
+            approvalEmitter.emit('request', { change, effectiveRisk: risk, transport, resolve });
+        });
+        const runInkRestore = (c) => 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 },
+            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.
+            log: (line) => chunkEmitter.emit('chunk', chalk.dim(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,
-            writeMode: cfg.write_mode,
+            // 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.
+            getTodos: () => session.todos ?? [],
+            // Task 3 (ux-wave3) — rewind panel accessors. Candidates join
+            // session.toolCalls with the on-disk snapshot list (async fs read),
+            // re-evaluated each open; onRewindRestore fires the gated executor.
+            getRewindCandidates: async () => collectRewindCandidates(session.toolCalls, await snapshots.list()),
+            onRewindRestore: (c) => { void runInkRestore(c); },
+            // Task 4 (ux-wave1) — no writeMode prop: App's mode-cycle handler
+            // reads its base from the SapStateStore, seeded with the startup-
+            // EFFECTIVE mode above (before this render — same function, no
+            // other Ink mount path exists). Clamp idempotency makes the
+            // effective mode a byte-compatible base for runModeCommand.
+            // Task 3 (ux-wave1) — Shift+Tab / Alt+M mode cycling needs the alias
+            // role (ceiling) + name (refusal line) inside App's useInput handler.
+            sapRole: cfg.sap[selectedAlias]?.role,
+            sapAlias: selectedAlias,
             onInterrupt,
         }), {
+            // Bug 2 (wave1 live-fix) — Ink reads from the paste guard, not
+            // process.stdin directly. The guard satisfies Ink's full stdin
+            // surface (isTTY / setEncoding / ref / unref / setRawMode /
+            // 'readable' + read()) — pinned by ink-stdin-guard.test.ts.
+            stdin: inkStdin,
             // exitOnCtrlC: false — Ink would otherwise call process.exit()
             // on Ctrl+C before onInterrupt can decide whether to abort the
             // in-flight turn or exit cleanly.
@@ -996,6 +1657,11 @@ export async function runRepl(opts) {
         });
         await donePromise;
         unmount();
+        // 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);
+        inkStdin.destroy();
+        disableBracketedPaste();
         // Restore the terminal cursor we hid on Ink mount.
         process.stdout.write('\x1b[?25h');
         // Print session summary + resume hint after Ink unmounts so the
@@ -1038,6 +1704,25 @@ export async function runRepl(opts) {
     // Disable bracketed paste on shutdown so the user's shell prompt after
     // CSPeach exits doesn't keep receiving wrapped pastes.
     process.on('exit', () => disableBracketedPaste());
+    // UX-5 #5 (2026-06-12) — piped-stdin support. Lines piped into the REPL
+    // (`"/cost`n/exit" | cspeach`) arrive BEFORE the loop's first rl.question
+    // is pending; readline emits them as 'line' EVENTS that nobody consumed,
+    // so every line was silently dropped and EOF hard-exited the process.
+    // The buffer queues those early lines (with a BOM strip on the first —
+    // PowerShell pipes inject one); the loop below drains the queue before
+    // calling rl.question, and EOF only ends the session after the queue is
+    // 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();
+    // 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
+    // undefined, so every Rule 9 transport notice was silently dropped.
+    // This emitter renders them straight to stdout. It is intentionally NOT
+    // passed as RunTurnParams.chunkEmitter — the loop's render functions
+    // 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),
@@ -1084,6 +1769,11 @@ export async function runRepl(opts) {
             return;
         if (turnInProgress)
             return; // turn handler owns the abort + UX
+        // UX-5 #5 — piped stdin: EOF must NOT hard-exit while queued lines are
+        // still unprocessed (or while a builtin like /cost is mid-flight). The
+        // loop drains the queue and owns shutdown via earlyLines.closed().
+        if (pipedStdin)
+            return;
         console.log('\nGoodbye.\n');
         process.exit(0);
     });
@@ -1255,6 +1945,23 @@ export async function runRepl(opts) {
         })),
         log: (line) => console.log(chalk.dim(line)),
     });
+    // 2026-06-15: one-time output-namespace migration. The customer-output
+    // root was renamed from the dead-brand `.abapforge/` to `.cspeach/`.
+    // Workspaces that still have a top-level `.abapforge/` get offered a
+    // one-time merge-move into `.cspeach/`. The dual-read resolver keeps old
+    // projects working if the user declines; "never" suppresses future offers.
+    await maybeOfferAbapforgeMigration(findProjectRoot(process.cwd()) ?? process.cwd(), {
+        prompt: async ({ legacyDir, newDir }) => withInquirer(() => select({
+            message: `Found legacy CSPeach outputs in ${legacyDir}. The output folder is now '.cspeach/'. Move them?`,
+            default: 'move',
+            choices: [
+                { value: 'move', name: `Move everything into ${newDir} (recommended)` },
+                { value: 'skip', name: `Not now — ask me again next time` },
+                { value: 'never', name: `Leave it and never ask again` },
+            ],
+        })),
+        log: (line) => console.log(chalk.dim(line)),
+    });
     while (true) {
         // Re-attach the bare-Esc detector every iteration. Inquirer prompts
         // (slash-picker, approval, ask_question, safety-confirm) remove
@@ -1270,15 +1977,27 @@ export async function runRepl(opts) {
         const dispatchedCmd = pendingDispatchAccessor.get();
         if (dispatchedCmd) {
             pendingDispatchAccessor.set(null);
-            if (isPlanResumeCommand(dispatchedCmd)) {
-                session.messages = [];
-                console.log(chalk.dim('↪ Auto-running next phase in fresh context'));
-            }
-            else {
-                console.log(chalk.dim(`↪ Auto-routed: ${dispatchedCmd}`));
-            }
+            // No context clear here: resetContextForPlanResume (called in the
+            // plan-resume prepare branch below) is the single owner of the
+            // 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}`));
             line = dispatchedCmd;
         }
+        else if (earlyLines.size() > 0) {
+            // UX-5 #5 — drain piped lines queued while no question was pending.
+            // Echo with the prompt string so transcripts/CI logs show what ran.
+            line = earlyLines.shift();
+            console.log(promptStr + line);
+        }
+        else if (earlyLines.closed()) {
+            // Piped stdin hit EOF and every queued line has been processed —
+            // end the session the same way /exit does.
+            printGoodbye(session);
+            rl.close();
+            return 0;
+        }
         else {
             const effectivePrompt = pendingPrefill ? promptStr + pendingPrefill : promptStr;
             try {
@@ -1296,6 +2015,11 @@ export async function runRepl(opts) {
                 // discriminates the two cases reliably.
                 const rlAny = rl;
                 if (rlAny.closed) {
+                    // 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.
+                    if (earlyLines.size() > 0)
+                        continue;
                     console.log('\nGoodbye.\n');
                     rl.close();
                     return 0;
@@ -1314,8 +2038,9 @@ export async function runRepl(opts) {
         const trimmed = line.trim();
         if (!trimmed)
             continue;
-        // Persist non-empty input to history file.
-        appendHistory(trimmed);
+        // Persist non-empty input to history file (Task 8: consecutive
+        // duplicates are skipped inside the shared writer).
+        appendHistoryEntry(trimmed);
         // 2026-05-01 fix: rl.question() does NOT auto-populate readline's internal
         // history (only the 'line' event does). Without this manual push, arrow-up
         // cycles only through the file-loaded seed from session start — commands
@@ -1375,16 +2100,80 @@ export async function runRepl(opts) {
             await runCostCommand(session.id);
             continue;
         }
+        // Task 4 (ux-wave3) — classic-mode /export audit [filename]. Mirrors the
+        // Ink handler: build the signable audit record, write it to cwd, print path.
+        if (trimmed === '/export' || trimmed.startsWith('/export ')) {
+            const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
+            const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+            if (sub !== 'audit') {
+                console.log(chalk.dim('Usage: /export audit [filename]'));
+                continue;
+            }
+            await runExportAuditCommand({
+                session,
+                transport: getCurrentTransport(),
+                filename,
+                emit: (l) => console.log(l),
+            });
+            continue;
+        }
+        // Task 5 (ux-wave3) — classic-mode /context. Mirrors the Ink handler:
+        // build + print the composition grid (same lines, minus color).
+        if (trimmed === '/context' || trimmed.startsWith('/context ')) {
+            // M4 — one usage line instead of the classifier fallthrough.
+            if (trimmed !== '/context') {
+                console.log(chalk.dim('/context takes no arguments — it shows what fills the model window right now'));
+                continue;
+            }
+            const { runContextCommand } = await import('./ui/context-grid.js');
+            await runContextCommand({
+                session,
+                color: false,
+                emit: (l) => console.log(l),
+            });
+            continue;
+        }
+        // Task 3 (ux-wave1) — classic-mode /mode. Mirrors the Ink handler:
+        // bare cycles the SESSION write mode, advisory|gated|auto jumps
+        // (clamped to the alias role's ceiling), config never touched.
+        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));
+            sapStateStore.update({ writeMode: mode });
+            continue;
+        }
+        // Task 6 (ux-wave2) — classic-mode /recap. Mirrors the Ink handler:
+        // reprint the orientation recap (session · todos · plan) for the
+        // CURRENT session; empty recap → one dim placeholder line.
+        if (trimmed === '/recap') {
+            const { buildRecap } = await import('./session/recap.js');
+            const { resolveWorkspacePath } = await import('./projects/workspace.js');
+            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));
+            }
+            continue;
+        }
         // Phase 2 conversation hygiene (2026-05-16) — classic-mode /compact.
         // Summarises older turns via Haiku 4.5 so subsequent turns ingest ~5k
         // tokens of context instead of 500k+. Backs up session pre-mutation.
         if (trimmed === '/compact') {
-            const { runCompact, formatCompactResult, buildSummarisationPrompt, serialiseForSummariser, COMPACTION_MODEL } = await import('./commands/compact.js');
+            const { runCompact, formatCompactResult, buildSummarisationPrompt, serialiseForSummariser } = await import('./commands/compact.js');
             const { summariseViaProvider } = await import('./agent/summarise-via-provider.js');
             const { loadConfig } = await import('./config/loader.js');
             const compactCfg = (await loadConfig()).compact;
             const summarise = async (toSummarise) => {
-                return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), { model: COMPACTION_MODEL, maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                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' } });
             };
             try {
                 console.log(chalk.dim('\nCompacting older turns into a summary...'));
@@ -1480,7 +2269,7 @@ export async function runRepl(opts) {
                 provider,
                 userMessage: rr.prompt,
                 skill: rr.skill,
-                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
             });
             continue;
         }
@@ -1498,6 +2287,35 @@ export async function runRepl(opts) {
             console.log(chalk.cyan(msg));
             continue;
         }
+        // Task 3 (ux-wave3) — classic-mode /rewind: numbered inquirer list + confirm
+        // + gated restore. Reuses the identical candidate collector and executor as
+        // the Ink panel (executeRestore); only the surface differs.
+        if (trimmed === '/rewind' || trimmed.startsWith('/rewind ')) {
+            // M5 — one usage line instead of the classifier fallthrough.
+            if (trimmed !== '/rewind') {
+                console.log(chalk.dim('/rewind takes no arguments — it opens the session rewind list'));
+                continue;
+            }
+            await runClassicRewind({
+                toolCalls: session.toolCalls,
+                adt,
+                cfg,
+                alias: selectedAlias,
+                toolCtx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                suppliedTransport: currentTransportAccessor.get() ?? undefined,
+                print: (line) => console.log(line),
+            });
+            continue;
+        }
+        // /safety-mode on|off — structured Forge Rule confirmation cards.
+        // UX-5 #1 (2026-06-12): classic-path mirror of the Ink dispatch above.
+        {
+            const msg = matchSafetyModeCommand(trimmed);
+            if (msg !== null) {
+                console.log(chalk.cyan(msg));
+                continue;
+            }
+        }
         // 2026-05-01: live slash-command picker. When the user types something
         // that LOOKS like a slash command but isn't an exact match — `/`,
         // `/abap-r`, `/fix`, etc. — open a search-as-you-type picker
@@ -1616,7 +2434,25 @@ export async function runRepl(opts) {
         }
         // Any non-empty submit clears the empty-prefill latch.
         lastEmptyPrefill = null;
+        // UX-5 #2 (2026-06-12) — numbered-menu expansion (classic mirror of the
+        // Ink block above). Bare `2` after a plain-text numbered menu expands
+        // to that item's text with a dim echo; everything else passes through.
+        {
+            const expansion = maybeExpandNumberSelection(resolvedTrimmed, lastAssistantText(session.messages));
+            if (expansion) {
+                console.log(chalk.dim(expansion.echo));
+                resolvedTrimmed = expansion.text;
+            }
+        }
         const parsed = parseShortcut(resolvedTrimmed);
+        // D35 (2026-06-11) — explicit slash naming a skill that isn't in the
+        // catalog: print the notice ("did you mean" / builtin-with-args) and
+        // end the turn. Slash input must NEVER fall through to the classifier
+        // (classifyPrompt asserts on it) and must never dispatch to a
+        // nonexistent skill. Shared gate: rejectUnknownSkill in classifier.ts.
+        if (rejectUnknownSkill(parsed, (m) => console.log(chalk.yellow(`\n${m}\n`)))) {
+            continue;
+        }
         // Record the prose body (post-shortcut stripping) for /reroute. Using
         // `parsed.prompt` rather than `trimmed` means:
         //   - plain prose: `parsed.prompt === trimmed`, stored as-is
@@ -1743,12 +2579,28 @@ export async function runRepl(opts) {
         // envelope revision after the turn.
         let planResume = null;
         let planResumeMsgStart = 0;
+        // D-B — see the Ink-path mirror above: this attempt's turn-start cutoff.
+        let planPhaseStartedAt = '';
+        // A4 — set only when plan model tiering picks Sonnet for this phase.
+        let planModelOverride;
+        // Task 6 — guarded auto_approve override lifetime (see Ink path).
+        let guardedRunFlagSet = false;
+        // Task 7 — plan-phase subagent read-only enforcement lifetime (see Ink path).
+        let planPhaseFlagSet = false;
         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');
                 planResume = await preparePlanResume({
                     body: prompt,
                     cwd: process.cwd(),
+                    configMode: cfg.plan_mode,
+                    // Audit off-switch (2026-07-06, owner) — config default; per-run
+                    // --audit/--no-audit flags in the body override it (parsed inside).
+                    configAudit: cfg.plan_audit,
+                    // Task 9 — run-lease identity + takeover prompt (classic mirror).
+                    sessionId: session.id,
+                    prompt: inkAwarePrompt,
                     log: (...lines) => lines.forEach((l) => console.log(l)),
                 });
             }
@@ -1760,12 +2612,110 @@ export async function runRepl(opts) {
                 session.last_object = extractedObject ?? previousObject ?? null;
                 continue;
             }
+            // Task 6 — re-audit-on-resume (classic mirror of the Ink branch; see
+            // there for the design note). No model turn: the chain re-judges the
+            // unresolved phase and queues any follow-up through pendingDispatch,
+            // which the loop-top consumer picks up on `continue`.
+            if (planResume.reauditPhaseId) {
+                try {
+                    const { runReauditPass } = await import('./commands/plan-chain.js');
+                    const { inkAwarePrompt } = await import('./agent/loop.js');
+                    await runReauditPass({
+                        savedPath: planResume.path,
+                        phaseIds: planResume.reauditPhaseIds ?? [planResume.reauditPhaseId],
+                        sessionId: session.id,
+                        cwd: process.cwd(),
+                        mode: planResume.effectiveMode ?? 'step',
+                        modeFlag: planResume.mode,
+                        // Off-switch (I3/I2) — classic mirror; see the Ink re-audit site.
+                        auditMode: planResume.auditMode,
+                        auditFlag: planResume.auditFlag,
+                        prompt: inkAwarePrompt,
+                        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`));
+                }
+                // Task 9 (review fix) — release ONLY when the re-audit leg queued no
+                // follow-up (classic mirror; the loop-top pre-prompt consumer picks
+                // up a queued dispatch on `continue`, so the slot still holds it
+                // here). See the Ink branch for the hold-across-chain design note.
+                {
+                    const { releaseRunLeaseUnlessChained } = await import('./projects/run-lease.js');
+                    releaseRunLeaseUnlessChained(planResume.path, pendingDispatchAccessor.get());
+                }
+                session.last_skill = previousSkill ?? null;
+                session.last_object = extractedObject ?? previousObject ?? null;
+                continue;
+            }
+            // A1 (defect D23) — see the Ink path: every plan-resume turn starts
+            // from reset session messages (true bounded phases).
+            {
+                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'));
+                }
+            }
             planResumeMsgStart = session.messages.length;
+            planPhaseStartedAt = new Date().toISOString(); // D-B evidence-window cutoff
             prompt = planResume.llmPrompt;
+            // C1 mid-phase-continue — record the phase now in flight (classic
+            // mirror of the Ink marker-set; see there for the full design note).
+            {
+                const { buildPlanInFlight } = await import('./commands/plan-continue.js');
+                session.plan_in_flight = buildPlanInFlight(planResume, planPhaseStartedAt);
+            }
+            // A4 — flag-gated per-phase model tiering (classic-mode mirror of the
+            // Ink path above; see that block for the design note).
+            {
+                const { isPlanModelTieringEnabled, selectPlanPhaseModel } = await import('./commands/plan-model-tier.js');
+                const choice = selectPlanPhaseModel({
+                    enabled: isPlanModelTieringEnabled(cfg),
+                    phaseId: planResume.nextPhaseId,
+                    delegateTo: planResume.nextDelegateTo,
+                    // model-governance step 2d — the session default now resolves
+                    // env > local > server > built-in (== cfg.default_model when nothing set).
+                    defaultModel: resolveModelRole('session_default', cfg),
+                });
+                if (choice.model) {
+                    planModelOverride = choice.model;
+                    console.log(chalk.dim(choice.notice));
+                }
+            }
+        }
+        // C1 mid-phase-continue — continuation detect + prepare (classic mirror
+        // of the Ink branch; see there for the full design note: mutually
+        // exclusive with --resume, prompt NOT replaced, context NOT reset).
+        let planContinue = null;
+        if (skill === 'abap-plan' && planResume === null && session.plan_in_flight) {
+            const marker = session.plan_in_flight;
+            const { preparePlanContinuation } = await import('./commands/plan-continue.js');
+            const r = preparePlanContinuation({
+                marker,
+                sessionId: session.id,
+                log: (...lines) => lines.forEach((l) => console.log(l)),
+            });
+            if (r.prepared) {
+                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})`));
+            }
+            else if (r.stale) {
+                session.plan_in_flight = null; // plan/phase gone for good — marker is noise
+            }
         }
+        const planContinueForHook = planContinue;
         // 2026-06-08 — manifest-on-interrupt (classic path). See the Ink path for
         // the full rationale; persist the revision mid-turn so a Ctrl+C can't lose it.
         let planSavedEarly = false;
+        // A1 — persisted-revision outcome; drives the post-turn next-phase offer.
+        let planOutcome = null;
+        // Fix-wave (item 1) — classic mirror of the Ink path: subagent counter
+        // consumed in the runTurn finally, threaded to runPostPhaseChain.
+        let planSubagentDispatches;
         const planResumeForHook = planResume;
         const turnStart = Date.now();
         // H1 — `session.usage` is session-LIFETIME (initialised once in
@@ -1815,21 +2765,53 @@ export async function runRepl(opts) {
         };
         rl.on('SIGINT', onSigint);
         try {
+            // Task 6 (review M-2) — guarded chain start (classic mirror): set
+            // INSIDE the try so nothing between set and runTurn can skip the
+            // finally-clear.
+            // C1 — a continuation turn re-attaches to the interrupted phase, so the
+            // SAME enforcement is active for it too (classic mirror; see Ink note).
+            const planPhaseCtx = planResume ?? planContinue?.prepared;
+            if (planPhaseCtx) {
+                const { setPlanPhaseActive, setGuardedRunActive, setCurrentPhaseWrites, getAndResetPlanDeviation } = await import('./commands/plan-gate.js');
+                // Task 7 — plan-phase subagent read-only enforcement (classic mirror):
+                // set for EVERY plan-resume phase turn regardless of mode.
+                setPlanPhaseActive(true);
+                // Task 10 — executing phase's writes declaration for the deviation
+                // backstop + stale-flag discard (classic mirror; see Ink path note).
+                setCurrentPhaseWrites(planPhaseCtx.nextPhaseWrites ?? true);
+                getAndResetPlanDeviation();
+                planPhaseFlagSet = true;
+                if ((planPhaseCtx.effectiveMode ?? 'step') === 'guarded') {
+                    setGuardedRunActive(true);
+                    guardedRunFlagSet = true;
+                    console.log(chalk.dim('▶ guarded mode — auto_approve disabled 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).
+                if ((planPhaseCtx.auditMode ?? 'on') === 'off') {
+                    console.log(chalk.dim('plan audits: off'));
+                }
+            }
             await runTurn({
                 provider,
                 userMessage: prompt,
                 skill: skill,
-                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
+                ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                 signal: turnAbort.signal,
-                suppressSaveHook: planResume !== null,
+                suppressSaveHook: planResume !== null || planContinue !== null,
+                // A4 — undefined on every non-plan turn (and when tiering is off).
+                modelOverride: planModelOverride,
                 onPlanManifest: planResumeForHook
                     ? async (assistantText) => {
                         try {
                             const { finishPlanResume } = await import('./commands/plan-resume.js');
-                            await finishPlanResume({
+                            planOutcome = await finishPlanResume({
                                 prepared: planResumeForHook,
                                 messages: session.messages,
                                 messagesStart: planResumeMsgStart,
+                                sessionId: session.id,
+                                attemptStartedAt: planPhaseStartedAt || undefined, // D-B item 1
+                                auditMode: planResumeForHook.auditMode, // off-switch — no pending injected when 'off'
                                 log: (...lines) => lines.forEach((l) => console.log(l)),
                                 textOverride: assistantText,
                             });
@@ -1839,7 +2821,34 @@ export async function runRepl(opts) {
                             console.log(chalk.red(`\n[plan] early revision save failed: ${err.message}\n`));
                         }
                     }
-                    : undefined,
+                    : planContinueForHook
+                        ? async (assistantText) => {
+                            // C1 — early-persist the continuation revision the moment the
+                            // manifest is finalised (classic mirror of the Ink hook).
+                            try {
+                                const { finishPlanContinuation } = await import('./commands/plan-continue.js');
+                                const r = await finishPlanContinuation({
+                                    prepared: planContinueForHook.prepared,
+                                    marker: planContinueForHook.marker,
+                                    messages: session.messages,
+                                    messagesStart: planResumeMsgStart,
+                                    sessionId: session.id,
+                                    textOverride: assistantText,
+                                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                                });
+                                if (r.kind === 'saved') {
+                                    planOutcome = r.outcome;
+                                    planSavedEarly = true;
+                                }
+                                // 'foreign'/'none'/'not-persisted': leave both flags unset —
+                                // the post-turn fallback re-classifies the full turn text and
+                                // owns the foreign save / quiet-none handling.
+                            }
+                            catch (err) {
+                                console.log(chalk.red(`\n[plan] early continuation save failed: ${err.message}\n`));
+                            }
+                        }
+                        : undefined,
             });
         }
         catch (err) {
@@ -1858,6 +2867,22 @@ export async function runRepl(opts) {
         finally {
             rl.removeListener('SIGINT', onSigint);
             turnInProgress = false;
+            // 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 survives on purpose —
+            // runPostPhaseChain below reads+resets it.)
+            if (guardedRunFlagSet || planPhaseFlagSet) {
+                const { setGuardedRunActive, setPlanPhaseActive, setCurrentPhaseWrites, getAndResetPlanPhaseSubagentDispatches } = await import('./commands/plan-gate.js');
+                if (guardedRunFlagSet)
+                    setGuardedRunActive(false);
+                if (planPhaseFlagSet) {
+                    setPlanPhaseActive(false);
+                    setCurrentPhaseWrites(null);
+                    // Fix-wave (item 1) — consume the subagent counter here (classic
+                    // mirror; see the Ink finally for the leak rationale).
+                    planSubagentDispatches = getAndResetPlanPhaseSubagentDispatches();
+                }
+            }
         }
         // B3 — persist the plan revision from the resume turn's manifest block.
         // FALLBACK: skipped when the mid-turn onPlanManifest hook already saved it
@@ -1865,10 +2890,13 @@ export async function runRepl(opts) {
         if (planResume && !planSavedEarly) {
             try {
                 const { finishPlanResume } = await import('./commands/plan-resume.js');
-                await finishPlanResume({
+                planOutcome = await finishPlanResume({
                     prepared: planResume,
                     messages: session.messages,
                     messagesStart: planResumeMsgStart,
+                    sessionId: session.id,
+                    attemptStartedAt: planPhaseStartedAt || undefined, // D-B item 1
+                    auditMode: planResume.auditMode, // off-switch — no pending injected when 'off'
                     log: (...lines) => lines.forEach((l) => console.log(l)),
                 });
             }
@@ -1876,6 +2904,112 @@ export async function runRepl(opts) {
                 console.log(chalk.red(`\n[plan] revision save failed: ${err.message}\n`));
             }
         }
+        // A1 (defect D23) + Task 6 — harness-owned continuation, now the full
+        // post-phase chain (classic-path mirror of the Ink block; see there for
+        // the design note): audit → verdict persistence → failure handling →
+        // guarded gate → offer/auto-queue through the same pendingDispatch slot
+        // the pre-prompt consumer reads.
+        if (planResume && planOutcome) {
+            try {
+                const { runPostPhaseChain } = await import('./commands/plan-chain.js');
+                const { inkAwarePrompt } = await import('./agent/loop.js');
+                await runPostPhaseChain({
+                    savedPath: planOutcome.savedPath,
+                    executedPhaseId: planResume.nextPhaseId,
+                    sessionId: session.id,
+                    cwd: process.cwd(),
+                    mode: planResume.effectiveMode ?? 'step',
+                    modeFlag: planResume.mode,
+                    // Off-switch (I3/I2) — classic mirror of the Ink chain call: skip
+                    // the audit when 'off'; per-run flag survives onto resume commands.
+                    auditMode: planResume.auditMode,
+                    auditFlag: planResume.auditFlag,
+                    // D-B — this attempt's turn-start, so the audit windows the evidence.
+                    attemptStartedAt: planPhaseStartedAt || undefined,
+                    // Fix-wave (item 1) — counter consumed in the runTurn finally.
+                    subagentDispatches: planSubagentDispatches,
+                    prompt: inkAwarePrompt,
+                    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`));
+            }
+        }
+        // C1 — continuation post-turn: fallback-persist (hook may not have
+        // fired), then re-attach the chain (classic mirror of the Ink blocks).
+        if (planContinue && !planSavedEarly) {
+            try {
+                const { finishPlanContinuation } = await import('./commands/plan-continue.js');
+                const r = await finishPlanContinuation({
+                    prepared: planContinue.prepared,
+                    marker: planContinue.marker,
+                    messages: session.messages,
+                    messagesStart: planResumeMsgStart,
+                    sessionId: session.id,
+                    log: (...lines) => lines.forEach((l) => console.log(l)),
+                });
+                if (r.kind === 'saved') {
+                    planOutcome = r.outcome;
+                }
+                else if (r.kind === 'foreign') {
+                    // The turn produced a DIFFERENT plan's manifest and the save hook
+                    // was suppressed — run the generic save now so it isn't lost. The
+                    // in-flight marker stays: that phase is still unresolved.
+                    const { maybeOfferSave } = await import('./agent/loop.js');
+                    const { collectTurnAssistantText } = await import('./agent/turn-assistant-text.js');
+                    await maybeOfferSave({
+                        skill: 'abap-plan',
+                        assistantText: collectTurnAssistantText(session.messages, planResumeMsgStart),
+                        userMessage: prompt,
+                        tokensUsed: 0,
+                        model: session.model,
+                        emit: (line) => console.log(line),
+                    });
+                }
+                else if (r.kind === 'none') {
+                    console.log(chalk.dim(`phase ${planContinue.marker.phaseId} still in flight — no completion manifest this turn`));
+                }
+            }
+            catch (err) {
+                console.log(chalk.red(`\n[plan] continuation save failed: ${err.message}\n`));
+            }
+        }
+        if (planContinue && planOutcome) {
+            try {
+                const { runContinuationChain } = await import('./commands/plan-continue.js');
+                const { inkAwarePrompt } = await import('./agent/loop.js');
+                await runContinuationChain({
+                    prepared: planContinue.prepared,
+                    marker: planContinue.marker,
+                    outcome: planOutcome,
+                    sessionId: session.id,
+                    cwd: process.cwd(),
+                    subagentDispatches: planSubagentDispatches,
+                    prompt: inkAwarePrompt,
+                    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`));
+            }
+        }
+        // C1 — the phase reached a resolved terminal (revision persisted, chain
+        // ran or is queued): the marker's job is done. Applies to --resume AND
+        // continuation dispatches; a null outcome keeps the marker (still in flight).
+        if (planOutcome)
+            session.plan_in_flight = null;
+        // Task 9 — chain leg truly ends here: release the run lease UNLESS a
+        // next-phase dispatch is queued (review fix — the loop-top pre-prompt
+        // consumer reads the slot after `continue`, so it still holds the
+        // command here; the chain must keep the family lock across the gap).
+        // Classic mirror of the Ink call site; see the design note there.
+        if (planResume || planContinue) {
+            const { releaseRunLeaseUnlessChained } = await import('./projects/run-lease.js');
+            releaseRunLeaseUnlessChained((planResume ?? planContinue.prepared).path, pendingDispatchAccessor.get());
+        }
         // Status footer after each turn.
         // tool_result messages also have role:'user' but content is an array —
         // filter them out so we count actual user prompts, not tool rounds.
@@ -1896,6 +3030,9 @@ export async function runRepl(opts) {
                 cacheCreate: turnStartCostSnapshot.cacheCreate,
                 startedAt: turnStart,
             },
+            // A4 — price the turn at the model that actually ran it (classic-path
+            // mirror of the Ink call site above).
+            turnModel: planModelOverride ?? session.model,
         });
         // 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.