@cspeach/cli 1.0.0 → 1.1.1

package/dist/repl/current-transport.js

@@ -14,16 +14,26 @@
  *
  * Module-scope singleton per CLI process. Tests must call clearCurrentTransport()
  * in beforeEach to avoid leakage across Vitest test files.
+ *
+ * Task 9 (ux-wave1) — this setter is ALSO the single statusline wire for the
+ * `tr <TRKORR>` segment: every path that changes the session transport
+ * (sap_transport create success, owning-transport adoption in the create
+ * guard, /transport slash command) funnels through set/clear here, so the
+ * globalStore push lives HERE rather than scattered across tool handlers.
+ * Store writes are harmless in classic mode (nothing subscribes there).
  */
+import { globalStore } from '../ui/sap-state-store.js';
 let currentTransport = null;
 export function setCurrentTransport(trkorr) {
     currentTransport = trkorr;
+    globalStore.update({ transport: trkorr });
 }
 export function getCurrentTransport() {
     return currentTransport;
 }
 export function clearCurrentTransport() {
     currentTransport = null;
+    globalStore.update({ transport: null });
 }
 /**
  * Handles the `/transport [<trkorr>|clear]` slash command. Returns user-facing

package/dist/repl/history.js

@@ -0,0 +1,86 @@
+/**
+ * Persistent REPL history — the ONE writer shared by every append site:
+ *  - classic readline path (repl.tsx)
+ *  - Ink handleSubmit (repl.tsx)
+ *  - Ink Footer (ui/footer.tsx)
+ *
+ * File shape: `~/.cspeach/history`, one entry per line, chronological
+ * (oldest at top, newest at bottom), appended on every submit; capped at
+ * READ time (HISTORY_SIZE in repl.tsx), not write time.
+ *
+ * Task 8 (ux-wave1) — consecutive-duplicate dedup lives HERE so all
+ * append sites share a single guard (CC parity: bash
+ * HISTCONTROL=ignoredups). `x, y, x` stores three entries — only
+ * back-to-back repeats collapse, never across gaps. Comparison is on the
+ * flattened + trimmed entry, against the file tail — so it also holds
+ * across session restarts, AND it collapses the Ink path's historical
+ * double append (Footer wrote the entry, then repl.tsx's handleSubmit
+ * wrote the same submission again — unflattened).
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+// Resolved lazily (not at module load) so it honours the HOME/USERPROFILE
+// active at call time — lets tests point it at a temp dir.
+export function historyFile() {
+    return path.join(os.homedir(), '.cspeach', 'history');
+}
+/** All persisted entries, oldest → newest, trimmed, blank lines dropped. */
+export function readHistoryEntries() {
+    try {
+        return fs
+            .readFileSync(historyFile(), 'utf-8')
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Flatten a submission into a single history-file entry: `\r\n` becomes
+ * ONE space, then every remaining C0 control + DEL becomes a space.
+ *
+ * Wave1 fast-follow (tab-flatten): newlines were already flattened, but
+ * tabs (e.g. from a pasted tab-indented ABAP snippet) survived into the
+ * history file. A tab-bearing entry later rendered in the Ctrl+R fuzzy
+ * list dodges Ink's truncate-end — widestLine/string-width measure `\t`
+ * as 0 cells while the terminal renders up to 8 — re-opening the exact
+ * wrapped-row erase-accounting leak Bug 1 fixed (see text-input.tsx
+ * maxDisplayWidth doc). Flattening at WRITE time keeps new entries clean;
+ * the fuzzy-row render flattens too, covering pre-fix history files.
+ */
+export function flattenHistoryEntry(line) {
+    // eslint-disable-next-line no-control-regex
+    return line.replace(/\r\n/g, ' ').replace(/[\x00-\x1f\x7f]/g, ' ').trim();
+}
+/**
+ * Append one entry to the history file.
+ *  - Submissions are flattened (newlines, tabs, and all other C0
+ *    controls → ' ') — the file is one-entry-per-line (Task 7 contract)
+ *    and entries must never carry width-invisible controls (tab-flatten
+ *    fast-follow; see flattenHistoryEntry).
+ *  - Skips when the flattened + trimmed entry equals the file's LAST
+ *    entry (consecutive dedup — trimmed comparison).
+ *  - Never throws: history persistence failure must not crash the REPL.
+ *
+ * @returns true when the entry was written, false when skipped.
+ */
+export function appendHistoryEntry(line) {
+    const entry = flattenHistoryEntry(line);
+    if (!entry)
+        return false;
+    try {
+        const entries = readHistoryEntries();
+        if (entries.length > 0 && entries[entries.length - 1] === entry)
+            return false;
+        const file = historyFile();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, entry + '\n', 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/repl/ink-stdin-guard.js

@@ -0,0 +1,64 @@
+/**
+ * InkStdinPasteGuard — bracketed-paste interception for the INK path
+ * (wave1 live-fix, Bug 2: multiline paste submitted line-by-line on real
+ * Windows Terminal).
+ *
+ * What the live test proved (and Task 7's assumption it disproved):
+ * Windows Terminal does NOT deliver a paste as one big chunk with
+ * embedded newlines — pasted newlines arrive as `\r`, and a `\r` can
+ * land as its OWN stdin chunk. Ink's parseKeypress flags a chunk that is
+ * exactly '\r' as key.return (ink/build/parse-keypress.js:145-148), so
+ * every pasted line submitted immediately — the garbled multi-dispatch
+ * the user saw.
+ *
+ * Why the interception must happen BEFORE Ink parses:
+ *  - With DEC 2004 enabled the paste arrives as `\x1b[200~ … \x1b[201~`,
+ *    but Ink's parser mangles the markers: parse-keypress' fnKeyRe
+ *    matches `\x1b[200~` with code '[200~' → name undefined, and
+ *    use-input.js:73-75 strips the leading ESC from the sequence, so the
+ *    marker would land in the input as literal garbage text ("[200~…").
+ *    There is no reliable way to reassemble a marker split across chunks
+ *    from inside useInput.
+ *  - The reliable seam is the stdin stream itself: Ink accepts a custom
+ *    `stdin` in its render options and touches exactly this surface on
+ *    it (ink/build/components/App.js:104-139): `isTTY`, `setEncoding`,
+ *    `ref`/`unref`, `setRawMode`, `addListener('readable')` + `read()`.
+ *    A Transform (Duplex) provides the readable side natively; the four
+ *    TTY-ish members are shimmed here, forwarding to process.stdin.
+ *
+ * Wiring (repl.tsx Ink branch): enableBracketedPaste() →
+ * `process.stdin.pipe(guard)` → `render(…, { stdin: guard })`. The base
+ * class (BracketedPasteDecoder with emitVerbatim) strips the markers,
+ * accumulates the whole span — including any `\r`-only chunks inside it —
+ * and re-emits the paste as ONE chunk with newlines preserved. Ink then
+ * hands that single chunk unsplit to useInput, where text-input's Task-7
+ * paste branch buffers complete lines via onPasteLines and keeps the
+ * tail fragment. NOTHING can submit mid-paste because no `\r`-only chunk
+ * ever reaches parseKeypress between the markers.
+ *
+ * Terminals without bracketed-paste support simply never send markers:
+ * the guard is pass-through and behaviour is exactly the pre-fix Task 7
+ * path (no regression, same as the classic-mode caveat).
+ */
+import { BracketedPasteDecoder } from './bracketed-paste.js';
+export class InkStdinPasteGuard extends BracketedPasteDecoder {
+    /**
+     * Mirror the REAL stdin's TTY-ness (the base class hardcodes true for
+     * readline's sake). Ink gates isRawModeSupported on this — lying about
+     * a non-TTY stdin would make Ink call setRawMode on a pipe.
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    isTTY = process.stdin.isTTY ?? false;
+    constructor() {
+        super({ emitVerbatim: true });
+    }
+    /** Ink calls stdin.ref()/unref() around raw-mode enable/disable. */
+    ref() {
+        process.stdin.ref?.();
+        return this;
+    }
+    unref() {
+        process.stdin.unref?.();
+        return this;
+    }
+}

package/dist/repl/mode-ceiling.js

@@ -0,0 +1,16 @@
+/** Ordered from most to least restricted. */
+export const WRITE_MODE_ORDER = ['advisory-only', 'approval-gated', 'auto'];
+const ROLE_CEILING = {
+    dev: 'auto',
+    qas: 'approval-gated',
+    prd: 'advisory-only',
+};
+/** The most permissive write mode a system role allows. */
+export function modeCeiling(role) {
+    return role === undefined ? 'auto' : ROLE_CEILING[role];
+}
+/** Clamp a mode to the role's ceiling. */
+export function clampToCeiling(mode, role) {
+    const ceiling = modeCeiling(role);
+    return WRITE_MODE_ORDER.indexOf(mode) <= WRITE_MODE_ORDER.indexOf(ceiling) ? mode : ceiling;
+}

package/dist/repl/mode-cycle.js

@@ -0,0 +1,104 @@
+import { clampToCeiling, modeCeiling, WRITE_MODE_ORDER, } from './mode-ceiling.js';
+/**
+ * Session-scoped effective write mode + cycling core (UX Wave 1, Task 2).
+ *
+ * The config's `write_mode` is the durable setting; this module layers a
+ * SESSION override on top (Shift+Tab-style cycling, lost on exit) and clamps
+ * the result to the active system role's ceiling (mode-ceiling.ts):
+ *
+ *   effective = clamp(sessionOverride ?? configMode, roleCeiling)
+ *
+ * Cycling walks WRITE_MODE_ORDER restricted to the modes the role allows:
+ *   dev / unset → advisory → gated → auto → advisory …
+ *   qas         → advisory → gated → advisory …   (auto not in the cycle — a
+ *                                                  gated→advisory step is a
+ *                                                  WRAP, not a cap)
+ *   prd         → pinned at advisory-only; a cycle attempt reports
+ *                 `capped: true` so the caller can render the refusal line.
+ *
+ * Pure module — no I/O, no config access; callers pass config mode + role in.
+ * Module-level state is test-resettable via `setSessionWriteMode(null)`.
+ */
+let sessionWriteMode = null;
+/** Session override; null = follow config. Module-level, test-resettable. */
+export function setSessionWriteMode(mode) {
+    sessionWriteMode = mode;
+}
+export function getSessionWriteMode() {
+    return sessionWriteMode;
+}
+/** cfgMode overlaid by session override, then clamped to the alias role's ceiling. */
+export function getEffectiveWriteMode(cfgMode, role) {
+    return clampToCeiling(sessionWriteMode ?? cfgMode, role);
+}
+/**
+ * Cycle to the next mode the role allows (wraps). Sets the session override
+ * so the new mode takes effect immediately. Returns the new mode AND whether
+ * the requested step was capped (for the refusal line).
+ */
+export function cycleWriteMode(cfgMode, role) {
+    const ceilingIdx = WRITE_MODE_ORDER.indexOf(modeCeiling(role));
+    // Modes at or below the ceiling, in cycling order (most→least restricted).
+    const allowed = WRITE_MODE_ORDER.slice(0, ceilingIdx + 1);
+    if (allowed.length === 1) {
+        // prd: pinned — there is nowhere to step. Report capped for the refusal line.
+        setSessionWriteMode(allowed[0]);
+        return { mode: allowed[0], capped: true };
+    }
+    const current = getEffectiveWriteMode(cfgMode, role);
+    const next = allowed[(allowed.indexOf(current) + 1) % allowed.length];
+    setSessionWriteMode(next);
+    return { mode: next, capped: false };
+}
+/** Short /mode arguments → WriteMode. */
+const MODE_ARGS = {
+    advisory: 'advisory-only',
+    gated: 'approval-gated',
+    auto: 'auto',
+};
+function announceLine(prev, next) {
+    return `mode: ${prev} → ${next} (session only — config unchanged)`;
+}
+function refusalLine(clamped, role, alias) {
+    return `mode capped at ${clamped} — sap.${alias ?? '?'}.role = ${role} (policy)`;
+}
+/**
+ * /mode command core (UX Wave 1, Task 3). Pure apart from the session
+ * override it shares with cycleWriteMode — the REPL builtin and the
+ * Shift+Tab / Alt+M keybindings are thin shells over this.
+ *
+ *   - bare / empty arg      → cycle (wraps within the role's allowed modes)
+ *   - 'advisory'|'gated'|'auto' → jump directly (still clamped to the ceiling;
+ *                             a jump above it returns the refusal line and
+ *                             the clamped mode)
+ *   - anything else         → usage line, mode untouched
+ *
+ * Returns the line to print (caller dims it) and the resulting effective
+ * mode (caller pushes it into the SapStateStore so the statusline is live).
+ */
+export function runModeCommand(arg, cfgMode, role, alias) {
+    const prev = getEffectiveWriteMode(cfgMode, role);
+    const normalized = arg?.trim().toLowerCase() ?? '';
+    if (normalized === '') {
+        const { mode, capped } = cycleWriteMode(cfgMode, role);
+        // capped is only ever true with a prd role, so `role!` is safe here.
+        if (capped)
+            return { line: refusalLine(mode, role, alias), mode };
+        return { line: announceLine(prev, mode), mode };
+    }
+    const target = MODE_ARGS[normalized];
+    if (target === undefined) {
+        return {
+            line: `usage: /mode [advisory|gated|auto] — bare /mode cycles (current: ${prev})`,
+            mode: prev,
+        };
+    }
+    const clamped = clampToCeiling(target, role);
+    setSessionWriteMode(clamped);
+    if (clamped !== target) {
+        // Jump above the ceiling — clamp landed us lower than requested. `role!`
+        // is safe: without a role the ceiling is 'auto' and nothing clamps.
+        return { line: refusalLine(clamped, role, alias), mode: clamped };
+    }
+    return { line: announceLine(prev, clamped), mode: clamped };
+}

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) {
@@ -44,6 +49,14 @@ export function pushPostTurnStatus(params) {
         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/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',