@cspeach/cli 0.6.5 → 0.7.1

package/dist/repl.js

@@ -21,6 +21,7 @@ import { getConnection } from './sap/connection-manager.js';
 import { AdtClient } from '@cspeach/sap-client';
 import { makeSessionId, saveSession } from './session/store.js';
 import { newSession } from './session/schema.js';
+import { computeCost, formatCost } from './cost/pricing.js';
 import { createProviderForMode } from './agent/providers/factory.js';
 import { runTurn } from './agent/loop.js';
 import { renderTurnError } from './agent/turn-error-ux.js';
@@ -28,6 +29,7 @@ import { classifyPrompt, parseShortcut } 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 { PICK_CANCELLED } from './ui/skill-picker.js';
 import { registerReadline, withInquirer } from './repl/inquirer-guard.js';
 import { maybePromptWorkspaceMigration } from './projects/migration.js';
@@ -57,7 +59,6 @@ function prefillReadline(rl, text) {
 }
 import { BracketedPasteDecoder, enableBracketedPaste, disableBracketedPaste, } from './repl/bracketed-paste.js';
 import { printHelp } from './commands/help.js';
-import { printStatusFooter } from './renderer/status-footer.js';
 import { shouldUseInk, setRenderingOverride } from './renderer/tty.js';
 import { saveConfig } from './config/loader.js';
 import { EventEmitter } from 'node:events';
@@ -65,6 +66,8 @@ 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 { snapshotTurnStart, pushPostTurnStatus } from './repl/post-turn-status.js';
+import { looksLikeCspeachShellCommand, CSPEACH_SHELL_NUDGE } from './repl/cspeach-shell-detect.js';
 // Side-effect imports so tool registrations happen before listTools() is called.
 import './tools/sap-read.js';
 import './tools/sap-write.js';
@@ -87,7 +90,7 @@ import './tools/project/convention_get.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
-import './tools/subagent/schedule_create.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');
@@ -137,6 +140,32 @@ const ACK_PHRASES = new Set([
     'decline', 'denied', 'reject', 'rejected',
     'skip', 'next',
 ]);
+/** Conversational acknowledgements that mean "I'm done with the previous
+ *  turn, no further work needed." Distinct from ACK_PHRASES (which
+ *  largely mean "yes/no to a question"). For these we don't classify,
+ *  don't call any model — just print a friendly ack and return. The user
+ *  isn't asking us to do more work; they're closing the prior thread.
+ *
+ *  2026-05-17 — Laeeq hit "thank you" being classified and run through
+ *  /abap-explain, producing another huge code explanation. THIS is the
+ *  fix for that. */
+const CONVERSATIONAL_ACKS = new Set([
+    'thanks', 'thank you', 'thank u', 'thx', 'tx', 'ty', 'ta',
+    'cool', 'nice', 'great', 'awesome', 'perfect',
+    'got it', 'gotit', 'understood',
+    'cheers',
+    // Common ackowledgements that follow a long answer.
+    'makes sense',
+]);
+/**
+ * True when `trimmed` is one of CONVERSATIONAL_ACKS. We treat these as
+ * "user closes the previous thread, no further work" — print a friendly
+ * acknowledgement and return without classifying or calling any model.
+ */
+function isConversationalAck(trimmed) {
+    const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
+    return CONVERSATIONAL_ACKS.has(normalized);
+}
 /**
  * Returns true when `trimmed` is a short acknowledgement-style follow-up
  * AND there is a previous skill to continue. Treats both bare acks and
@@ -169,6 +198,41 @@ function isAckContinuation(trimmed, sessionSkill) {
  * the "nonsense like 'yes' → /abap-explain at 35%" failure that ACK_PHRASES
  * was introduced to prevent.
  */
+/**
+ * Print the goodbye + session-saved message on /exit. Used by both
+ * classic and Ink paths. In Ink the caller MUST invoke this AFTER
+ * leaveAltScreen() so the message lands in the user's restored shell
+ * scrollback (not the alt-screen which is about to disappear).
+ *
+ * 2026-05-17 — enriched to show session summary (turn count, last
+ * skill, total cost) so the user has something to look back on after
+ * the alt-screen takedown wipes the conversation. Without this the
+ * shell shows only the startup banner + a bare "session saved" line,
+ * which feels like everything they just did vanished.
+ */
+function printGoodbye(session) {
+    const userTurns = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
+    const sessionCost = computeCost(session.model, {
+        input: session.usage.input_tokens ?? 0,
+        output: session.usage.output_tokens ?? 0,
+        cacheRead: session.usage.cache_read_input_tokens ?? 0,
+        cacheCreate: session.usage.cache_creation_input_tokens ?? 0,
+    });
+    const totalTokens = (session.usage.input_tokens ?? 0) +
+        (session.usage.output_tokens ?? 0) +
+        (session.usage.cache_read_input_tokens ?? 0) +
+        (session.usage.cache_creation_input_tokens ?? 0);
+    console.log('');
+    console.log(chalk.bold(`Session ${session.id}`));
+    console.log(chalk.dim(`  turns:     ${userTurns}`));
+    console.log(chalk.dim(`  last skill: ${session.skill ?? '(none)'}`));
+    console.log(chalk.dim(`  tokens:    ${totalTokens.toLocaleString()}  (input+output+cache)`));
+    console.log(chalk.dim(`  spend:     ${formatCost(sessionCost)}`));
+    console.log('');
+    console.log(chalk.cyan(`Resume with: cspeach --resume ${session.id}`));
+    console.log(chalk.dim(`Full log: ~/.cspeach/streams/${session.id}.md`));
+    console.log('');
+}
 function isBareAck(trimmed) {
     const normalized = trimmed.toLowerCase().trim().replace(/[.!?,]+$/, '');
     return ACK_PHRASES.has(normalized);
@@ -178,23 +242,52 @@ function isBareAck(trimmed) {
  * Picks top-3 candidates (top-1 + top-2 alternates), looks up description
  * and whenToUse from the catalog per entry. Falls back to entry.description
  * if whenToUse is missing (defensive — drift-guard test should prevent this).
+ *
+ * 2026-05-16 (screenshot 72): always pads to at least MIN_OPTIONS so the
+ *   user has something to arrow to.
+ * 2026-05-17 (continuation UX): the just-used skill (lastSkill) is
+ *   always included in candidates (de-duped, no double-render). Picker
+ *   then defaults its cursor to that option via preferSkill, so a
+ *   follow-up question to a recent skill is a 1-Enter-press continuation
+ *   instead of having to arrow to the right item.
  */
-function buildCoachingParams(result, prompt, preSelect) {
+const PICKER_FALLBACK_SKILLS = [
+    'abap-explain', 'abap-review', 'abap-document', 'abap-rap', 'abap-radar',
+];
+const MIN_PICKER_OPTIONS = 3;
+function buildCoachingParams(result, prompt, preSelect, lastSkill) {
     const candidates = [result.skill, ...result.alternates].slice(0, 3);
+    // Include the just-used skill if not already present — gives the user
+    // a one-keypress "continue with same skill" path. Inserted AFTER the
+    // classifier's top-1 so the classifier's best guess still leads
+    // visually; the cursor will default to lastSkill via preferSkill below.
+    if (lastSkill && !candidates.includes(lastSkill)) {
+        candidates.splice(1, 0, lastSkill);
+    }
+    // Pad with fallback skills if total still under the minimum.
+    if (candidates.length < MIN_PICKER_OPTIONS) {
+        for (const fallback of PICKER_FALLBACK_SKILLS) {
+            if (candidates.length >= MIN_PICKER_OPTIONS)
+                break;
+            if (!candidates.includes(fallback))
+                candidates.push(fallback);
+        }
+    }
     const options = candidates.map((skill) => {
         const entry = SKILL_CATALOG.find((e) => e.name === skill);
         return {
             skill,
-            // Only the top-1 has a real confidence; alternates currently are skill-
-            // name only (Layer B gap). Show top-1's confidence for the first entry,
-            // 0 for alternates (rendered as "0%") — a visual cue that these are
-            // alternate suggestions, not separately scored.
             confidence: skill === result.skill ? result.confidence : 0,
             whatItDoes: entry?.description ?? 'no description',
             whenToPick: entry?.whenToUse ?? entry?.description ?? 'no description',
         };
     });
-    return { prompt, options, preSelect };
+    return {
+        prompt,
+        options,
+        preSelect,
+        preferSkill: lastSkill ?? undefined,
+    };
 }
 export async function runRepl(opts) {
     printStartupBanner();
@@ -306,6 +399,14 @@ export async function runRepl(opts) {
     }
     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.
+    sapStateStore.update({
+        system: `${selectedAlias} (${cfg.sap[selectedAlias].host})`,
+        user: cfg.sap[selectedAlias].username,
+    });
     // 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
@@ -361,22 +462,111 @@ export async function runRepl(opts) {
         const { App } = await import('./ui/app.js');
         const React = (await import('react')).default;
         const chunkEmitter = new EventEmitter();
+        // Phase D6 (2026-05-17) — INLINE Ink mode (no alt-screen).
+        //
+        // After Laeeq pointed out CC achieves great scrolling without any
+        // alt-screen, we reverted the alt-screen attempt. Ink renders to
+        // the normal terminal stream; Body uses <Static> to commit each
+        // node to scrollback. The terminal's native scroll (mouse wheel,
+        // PgUp, search) just works because we're not stealing the screen.
+        //
+        // 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)
+        // 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
+        // showCursor=true draws a block character at the actual typing
+        // position. Hiding the native cursor leaves just that block — clear
+        // visual indicator without the distracting phantom blink below.
+        // Restored on /exit via the SHOW_CURSOR write below. Belt-and-
+        // braces: also restore on process exit / uncaught exception so a
+        // crash doesn't leave the user's shell with no visible cursor.
+        process.stdout.write('\x1b[?25l');
+        const restoreCursor = () => { process.stdout.write('\x1b[?25h'); };
+        process.once('exit', restoreCursor);
+        process.once('uncaughtException', (err) => {
+            restoreCursor();
+            process.stderr.write(`\nUncaught: ${err.stack ?? String(err)}\n`);
+            process.exit(1);
+        });
         let done = false;
         let resolveDone = null;
         const donePromise = new Promise((r) => { resolveDone = r; });
+        // Phase D5 (2026-05-17) — per-turn AbortController for SIGINT.
+        // Ink puts stdin in raw mode so the OS SIGINT never fires; we catch
+        // Ctrl+C via App.useInput → onInterrupt callback below. That callback
+        // either aborts the in-flight turn (if one's running) or exits the
+        // app cleanly (if at idle). Mirrors classic mode's turn-scoped abort
+        // semantics — first Ctrl+C aborts, second exits.
+        //
+        // currentTurnAbort: when set, a turn is in progress and we abort
+        // it. When null, we're at idle and should exit on Ctrl+C.
+        let currentTurnAbort = null;
+        let interruptCount = 0;
         const handleSubmit = async (line) => {
             const trimmed = line.trim();
             if (!trimmed)
                 return;
             appendHistory(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
+            // Laeeq's screenshot-70 observation: previous turn's prose and
+            // new turn's content touched with no separator and looked like
+            // garbled overlap).
+            if (trimmed !== '/exit' && trimmed !== '/quit') {
+                chunkEmitter.emit('chunk', chalk.dim('\n──────────────────────────────────\n') +
+                    chalk.cyan(`› ${trimmed}\n`));
+            }
             if (trimmed === '/exit' || trimmed === '/quit') {
                 done = true;
                 if (resolveDone)
                     resolveDone();
                 return;
             }
+            // Bug 11b (2026-05-15) — user typed `cspeach ...` at the REPL prompt
+            // by mistake. Catch it before any classifier or skill routing fires.
+            if (looksLikeCspeachShellCommand(trimmed)) {
+                chunkEmitter.emit('chunk', chalk.yellow(`\n${CSPEACH_SHELL_NUDGE}\n`));
+                return;
+            }
             if (trimmed === '/help' || trimmed === '/skills') {
-                printHelp();
+                // Phase D5 — route through chunkEmitter so help lands in Body,
+                // not above the Ink frame (which would scroll off + corrupt).
+                printHelp((line) => chunkEmitter.emit('chunk', line + '\n'));
+                return;
+            }
+            // Phase 1 cost tracking (2026-05-16) — /cost prints session $ summary
+            // from the JSONL log written each turn. Read-only, no network.
+            if (trimmed === '/cost') {
+                const { runCostCommand } = await import('./commands/cost.js');
+                await runCostCommand(session.id);
+                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 { 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' } });
+                };
+                try {
+                    chunkEmitter.emit('chunk', chalk.dim('\nCompacting older turns into a summary...\n'));
+                    const result = await runCompact({ session, summarise, keepRecentTurns: compactCfg.keep_recent_turns });
+                    chunkEmitter.emit('chunk', formatCompactResult(result, compactCfg.keep_recent_turns));
+                }
+                catch (err) {
+                    chunkEmitter.emit('chunk', chalk.red(`\n/compact failed: ${err instanceof Error ? err.message : String(err)}\n`));
+                }
                 return;
             }
             // /files — open interactive picker for .cspeach.json artefacts in
@@ -406,33 +596,35 @@ export async function runRepl(opts) {
                 return;
             }
             // /ui — view or change rendering mode. Ink-mode branch mirrors non-Ink.
+            // Phase D5 (2026-05-17): all console.log → chunkEmitter so output
+            // lands in Body, not above the React frame.
             if (trimmed === '/ui' || trimmed.startsWith('/ui ')) {
-                // Defensive: a config that predates the [ui] section may have cfg.ui === undefined
-                // if loaded before loader.ts's deep-merge fix. Initialise to the default.
                 if (!cfg.ui)
                     cfg.ui = { rendering: 'auto' };
                 const arg = trimmed.slice(3).trim().toLowerCase();
+                const emit = (s) => chunkEmitter.emit('chunk', s + '\n');
                 if (arg === '') {
-                    console.log(`\nCurrent UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
-                        `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})\n`);
-                    console.log(chalk.dim('  /ui classic  — chalk REPL (default)'));
-                    console.log(chalk.dim('  /ui ink      — Ink frame (opt-in)'));
-                    console.log(chalk.dim('  /ui auto     — choose automatically\n'));
-                    console.log(chalk.dim('Change takes effect after /exit + relaunch.\n'));
+                    emit('');
+                    emit(`Current UI mode: ${chalk.cyan.bold(cfg.ui.rendering)}  ` +
+                        `(effective now: ${chalk.yellow(shouldUseInk() ? 'ink' : 'classic')})`);
+                    emit(chalk.dim('  /ui classic  — chalk REPL (default)'));
+                    emit(chalk.dim('  /ui ink      — Ink frame (opt-in)'));
+                    emit(chalk.dim('  /ui auto     — choose automatically'));
+                    emit(chalk.dim('Change takes effect after /exit + relaunch.'));
                 }
                 else if (arg === 'auto' || arg === 'ink' || arg === 'classic') {
                     cfg.ui.rendering = arg;
                     try {
                         await saveConfig(cfg);
-                        console.log(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
-                        console.log(chalk.dim('Relaunch cspeach to apply.\n'));
+                        emit(chalk.green(`\n✓ UI mode set to ${chalk.bold(arg)}.`));
+                        emit(chalk.dim('Relaunch cspeach to apply.'));
                     }
                     catch (err) {
-                        console.log(chalk.red(`\n✗ Failed to save config: ${err.message}\n`));
+                        emit(chalk.red(`\n✗ Failed to save config: ${err.message}`));
                     }
                 }
                 else {
-                    console.log(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.\n`));
+                    emit(chalk.red(`\nUnknown UI mode: ${arg}. Try auto / ink / classic.`));
                 }
                 return;
             }
@@ -441,13 +633,13 @@ export async function runRepl(opts) {
                 session.awaitingSkillAnswer = false;
                 const rr = parseAndValidateReroute(trimmed, session.lastUserPrompt, SKILL_CATALOG);
                 if (rr.kind === 'error') {
-                    console.log(chalk.red(`\n${rr.message}\n`));
+                    chunkEmitter.emit('chunk', chalk.red(`\n${rr.message}\n`));
                     return;
                 }
                 const preview = rr.prompt.length > 60 ? rr.prompt.slice(0, 57) + '...' : rr.prompt;
-                console.log(chalk.dim(`↪ Rerouting "${preview}" → /${rr.skill}`));
+                chunkEmitter.emit('chunk', chalk.dim(`\n↪ Rerouting "${preview}" → /${rr.skill}\n`));
                 if (rr.warning)
-                    console.log(chalk.dim(`  (${rr.warning})`));
+                    chunkEmitter.emit('chunk', chalk.dim(`  (${rr.warning})\n`));
                 await runTurn({
                     provider,
                     userMessage: rr.prompt,
@@ -462,14 +654,14 @@ export async function runRepl(opts) {
             // previous skill's Q&A chain.
             if (trimmed === '/new' || trimmed === '/reset') {
                 session.awaitingSkillAnswer = false;
-                console.log(chalk.dim('↩ fresh start — next prompt will be classified normally'));
+                chunkEmitter.emit('chunk', chalk.dim('\n↩ fresh start — next prompt will be classified normally\n'));
                 return;
             }
             // /transport — session current-transport state for Rule 9 (transport isolation)
             if (trimmed === '/transport' || trimmed.startsWith('/transport ')) {
                 const arg = trimmed === '/transport' ? '' : trimmed.slice('/transport '.length);
                 const msg = handleTransportCommand(arg);
-                console.log(chalk.cyan(msg));
+                chunkEmitter.emit('chunk', chalk.cyan(`\n${msg}\n`));
                 return;
             }
             const parsed = parseShortcut(trimmed);
@@ -495,6 +687,16 @@ export async function runRepl(opts) {
                 // Use session.skill (the skill of the IMMEDIATELY PREVIOUS turn) —
                 // NOT session.last_skill which holds the skill from TWO turns ago
                 // and is used as classifier context.
+                // 2026-05-17 — conversational ack ("thank you", "thanks", "cool",
+                // "got it", etc.) means the user is closing the prior thread, not
+                // asking for more work. Print a friendly response and return
+                // BEFORE the classifier/skill machinery. Saves the user from
+                // accidentally running another expensive turn on a thank-you.
+                if (isConversationalAck(trimmed)) {
+                    chunkEmitter.emit('chunk', chalk.cyan('You\'re welcome. ') +
+                        chalk.dim('Type a new question, /new to reset, or /exit to quit.\n'));
+                    return;
+                }
                 if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
                     chunkEmitter.emit('chunk', chalk.dim(`↪ Continuing /${session.skill}\n`));
                     skill = session.skill;
@@ -514,19 +716,24 @@ export async function runRepl(opts) {
                             last_object: extractedObject ?? session.last_object ?? null,
                         });
                         const decision = decideRouting(c);
+                        // 2026-05-17 — pass the just-used skill so the picker can
+                        // default cursor to it (one-Enter "continue" UX for follow-up
+                        // questions). session.skill = immediately-previous turn's
+                        // skill, NOT session.last_skill which is from TWO turns ago.
+                        const continueSkill = session.skill ?? null;
                         let pickedResult;
                         if (cfg.classifier.safe_mode) {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(c, trimmed, false));
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(c, trimmed, false, continueSkill));
                         }
                         else if (decision.kind === 'silent') {
                             chunkEmitter.emit('chunk', chalk.dim(`┄ Routed to /${decision.skill}\n`));
                             pickedResult = decision.skill;
                         }
                         else if (decision.kind === 'coach') {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, true));
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, true, continueSkill));
                         }
                         else {
-                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, false));
+                            pickedResult = await coachingPickerEmitter.request(buildCoachingParams(decision.result, trimmed, false, continueSkill));
                         }
                         if (pickedResult === PICK_CANCELLED) {
                             chunkEmitter.emit('chunk', chalk.dim('↩ cancelled — type a new prompt\n'));
@@ -572,6 +779,19 @@ export async function runRepl(opts) {
                 session.last_object = extractedObject ?? previousObject ?? null;
                 return;
             }
+            // Phase A** wiring fix (2026-05-16) — snapshot pre-turn counters so
+            // pushPostTurnStatus can compute per-turn deltas. The classic-mode
+            // turn loop has its own equivalent below; both paths now call the
+            // shared post-turn helper so StatusRow + Sidebar update in BOTH
+            // modes. (Pre-fix this whole block didn't exist in the Ink path —
+            // sidebar stayed frozen at "0 tok / no turns yet" forever.)
+            const turnSnapshot = snapshotTurnStart(session);
+            // Phase D5 (2026-05-17) — install per-turn abort. onInterrupt
+            // (Ctrl+C handler) calls currentTurnAbort.abort() while this is
+            // non-null, which tears the in-flight provider stream down via
+            // the signal we thread into runTurn.
+            currentTurnAbort = new AbortController();
+            interruptCount = 0;
             try {
                 await runTurn({
                     provider,
@@ -579,6 +799,7 @@ export async function runRepl(opts) {
                     skill: skill,
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     chunkEmitter,
+                    signal: currentTurnAbort.signal,
                 });
             }
             catch (err) {
@@ -589,6 +810,10 @@ export async function runRepl(opts) {
                     body: err.message,
                 });
             }
+            finally {
+                currentTurnAbort = null;
+            }
+            pushPostTurnStatus({ session, selectedAlias, snapshot: turnSnapshot, chunkEmitter });
             session.last_skill = previousSkill ?? null;
             session.last_object = extractedObject ?? previousObject ?? null;
             // 2026-05-08: post-turn auto-dispatch. The dispatch_skill tool may
@@ -606,6 +831,34 @@ export async function runRepl(opts) {
                 setImmediate(() => { void handleSubmit(dispatched); });
             }
         };
+        // Phase D5 (2026-05-17) — Ctrl+C handler routed through Ink.
+        // First press during turn: abort the turn (preserves partial work).
+        // Second press during the SAME turn: hard-exit (escape hatch in case
+        // the abort doesn't take effect for some reason).
+        // Press at idle: clean exit (printGoodbye + leaveAltScreen).
+        const onInterrupt = () => {
+            if (currentTurnAbort) {
+                interruptCount++;
+                if (interruptCount === 1) {
+                    chunkEmitter.emit('chunk', chalk.yellow('\n⚠  Interrupting turn — saving partial work...\n'));
+                    currentTurnAbort.abort();
+                }
+                else {
+                    // Second Ctrl+C during the same turn — give up and exit.
+                    chunkEmitter.emit('chunk', chalk.red('\n✗ Force-exit on second Ctrl+C.\n'));
+                    unmount();
+                    process.stdout.write('\x1b[?25h'); // restore cursor
+                    printGoodbye(session);
+                    process.exit(130); // 128 + SIGINT
+                }
+            }
+            else {
+                // Idle — clean exit, same path as /exit.
+                done = true;
+                if (resolveDone)
+                    resolveDone();
+            }
+        };
         const { unmount } = render(React.createElement(App, {
             chunkEmitter,
             onSubmit: (line) => { void handleSubmit(line); },
@@ -613,9 +866,23 @@ export async function runRepl(opts) {
             onHistoryTrigger: () => { },
             getToolCalls: () => session.toolCalls,
             writeMode: cfg.write_mode,
-        }));
+            onInterrupt,
+        }), {
+            // Critical: without this Ink calls process.exit() on Ctrl+C and
+            // kills the CLI before our onInterrupt handler can decide what
+            // to do. We want to make that decision ourselves (abort turn
+            // vs exit at idle).
+            exitOnCtrlC: false,
+        });
         await donePromise;
         unmount();
+        // Restore the terminal cursor we hid on Ink mount.
+        process.stdout.write('\x1b[?25h');
+        // Print session summary + resume hint after Ink unmounts so the
+        // line lands in the user's shell scrollback alongside the session
+        // history. In inline mode the conversation IS in scrollback (no
+        // alt-screen erased it), so this is just a friendly bookend.
+        printGoodbye(session);
         return 0;
     }
     // --- readline setup (replaces inquirer input()) ---
@@ -957,15 +1224,52 @@ export async function runRepl(opts) {
             continue;
         }
         if (trimmed === '/exit' || trimmed === '/quit') {
-            console.log('Goodbye.\n');
+            printGoodbye(session);
             rl.close();
             return 0;
         }
+        // Bug 11b (2026-05-15) — user typed `cspeach ...` at the REPL prompt
+        // by mistake (e.g. `cspeach --resume <id>` while still inside CSPeach).
+        // Catch it before any classifier or skill routing fires so we don't
+        // waste a turn and don't pollute the session with the stray line.
+        if (looksLikeCspeachShellCommand(trimmed)) {
+            console.log(chalk.yellow(`\n${CSPEACH_SHELL_NUDGE}\n`));
+            continue;
+        }
         // /help and /skills show the skill catalog flat-list.
         if (trimmed === '/help' || trimmed === '/skills') {
             printHelp();
             continue;
         }
+        // Phase 1 cost tracking (2026-05-16) — classic-mode /cost.
+        // Mirrors the Ink-mode handler above. /cost prints session $ summary
+        // from the JSONL log written each turn. Read-only, no network.
+        if (trimmed === '/cost') {
+            const { runCostCommand } = await import('./commands/cost.js');
+            await runCostCommand(session.id);
+            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 { 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' } });
+            };
+            try {
+                console.log(chalk.dim('\nCompacting older turns into a summary...'));
+                const result = await runCompact({ session, summarise, keepRecentTurns: compactCfg.keep_recent_turns });
+                console.log(formatCompactResult(result, compactCfg.keep_recent_turns));
+            }
+            catch (err) {
+                console.log(chalk.red(`\n/compact failed: ${err instanceof Error ? err.message : String(err)}\n`));
+            }
+            continue;
+        }
         // /files — open interactive picker for .cspeach.json artefacts in
         // the workspace folder. After picking a file and an action, pre-fill
         // the synthesized slash command into the NEXT prompt via pendingPrefill
@@ -1208,6 +1512,12 @@ export async function runRepl(opts) {
             // Use session.skill (the skill of the IMMEDIATELY PREVIOUS turn) —
             // NOT session.last_skill which holds the skill from TWO turns ago
             // and is used as classifier context.
+            // 2026-05-17 — conversational ack short-circuit (matches Ink path).
+            if (isConversationalAck(trimmed)) {
+                console.log(chalk.cyan('You\'re welcome. ') +
+                    chalk.dim('Type a new question, /new to reset, or /exit to quit.'));
+                continue;
+            }
             if ((session.awaitingSkillAnswer || isAckContinuation(trimmed, session.skill)) && session.skill) {
                 console.log(chalk.dim(`↪ Continuing /${session.skill}`));
                 skill = session.skill;
@@ -1227,6 +1537,10 @@ export async function runRepl(opts) {
                         last_object: extractedObject ?? session.last_object ?? null,
                     });
                     const decision = decideRouting(c);
+                    // 2026-05-17 — pass the just-used skill so the picker can
+                    // default cursor to it. session.skill = immediately-previous
+                    // turn's skill, NOT session.last_skill (TWO turns ago).
+                    const continueSkillClassic = session.skill ?? null;
                     let pickedResult;
                     // Coaching picker path — inquirer takes over stdin. Use the shared
                     // withInquirer guard so the suppress-close window stays active
@@ -1238,7 +1552,7 @@ export async function runRepl(opts) {
                     };
                     if (cfg.classifier.safe_mode) {
                         // Safe mode overrides the decision — always open the full picker.
-                        pickedResult = await runPicker(buildCoachingParams(c, trimmed, false));
+                        pickedResult = await runPicker(buildCoachingParams(c, trimmed, false, continueSkillClassic));
                     }
                     else if (decision.kind === 'silent') {
                         console.log(chalk.dim(`┄ Routed to /${decision.skill}`));
@@ -1246,7 +1560,7 @@ export async function runRepl(opts) {
                     }
                     else {
                         const preSelect = decision.kind === 'coach';
-                        pickedResult = await runPicker(buildCoachingParams(decision.result, trimmed, preSelect));
+                        pickedResult = await runPicker(buildCoachingParams(decision.result, trimmed, preSelect, continueSkillClassic));
                     }
                     if (pickedResult === PICK_CANCELLED) {
                         console.log(chalk.dim('↩ cancelled — type a new prompt'));
@@ -1299,6 +1613,15 @@ export async function runRepl(opts) {
         // over Option B (changing label to "lifetime") because users care about
         // what the turn they just ran cost them, not the session running total.
         const lifetimeTokensBefore = session.usage.input_tokens + session.usage.output_tokens;
+        // Phase 1 cost tracking (2026-05-16) — snapshot all four counters so
+        // the footer can compute per-turn $ (loop.ts also writes a JSONL line,
+        // but the footer needs the value right here for immediate display).
+        const turnStartCostSnapshot = {
+            input: session.usage.input_tokens,
+            output: session.usage.output_tokens,
+            cacheRead: session.usage.cache_read_input_tokens,
+            cacheCreate: session.usage.cache_creation_input_tokens ?? 0,
+        };
         // v0.6 — per-turn SIGINT hard-interrupt + AbortController.
         //
         // Critical: Node readline with `terminal: true` (which we use) puts
@@ -1360,19 +1683,21 @@ export async function runRepl(opts) {
         const userTurns = session.messages.filter((m) => m.role === 'user' && typeof m.content === 'string').length;
         const lifetimeTokensAfter = session.usage.input_tokens + session.usage.output_tokens;
         const turnTokens = Math.max(0, lifetimeTokensAfter - lifetimeTokensBefore);
-        // H4: do not write chalk status footer if Ink owns stdout — it corrupts
-        // the frame. The Ink path renders its own <StatusRow /> above <Footer>.
-        if (!shouldUseInk()) {
-            printStatusFooter({
-                sessionId: session.id,
-                sapAlias: selectedAlias,
-                skill: session.skill ?? '(none)',
-                turnCount: userTurns,
-                tokens: turnTokens,
-                cachedTokens: session.usage.cache_read_input_tokens,
-                elapsedMs: Date.now() - turnStart,
-            });
-        }
+        // Phase A** (2026-05-16) — both classic + Ink paths now share the
+        // same post-turn helper. See src/repl/post-turn-status.ts. Earlier
+        // this block lived inline here and the Ink path's separate runTurn
+        // call site never reached it → sidebar froze forever under Ink.
+        pushPostTurnStatus({
+            session,
+            selectedAlias,
+            snapshot: {
+                input: turnStartCostSnapshot.input,
+                output: turnStartCostSnapshot.output,
+                cacheRead: turnStartCostSnapshot.cacheRead,
+                cacheCreate: turnStartCostSnapshot.cacheCreate,
+                startedAt: turnStart,
+            },
+        });
         // 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.
         // `session.skill` itself is reassigned inside runTurn (agent/loop.ts) to the