@cspeach/cli 0.8.0 → 1.0.0

package/dist/repl/at-picker.js

@@ -17,11 +17,83 @@
  * without screen takeover, Enter when they want a full search-as-you-type
  * picker. Same backing data, different UI.
  */
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { search } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
-import { ensureWorkspaceSync, listProjectFilesSync } from '../projects/workspace.js';
+import { ensureWorkspaceSync, listProjectFilesSync, isAttachableFilename } from '../projects/workspace.js';
 const CANCEL_VALUE = '__cspeach_cancel__';
+/**
+ * 2026-06-06 (Ink picker parity): workspace listing + substring filter,
+ * exported so the Ink FilePalette shares the same data + seeding
+ * semantics as this classic inquirer picker.
+ *
+ * Bug #4 (2026-06-15): the listing is the UNION of
+ *   - all workspace files (.cspeach.json envelopes + .txt/.md/.docx/.pdf), AND
+ *   - top-level .txt/.md/.docx/.pdf files in the current working directory.
+ * A spec file dropped next to the project (the common case) lives in the
+ * cwd, never in .cspeach/, so without the cwd half the picker was empty.
+ *
+ * Deduped by filename — when a name exists in both, the workspace entry
+ * wins. Non-recursive over the cwd; the .cspeach subfolder and any
+ * dotfiles/dirs are skipped. SYNCHRONOUS by contract (the Ink palette and
+ * pendingAtTokenPrefix call it sync). `cwd` / `workspace` are injectable
+ * for tests; the zero-arg call resolves both from the environment.
+ */
+export function listWorkspaceFileChoices(opts) {
+    const out = [];
+    const seen = new Set();
+    // Workspace half (takes precedence on name collisions).
+    try {
+        const ws = opts?.workspace ?? ensureWorkspaceSync();
+        for (const f of listProjectFilesSync(ws)) {
+            if (seen.has(f.filename))
+                continue;
+            seen.add(f.filename);
+            out.push({ filename: f.filename, mtimeMs: f.mtimeMs });
+        }
+    }
+    catch {
+        // fall through — still return whatever the cwd half yields
+    }
+    // cwd half — top-level .txt/.md/.docx/.pdf only. Never throws.
+    const cwd = opts?.cwd ?? process.cwd();
+    try {
+        for (const name of readdirSync(cwd)) {
+            if (name.startsWith('.'))
+                continue; // dotfiles/dirs (incl. .cspeach)
+            if (!isAttachableFilename(name))
+                continue;
+            if (seen.has(name))
+                continue; // workspace already has it
+            const full = join(cwd, name);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            seen.add(name);
+            out.push({ filename: name, mtimeMs: stat.mtimeMs });
+        }
+    }
+    catch {
+        // unreadable cwd — return just the workspace list
+    }
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return out;
+}
+/** Substring filter; empty prefix returns everything. */
+export function filterFileChoices(prefix, all) {
+    const lower = prefix.trim().toLowerCase();
+    return lower.length === 0
+        ? [...all]
+        : all.filter((f) => f.filename.toLowerCase().includes(lower));
+}
 /**
  * Open the at-picker pre-filtered to `prefix`. Returns the picked
  * filename (no leading @), or null on cancel / empty-workspace.
@@ -31,21 +103,11 @@ const CANCEL_VALUE = '__cspeach_cancel__';
  * (bare `@`) seeds the picker with all workspace files.
  */
 export async function openAtPicker(prefix) {
-    let allFiles;
-    try {
-        const ws = ensureWorkspaceSync();
-        allFiles = listProjectFilesSync(ws).map((f) => ({ filename: f.filename, mtimeMs: f.mtimeMs }));
-    }
-    catch {
-        allFiles = [];
-    }
+    const allFiles = listWorkspaceFileChoices();
     if (allFiles.length === 0) {
         return null;
     }
-    const lowerPrefix = prefix.trim().toLowerCase();
-    const seeded = lowerPrefix.length === 0
-        ? allFiles
-        : allFiles.filter((f) => f.filename.toLowerCase().includes(lowerPrefix));
+    const seeded = filterFileChoices(prefix, allFiles);
     // Single unique match — short-circuit, save the user a keystroke. Same
     // shortcut openSlashPicker uses.
     if (seeded.length === 1) {
@@ -95,7 +157,7 @@ export async function openAtPicker(prefix) {
  * null when the line doesn't end with an @-token or the token already
  * resolves exactly.
  */
-export function pendingAtTokenPrefix(trimmed) {
+export function pendingAtTokenPrefix(trimmed, knownFilenames) {
     // Match the rightmost @<word> at the end of the line. \S+ means
     // non-whitespace only — `@filename with space` is not auto-detected
     // (user can quote with `@"name with space"` for those, handled by
@@ -106,16 +168,26 @@ export function pendingAtTokenPrefix(trimmed) {
     const prefix = m[1] ?? '';
     // If the prefix already exactly matches a workspace filename, the
     // existing @-resolution will pick it up — don't open the picker.
+    // `knownFilenames` lets callers (Ink pipeline, tests) inject the
+    // listing instead of hitting the filesystem here.
     if (prefix.length > 0) {
-        try {
-            const ws = ensureWorkspaceSync();
-            const files = listProjectFilesSync(ws);
-            const exact = files.some((f) => f.filename === prefix);
-            if (exact)
+        if (knownFilenames) {
+            if (knownFilenames.includes(prefix))
                 return null;
         }
-        catch {
-            // Fall through — open picker as a safe default.
+        else {
+            try {
+                // Bug #4: check the MERGED listing (workspace + cwd text files),
+                // not workspace-only, so an exact `@spec.txt` for a cwd file
+                // submits directly instead of re-opening the picker.
+                const files = listWorkspaceFileChoices();
+                const exact = files.some((f) => f.filename === prefix);
+                if (exact)
+                    return null;
+            }
+            catch {
+                // Fall through — open picker as a safe default.
+            }
         }
     }
     return prefix;

package/dist/repl/builtin-commands.js

@@ -0,0 +1,37 @@
+/**
+ * Built-in (non-skill) slash commands — the single source of truth.
+ *
+ * Extracted from slash-picker.ts (2026-06-11) so the router layer
+ * (src/router/classifier.ts) can distinguish "user typed a builtin with
+ * arguments" (e.g. `/help me`) from "user typed an unknown skill"
+ * WITHOUT importing the inquirer-backed picker module. Pure data — no
+ * runtime dependencies.
+ */
+export 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' },
+    { name: '/safety-mode', description: 'Toggle structured Forge Rule confirmation cards (on / off / status)' },
+];
+/**
+ * Builtin command heads for routing checks. Superset of BUILTIN_ENTRIES:
+ * `/files` is a real REPL builtin (repl.tsx handles it in both paths) but
+ * is deliberately absent from the picker catalogue, so it's added here.
+ */
+const BUILTIN_HEADS = new Set([
+    ...BUILTIN_ENTRIES.map((e) => e.name),
+    '/files',
+]);
+/** True when `head` (e.g. '/help', as typed, any case) is a builtin command. */
+export function isBuiltinCommandHead(head) {
+    return BUILTIN_HEADS.has(head.toLowerCase());
+}

package/dist/repl/early-line-buffer.js

@@ -0,0 +1,68 @@
+/**
+ * Early-line buffer for piped-stdin REPL runs — UX-5 #5 (2026-06-12).
+ *
+ * The bug (found 2026-06-11): lines piped into the classic REPL
+ * (`"/cost`n/exit" | cspeach`) arrive on the readline BEFORE the loop's
+ * first rl.question() is pending. Node's readline only routes a line to a
+ * question callback when one is registered; otherwise it emits the 'line'
+ * EVENT — which nobody consumed, so every early line was silently dropped
+ * (even /cost never dispatched). stdin EOF then closed the readline and
+ * the old 'close' handler hard-exited. This blocked CI-driven multi-phase
+ * plan runs entirely.
+ *
+ * Fix shape:
+ *   - attach a 'line' listener at readline creation that QUEUES lines
+ *     arriving while no question is pending (readline emits 'line' only
+ *     in that case — a pending question consumes the line directly);
+ *   - the REPL loop drains this queue before calling rl.question;
+ *   - on stdin EOF ('close') the buffer flips `closed` and the loop keeps
+ *     processing queued lines before exiting (the repl.tsx close handler
+ *     no longer hard-exits in piped mode);
+ *   - the FIRST piped line gets a UTF-8 BOM strip — PowerShell pipes
+ *     inject one, which used to corrupt the first command head.
+ *
+ * Only attached when stdin is NOT a TTY (see repl.tsx): in interactive
+ * mode, type-ahead during a turn should keep its existing
+ * behaviour rather than silently becoming queued commands.
+ */
+/** Strip a single leading UTF-8 BOM (PowerShell pipes inject one). */
+export function stripBom(s) {
+    return s.charCodeAt(0) === 0xfeff ? s.slice(1) : s;
+}
+/**
+ * Attach the queueing listeners to `rl` and return the buffer handle.
+ * Call once, immediately after readline creation, BEFORE any awaits —
+ * piped data starts flowing on the next tick.
+ */
+export function attachEarlyLineBuffer(rl) {
+    const queue = [];
+    let firstLine = true;
+    let isClosed = false;
+    rl.on('line', (l) => {
+        let line = String(l);
+        if (firstLine) {
+            line = stripBom(line);
+            firstLine = false;
+        }
+        queue.push(line);
+    });
+    rl.on('close', () => {
+        isClosed = true;
+    });
+    return {
+        size: () => queue.length,
+        shift: () => queue.shift(),
+        closed: () => isClosed,
+    };
+}
+/**
+ * Inert buffer for interactive (TTY) runs — keeps the repl.tsx loop free
+ * of `isTTY` branches at every drain site.
+ */
+export function noopEarlyLineBuffer() {
+    return {
+        size: () => 0,
+        shift: () => undefined,
+        closed: () => false,
+    };
+}

package/dist/repl/inquirer-guard.js

@@ -28,6 +28,50 @@
  */
 import { clearActiveSpinner } from '../renderer/tool-widget.js';
 let state = null;
+/**
+ * UX-5 #4 (2026-06-12) — sequence-scoped (debounced) release.
+ *
+ * Failure mode this fixes: between BACK-TO-BACK inquirer prompts fired by
+ * the SAME handler (safety-confirm's two-step select, ask_question's
+ * select → custom-input follow-up, /files step 1 → step 2), the old
+ * per-prompt release resumed the outer readline the instant prompt N
+ * finished — readline repainted its prompt with a stale history/buffer
+ * entry for a frame — and then prompt N+1 paused it again. The user saw
+ * the old line flash between the two pickers.
+ *
+ * Scope note (M1, 2026-06-12): consecutive ask_question TOOL calls are
+ * separated by a full LLM round-trip (seconds apart) — the 50ms debounce
+ * neither covers nor needs to cover those; readline legitimately resumes
+ * between turns. The debounce only spans same-handler prompt sequences.
+ *
+ * Fix shape: the release (rl.resume + suppress-clear) is DEFERRED by
+ * RELEASE_DEBOUNCE_MS. If another withInquirer starts inside that window
+ * (an ask SEQUENCE), the pending release is cancelled and the outer
+ * prompt stays parked across the whole sequence — no repaint between
+ * prompts. Only the final prompt's release actually fires.
+ *
+ * Note: this is a CLASSIC-path concern only. Under Ink, ask_question /
+ * approval render through the Ink-native emitter modals (see
+ * tools/ask-question.ts shouldUseInk branch) and registerReadline is
+ * never called, so withInquirer is a pass-through there.
+ *
+ * The suppress flag intentionally stays TRUE during the debounce window —
+ * any spurious 'close' inquirer emits on release is still swallowed,
+ * which is strictly safer than the old nextTick clearing.
+ */
+// 50ms (M4 rationale): covers same-tick and next-macrotask prompt chaining
+// with ~3 frames of margin (one terminal frame ≈ 16ms) while staying far
+// below human-perceptible delay before the outer prompt repaints.
+export const RELEASE_DEBOUNCE_MS = 50;
+let pendingRelease = null;
+/** Re-entrancy depth — release is scheduled only when the OUTERMOST call exits. */
+let activeDepth = 0;
+function cancelPendingRelease() {
+    if (pendingRelease) {
+        clearTimeout(pendingRelease);
+        pendingRelease = null;
+    }
+}
 /**
  * Called by repl.tsx once the main readline is created. The `setSuppress`
  * callback must flip the same boolean the readline 'close' handler
@@ -38,6 +82,8 @@ export function registerReadline(rl, setSuppress) {
 }
 /** Clear the guard — call when the REPL is shutting down. */
 export function unregisterReadline() {
+    cancelPendingRelease();
+    activeDepth = 0;
     state = null;
 }
 /**
@@ -66,6 +112,12 @@ export async function withInquirer(fn) {
     // which collides with inquirer's prompt rendering — visible as ghost-text
     // and a cursor that hides under the rotating frame while the user types.
     clearActiveSpinner();
+    // UX-5 #4 — continuing an ask SEQUENCE: a release from the previous
+    // prompt is still pending, so cancel it. The readline stays parked
+    // (paused + close-suppressed) across the gap — no stale-line repaint
+    // between consecutive prompts.
+    cancelPendingRelease();
+    activeDepth++;
     // 2026-05-08: snapshot stdin 'data' / 'keypress' listeners BEFORE the
     // inquirer prompt runs. Some inquirer widgets (notably `search`, used
     // by /files step 1) strip ALL listeners on cleanup — including
@@ -120,11 +172,24 @@ export async function withInquirer(fn) {
         // Order matters here:
         //  1. resume stdin so the event loop stays referenced (otherwise the
         //     next rl.question prints its prompt and the process exits).
-        //  2. resume the readline so it accepts new input.
-        //  3. defer the suppress-clear so the spurious 'close' that inquirer
-        //     synchronously emits on release is still ignored.
+        //  2. SCHEDULE the readline resume + suppress-clear instead of doing
+        //     them inline (UX-5 #4). If another inquirer prompt opens within
+        //     RELEASE_DEBOUNCE_MS — an ask sequence — the entry above cancels
+        //     this timer and the outer readline never repaints between
+        //     prompts. The timer is deliberately NOT unref'd: it must hold
+        //     the event loop open across the gap.
+        //  3. inside the deferred release, still defer the suppress-clear by
+        //     one tick so the spurious 'close' that inquirer synchronously
+        //     emits on release is ignored.
         process.stdin.resume();
-        rl.resume();
-        process.nextTick(() => setSuppress(false));
+        activeDepth = Math.max(0, activeDepth - 1);
+        if (activeDepth === 0) {
+            cancelPendingRelease();
+            pendingRelease = setTimeout(() => {
+                pendingRelease = null;
+                rl.resume();
+                process.nextTick(() => setSuppress(false));
+            }, RELEASE_DEBOUNCE_MS);
+        }
     }
 }

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

@@ -26,7 +26,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,7 +37,7 @@ 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,

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']}`);
     }