@cspeach/cli 0.9.0 → 1.1.0

package/dist/repl/numbered-menu.js

@@ -0,0 +1,131 @@
+/**
+ * Numbered-menu expansion — UX-5 #2 (2026-06-12).
+ *
+ * Skills frequently end a turn with a plain-text numbered menu:
+ *
+ *   1. Explain it
+ *   2. Show structure
+ *   3. Run ATC
+ *
+ * Users then type `2` at the prompt — and before this module nothing
+ * useful happened: the bare digit was either routed to the previous skill
+ * as a meaningless answer or burned a classifier round-trip. The
+ * pragmatic fix: when the user submits a SHORT pure-number input AND the
+ * previous assistant message contains a matching numbered list item,
+ * expand the input to that item's text before the turn starts (with a
+ * dim echo so the user sees what they picked). Anything else passes
+ * through unchanged.
+ *
+ * Deliberately conservative — expansion fires ONLY when:
+ *   - the input matches ^[0-9]{1,2}$ (1–2 digit pure number, no spaces)
+ *   - the MENU-SHAPED TAIL of the last assistant text — its final
+ *     ~MENU_TAIL_LINES non-empty lines — contains a numbered list with
+ *     2+ items ("N. text" or "N · text" line patterns). A real menu sits
+ *     at the END of the message; numbered plans/steps mid-message
+ *     (followed by more prose) must NOT hijack a legitimate numeric
+ *     answer (UX-5 review I2, 2026-06-12).
+ *   - the typed number is one of the list's item numbers
+ *
+ * Everything else (no list, out-of-range number, prose input) returns
+ * null and the caller treats the input as typed.
+ */
+/** Pure 1–2 digit number, nothing else. */
+const PURE_NUMBER_RE = /^[0-9]{1,2}$/;
+/**
+ * A numbered list item at the start of a line: `12. text` or `12 · text`.
+ * Bullet variants with `)` etc. are deliberately NOT matched — staying
+ * conservative beats over-firing on prose like "step 3) optional".
+ */
+const ITEM_LINE_RE = /^\s*([0-9]{1,2})(?:\.|\s·)\s+(\S.*)$/;
+/**
+ * Extract numbered list items from assistant text. Returns one entry per
+ * distinct item number — when the same number appears twice (e.g. two
+ * separate lists in one message), the LAST occurrence wins, since the
+ * most recent list is the one the user is looking at.
+ */
+export function extractNumberedItems(text) {
+    const byNumber = new Map();
+    for (const line of text.split('\n')) {
+        const m = ITEM_LINE_RE.exec(line);
+        if (!m)
+            continue;
+        const n = Number.parseInt(m[1], 10);
+        byNumber.set(n, m[2].trim());
+    }
+    return [...byNumber.entries()].map(([number, text]) => ({ number, text }));
+}
+/**
+ * How many trailing non-empty lines count as the "menu-shaped tail" of an
+ * assistant message. 10 fits the largest real skill menus seen in the wild
+ * (8 items + a header + a trailing "pick one" line) while excluding
+ * numbered plan/step lists that sit mid-message above closing prose.
+ */
+export const MENU_TAIL_LINES = 10;
+/**
+ * The final `maxLines` NON-EMPTY lines of `text`, original order, joined
+ * with newlines. Blank lines are skipped (menus are often separated from
+ * the item lines by blank lines — those shouldn't eat the budget).
+ */
+export function menuTail(text, maxLines = MENU_TAIL_LINES) {
+    const lines = text.split('\n');
+    const tail = [];
+    for (let i = lines.length - 1; i >= 0 && tail.length < maxLines; i--) {
+        const line = lines[i];
+        if (line.trim().length === 0)
+            continue;
+        tail.unshift(line);
+    }
+    return tail.join('\n');
+}
+/**
+ * If `input` is a short pure number selecting an item from a numbered
+ * list in the menu-shaped TAIL of `lastAssistantText`, return the
+ * expansion; otherwise null (pass the input through unchanged).
+ *
+ * I2 (2026-06-12): only the final MENU_TAIL_LINES non-empty lines are
+ * scanned — a numbered plan mid-message (with prose after it) no longer
+ * hijacks a numeric answer the user meant literally.
+ */
+export function maybeExpandNumberSelection(input, lastAssistantText) {
+    const trimmed = input.trim();
+    if (!PURE_NUMBER_RE.test(trimmed))
+        return null;
+    if (!lastAssistantText)
+        return null;
+    const items = extractNumberedItems(menuTail(lastAssistantText));
+    if (items.length < 2)
+        return null; // not a menu — a lone "1." is prose
+    const n = Number.parseInt(trimmed, 10);
+    const hit = items.find((i) => i.number === n);
+    if (!hit)
+        return null; // out of range — pass through
+    return {
+        text: hit.text,
+        echo: `→ ${hit.number}. ${hit.text}`,
+    };
+}
+/**
+ * Text of the most recent assistant message in `messages`. Joins the
+ * text blocks of that single message (tool_use blocks skipped); handles
+ * the defensive string-content case too. Returns null when no assistant
+ * message exists.
+ */
+export function lastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        if (m.role !== 'assistant')
+            continue;
+        if (typeof m.content === 'string')
+            return m.content;
+        if (Array.isArray(m.content)) {
+            const parts = [];
+            for (const block of m.content) {
+                if (block?.type === 'text' && typeof block.text === 'string')
+                    parts.push(block.text);
+            }
+            return parts.join('\n\n');
+        }
+        return null;
+    }
+    return null;
+}

package/dist/repl/post-turn-status.js

@@ -9,11 +9,16 @@
  *   Ink mode     → chunkEmitter.emit('chunk', formatted) — Body's
  *                  <Static> commits the line to scrollback
  *
- * The sapStateStore push that used to drive a Header / Sidebar is
- * gone (no consumer). All status visibility now lives in the printed
- * status line that accompanies each turn — matches CC's pattern.
+ * The sapStateStore push that used to drive a Header / Sidebar was
+ * removed when the Header died (no consumer). UX Wave 1 Task 9 partially
+ * revives it: the Task 4 <StatusLine /> reads dollarSpendToday from the
+ * store, and this helper is the one chokepoint that already computes the
+ * session cost total after EVERY turn (both classic and Ink paths call
+ * it), so the spend wire lives here. The printed status line remains the
+ * primary per-turn status surface.
  */
 import { computeCost } from '../cost/pricing.js';
+import { globalStore } from '../ui/sap-state-store.js';
 import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
 import { shouldUseInk } from '../renderer/tty.js';
 export function snapshotTurnStart(session) {
@@ -26,7 +31,7 @@ export function snapshotTurnStart(session) {
     };
 }
 export function pushPostTurnStatus(params) {
-    const { session, selectedAlias, snapshot, chunkEmitter } = params;
+    const { session, selectedAlias, snapshot, chunkEmitter, turnModel } = params;
     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 lifetimeTokensBefore = snapshot.input + snapshot.output;
@@ -37,13 +42,21 @@ export function pushPostTurnStatus(params) {
         cacheRead: session.usage.cache_read_input_tokens - snapshot.cacheRead,
         cacheCreate: (session.usage.cache_creation_input_tokens ?? 0) - snapshot.cacheCreate,
     };
-    const turnCost = computeCost(session.model, turnCostTokens);
+    const turnCost = computeCost(turnModel ?? session.model, turnCostTokens);
     const sessionCost = computeCost(session.model, {
         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,
     });
+    // Task 9 (ux-wave1) — statusline spend wire. Honest semantics note: the
+    // store field is named `dollarSpendToday` (legacy sidebar naming, kept to
+    // avoid rename churn) but the value written is SESSION-scoped — the same
+    // sessionCost total shown in the printed status footer, computed from
+    // lifetime session.usage at session.model rates (mixed-model turns are an
+    // approximation, same caveat as the footer's session line). There is no
+    // day-spanning ledger; the statusline shows session spend.
+    globalStore.update({ dollarSpendToday: sessionCost });
     const statusPayload = {
         sessionId: session.id,
         sapAlias: selectedAlias,
@@ -60,7 +73,14 @@ export function pushPostTurnStatus(params) {
         // Push through chunkEmitter so the line lands in Body's <Static>
         // scrollback alongside the conversation, instead of corrupting
         // the live Ink frame.
-        chunkEmitter.emit('chunk', formatStatusFooter(statusPayload));
+        //
+        // Wave1 fast-follow — variant:'turn' slims the Ink receipt to
+        // turn-only facts (skill │ turns │ tok │ $ │ duration): the
+        // persistent <StatusLine /> already shows the alias and the session
+        // $ total, so the full receipt double-reported both after every
+        // turn. Classic mode (and the no-emitter fallback) keeps the full
+        // receipt — there is no statusline there.
+        chunkEmitter.emit('chunk', formatStatusFooter({ ...statusPayload, variant: 'turn' }));
     }
     else {
         printStatusFooter(statusPayload);

package/dist/repl/rule8-detector.js

@@ -82,10 +82,25 @@ export function renderPlanSummary(proposedNext) {
     return lines.join('\n');
 }
 function summarizeArgs(args) {
-    // Best-effort one-line summary. Pulls the most useful identifier fields:
-    // type+name, class_name+method_name, transport.
+    // Best-effort one-line summary. Pulls the most useful identifier fields so a
+    // customer reviewing the batch gate sees WHAT each op targets (Forge Rule 8
+    // is unauditable theatre otherwise):
+    //   - file_write / file_edit → the path
+    //   - shell_exec             → command + args (e.g. `npm run build`)
+    //   - SAP object writes       → type+name, class_name->method_name, transport
     const a = args;
     const parts = [];
+    // Local-FS writes (the fiori-build path: 13× file_write + 2× shell_exec) —
+    // the path / command is the only meaningful descriptor; surface it FIRST.
+    if (typeof a['path'] === 'string' && a['path']) {
+        parts.push(a['path']);
+    }
+    if (typeof a['command'] === 'string' && a['command']) {
+        const cmdArgs = Array.isArray(a['args'])
+            ? a['args'].filter((x) => typeof x === 'string').join(' ')
+            : '';
+        parts.push(cmdArgs ? `${a['command']} ${cmdArgs}` : a['command']);
+    }
     if (typeof a['type'] === 'string' && typeof a['name'] === 'string') {
         parts.push(`${a['type']} ${a['name']}`);
     }

package/dist/repl/safety-confirm.js

@@ -5,13 +5,21 @@
  * surface, every rule-triggering operation gets a card showing which rule
  * applies, what's about to happen, and what rollback is available.
  *
- * Pure orchestration over `@inquirer/prompts.confirm` — no I/O of its own
- * beyond the prompt invocation.
+ * Three presentation surfaces, decided per call (headless first):
+ *   - headless        → fail-fast decline, no prompt (B5)
+ *   - Ink             → askQuestionEmitter choice modal (UX-5 review I1) —
+ *                       inquirer must NEVER run under Ink: it fights the
+ *                       React frame for stdin and paints over it
+ *   - classic         → inquirer select via withInquirer (unchanged)
  */
 import chalk from 'chalk';
 import { select } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
+import { isHeadless, shouldUseInk } from '../renderer/tty.js';
+import { askQuestionEmitter } from '../ui/ask-question-emitter.js';
+import { clearActiveSpinner } from '../renderer/tool-widget.js';
+import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
 const RULE_LABEL = {
     RULE_7_SNAPSHOT_BEFORE_WRITE: 'RULE 7 — snapshot before write',
     RULE_7A_USE_UPDATE_METHOD: 'RULE 7a — use sap_update_method (not sap_set_source)',
@@ -21,7 +29,100 @@ const RULE_LABEL = {
     RULE_10_VERIFY_AFTER_WRITE: 'RULE 10 — verify after write',
 };
 export async function presentSafetyConfirmation(action) {
+    // B5 (2026-06-11) — headless fail-fast. This card is a stdin modal (the
+    // Rule 8 batch gate reaches it on the 2nd+ mutating call per turn even in
+    // one-shot, e.g. two local file writes); a headless run would hang on it
+    // forever. Headless runs NEVER auto-confirm safety gates — decline with a
+    // clear reason so the model can wrap up gracefully.
+    if (isHeadless()) {
+        console.error(chalk.red(`headless: ${RULE_LABEL[action.rule]} requires interactive confirmation — ` +
+            'declining (headless runs never auto-confirm safety gates; run interactively).'));
+        return {
+            confirmed: false,
+            reason: 'headless run cannot confirm safety gates — run interactively',
+            headless: true,
+        };
+    }
     const card = renderCard(action);
+    // UX-5 review I1 (2026-06-12) — Ink-native branch. /safety-mode on made
+    // this card reachable under Ink, where the raw inquirer select() below
+    // toggled raw mode out from under the React frame and painted over it.
+    // Mirror of renderPlanGate (approvals/render.ts): route through the
+    // askQuestionEmitter choice modal — one input system, no stdin handoff.
+    // The modal renders `context` itself in dimColor, so strip the chalk ANSI
+    // codes (they'd show as raw escape text). Same choice semantics as the
+    // classic path below: Apply/Cancel, plus the Rule 9 irreversibility ack.
+    // Esc / no listener resolve as cancelled → decline (safe default).
+    if (shouldUseInk()) {
+        // CRITICAL race fix (2026-06-13) — this gate fires from INSIDE
+        // dispatchTool, on the 2nd+ mutating op of a turn. For local-FS ops
+        // (file_write / shell_exec, the fiori-build path) the agent loop
+        // classifies the tool as NON-interactive: it starts the in-place tool
+        // spinner, a per-second labelled heartbeat, AND keeps the turn-status
+        // row ticking — none of which it pauses (only ask_question /
+        // request_approval get paused at the loop level). So when this modal
+        // opens, three render sources are still repainting the Ink frame
+        // underneath it. That produced the observed live bug: the RULE 8 card
+        // rendered DOUBLED, Enter was not consumed by the modal, the keystroke
+        // LEAKED to the outer prompt (history-replay of the slash command), and
+        // the turn wedged for ~10 minutes while the tool spinner kept ticking.
+        //
+        // The gate must claim exclusive input focus itself (it can't rely on the
+        // loop, which doesn't know a non-interactive tool is about to block on
+        // the user). Mirror what the loop does for interactive tools:
+        //   - clearActiveSpinner(): stop the live in-place tool spinner so only
+        //     ONE surface (this modal) renders.
+        //   - turnStatusEmitter.pause(): freeze the ticking status row so it
+        //     stops repainting the dynamic frame and overdrawing the modal.
+        // resume() in the finally restores normal rendering the moment the gate
+        // resolves. (The per-second heartbeat is loop-local and is stopped on
+        // the loop side by ordering the gate ahead of heartbeat start — see
+        // tool-dispatch.ts / loop.ts.)
+        clearActiveSpinner();
+        const statusWasActive = turnStatusEmitter.snapshot().active;
+        if (statusWasActive)
+            turnStatusEmitter.pause();
+        try {
+            const first = await askQuestionEmitter.request({
+                id: 'safety-confirm',
+                question: `⚠  ${RULE_LABEL[action.rule]}`,
+                context: stripAnsi(card).trim(),
+                kind: 'choice',
+                choices: [
+                    { value: 'apply', label: 'Apply' },
+                    { value: 'cancel', label: 'Cancel' },
+                ],
+            });
+            if (first.cancelled || first.answer !== 'apply') {
+                return { confirmed: false, reason: 'user declined first prompt' };
+            }
+            // RULE 9 transport-release is irreversible — require a second explicit ack.
+            if (action.rule === 'RULE_9_TRANSPORT_RELEASE') {
+                const second = await askQuestionEmitter.request({
+                    id: 'safety-confirm-irreversible',
+                    question: `IRREVERSIBLE — releasing ${action.transport} cannot be undone from this side. ` +
+                        `Are you absolutely sure?`,
+                    kind: 'choice',
+                    // Cancel first → the modal cursor starts there (mirrors the classic
+                    // path's `default: 'cancel'`).
+                    choices: [
+                        { value: 'cancel', label: 'Cancel' },
+                        { value: 'release', label: 'Release transport' },
+                    ],
+                });
+                if (second.cancelled || second.answer !== 'release') {
+                    return { confirmed: false, reason: 'user declined irreversibility ack' };
+                }
+            }
+            return { confirmed: true };
+        }
+        finally {
+            // Restore normal rendering. resume() is a no-op if the turn already
+            // ended (e.g. the user Ctrl+C'd mid-modal) or was never paused.
+            if (statusWasActive)
+                turnStatusEmitter.resume();
+        }
+    }
     // 2026-05-01: switched from confirm() to select() to fix the "press Enter
     // first, then 'y'" race observed in dispatched-tool rule-8 prompts. confirm
     // has a brief window after rendering its multi-line message before raw
@@ -60,6 +161,14 @@ export async function presentSafetyConfirmation(action) {
     }
     return { confirmed: true };
 }
+/**
+ * Strip chalk ANSI escape codes. The Ink ask-question modal renders the
+ * card via its own <Text dimColor> — embedded escapes would display as
+ * literal `[33m` noise there. (Same approach as renderPlanGate.)
+ */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
 /**
  * Minimal indented summary block — replaces the chunky ASCII-art box.
  * Renders as:

package/dist/repl/safety-mode-state.js

@@ -1,7 +1,9 @@
 /**
- * Module-scope state for the safety-confirm-as-mode toggle. The REPL turns
- * this on via `--safety-confirm` flag at start, or `/safety-mode on|off` at
- * runtime. Tool dispatchers that hit a Forge Rule (snapshot, write, batch,
+ * Module-scope state for the safety-confirm-as-mode toggle. Off by default;
+ * the user turns it on with the `/safety-mode on` slash command at runtime
+ * (M3, 2026-06-12: there is no startup flag — an earlier version of this
+ * header claimed a `--safety-confirm` flag that was never implemented).
+ * Tool dispatchers that hit a Forge Rule (snapshot, write, batch,
  * transport release, activation) read isSafetyConfirmEnabled() and choose
  * presentSafetyConfirmation() vs the legacy ad-hoc inquirer prompt.
  *
@@ -34,3 +36,17 @@ export function handleSafetyModeCommand(args) {
     }
     return `Safety-confirm mode is currently ${enabled ? 'ON' : 'OFF'}. Use \`/safety-mode on\` or \`/safety-mode off\`.`;
 }
+/**
+ * REPL slash-dispatch entry. Returns the status string when `trimmed` is a
+ * `/safety-mode` command (bare or with args), or null when the line is not
+ * a /safety-mode command at all. Both REPL paths (Ink handleSubmit and the
+ * classic readline loop) route through this single matcher so the command
+ * behaves identically everywhere — mirrors how /transport dispatches via
+ * handleTransportCommand.
+ */
+export function matchSafetyModeCommand(trimmed) {
+    if (trimmed !== '/safety-mode' && !trimmed.startsWith('/safety-mode '))
+        return null;
+    const args = trimmed === '/safety-mode' ? '' : trimmed.slice('/safety-mode '.length);
+    return handleSafetyModeCommand(args);
+}

package/dist/repl/slash-completer.js

@@ -22,12 +22,17 @@ const BUILTIN_COMMANDS = [
     '/cancel',
     '/compact',
     '/cost',
+    '/context',
+    '/export',
     '/exit',
     '/quit',
     '/help',
     '/skills',
+    '/mode',
     '/new',
+    '/recap',
     '/reset',
+    '/rewind',
     '/ui',
     '/reroute',
     '/transport',

package/dist/repl/slash-picker.js

@@ -21,21 +21,10 @@
 import { search } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
-import { SKILL_CATALOG } from '../skill-catalog.js';
-const BUILTIN_ENTRIES = [
-    { name: '/cancel', description: 'Cancel the current pre-filled command, return to a clean prompt' },
-    { name: '/cost', description: 'Show this session\'s API spend so far ($ + token breakdown)' },
-    { name: '/compact', description: 'Summarise older turns into a compact context block — cuts subsequent turn cost by 80-90%' },
-    { name: '/exit', description: 'Exit CSPeach' },
-    { name: '/quit', description: 'Exit CSPeach (alias)' },
-    { name: '/help', description: 'Show all skills and commands' },
-    { name: '/skills', description: 'Show all skills (alias)' },
-    { name: '/new', description: 'Reset routing — next prompt is classified afresh' },
-    { name: '/reset', description: 'Reset routing (alias)' },
-    { name: '/ui', description: 'View or change rendering mode (auto / ink / classic)' },
-    { name: '/reroute', description: 'Re-dispatch the previous prompt to a different skill' },
-    { name: '/transport', description: 'View or set the active transport for this session' },
-];
+import { SKILL_CATALOG, SKILL_ALIASES } from '../skill-catalog.js';
+// 2026-06-11 — builtin list extracted to builtin-commands.ts (pure data)
+// so the router layer can check builtin heads without importing inquirer.
+import { BUILTIN_ENTRIES } from './builtin-commands.js';
 function buildCatalogue() {
     const skillEntries = SKILL_CATALOG.map((s) => ({
         name: `/${s.name}`,
@@ -133,5 +122,11 @@ export function isExactSlashMatch(trimmed) {
     if (!trimmed.startsWith('/'))
         return false;
     const head = trimmed.split(/\s+/, 1)[0].toLowerCase();
+    // Retired-but-redirected names (SKILL_ALIASES) count as exact so the
+    // line passes through to parseShortcut, which resolves the redirect and
+    // emits the "renamed" notice — instead of dumping the user into the
+    // picker. Aliases are deliberately NOT in the picker/completer lists.
+    if (head.startsWith('/') && head.slice(1) in SKILL_ALIASES)
+        return true;
     return ALL_ENTRIES.some((e) => e.name === head);
 }