@cspeach/cli 0.6.5 → 0.7.0

package/dist/cost/cost-log.js

@@ -0,0 +1,113 @@
+/**
+ * Per-turn cost log — Phase 1 (2026-05-16).
+ *
+ * Appends one JSONL line per turn to `~/.cspeach/sessions/<id>-cost.jsonl`
+ * with the model, all four token counters, and the computed $ cost. This
+ * is the persistent audit trail that lets us (a) show a session breakdown
+ * on demand via the `/cost` slash command and (b) analyse real usage
+ * offline (jq, pandas, whatever) to argue Phase 2 model-tiering from data.
+ *
+ * Failures are swallowed best-effort. A disk error must NOT crash a turn —
+ * the worst case is the user loses the per-turn line for that single turn,
+ * which is recoverable from session.usage at session-end if needed.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sessionsDir } from '../config/paths.js';
+import { computeCost } from './pricing.js';
+/**
+ * Path to a session's cost log file. Co-located with the session JSON so
+ * deletion cleans up both atomically.
+ */
+export function costLogPath(sessionId) {
+    return path.join(sessionsDir(), `${sessionId}-cost.jsonl`);
+}
+/**
+ * Build a CostLogEntry from raw counters. Caller can either pass this to
+ * `appendCostLine` or accumulate in memory for the `/cost` command.
+ */
+export function buildEntry(opts) {
+    return {
+        ts: new Date().toISOString(),
+        turn: opts.turn,
+        model: opts.model,
+        tokens: opts.tokens,
+        cost: computeCost(opts.model, opts.tokens),
+        duration_ms: opts.duration_ms,
+    };
+}
+/**
+ * Append a single line to the session's cost log. Best-effort:
+ * - Creates the parent dir if missing
+ * - Returns silently on any IO error (the log is observability, not a hard
+ *   dependency of the turn)
+ */
+export async function appendCostLine(sessionId, entry) {
+    try {
+        const filePath = costLogPath(sessionId);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        const line = JSON.stringify(entry) + '\n';
+        await fs.appendFile(filePath, line, 'utf-8');
+    }
+    catch {
+        // Swallow — cost-log failures must not crash a turn. The status footer
+        // still shows the in-memory cost for the current turn; only the
+        // persisted history is lost.
+    }
+}
+/**
+ * Read all entries for a session. Used by the `/cost` slash command.
+ * Tolerates a missing file (returns []) and skips malformed lines.
+ */
+export async function readCostLog(sessionId) {
+    try {
+        const filePath = costLogPath(sessionId);
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const out = [];
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                out.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Skip malformed line — partial write or manual edit, don't crash
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export function summarise(entries) {
+    const totals = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+    let total = 0;
+    const perModel = new Map();
+    for (const e of entries) {
+        total += e.cost;
+        totals.input += e.tokens.input;
+        totals.output += e.tokens.output;
+        totals.cacheRead += e.tokens.cacheRead;
+        totals.cacheCreate += e.tokens.cacheCreate;
+        const slot = perModel.get(e.model) ?? {
+            turns: 0,
+            cost: 0,
+            tokens: { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 },
+        };
+        slot.turns += 1;
+        slot.cost += e.cost;
+        slot.tokens.input += e.tokens.input;
+        slot.tokens.output += e.tokens.output;
+        slot.tokens.cacheRead += e.tokens.cacheRead;
+        slot.tokens.cacheCreate += e.tokens.cacheCreate;
+        perModel.set(e.model, slot);
+    }
+    return {
+        totalCost: Math.round(total * 10000) / 10000,
+        totalTokens: totals,
+        turns: entries.length,
+        byModel: [...perModel.entries()].map(([model, v]) => ({ model, ...v })),
+    };
+}

package/dist/cost/pricing.js

@@ -0,0 +1,91 @@
+/**
+ * Anthropic model pricing — USD per 1 million tokens.
+ *
+ * **Duplicate of `cspeach-proxy/src/anthropic/pricing.ts`** with one
+ * extension: this version also tracks `cache_creation_input_tokens` (the
+ * cache-write rate is 1.25× input per Anthropic's docs). The proxy version
+ * intentionally undercounts to stay conservative on customer bills; the
+ * CLI shows the cost to the developer who's spending it, so accuracy wins.
+ *
+ * **Sync responsibility**: when Anthropic updates pricing (~2x/year), update
+ * BOTH this file AND the proxy's version. Verify on the public pricing page:
+ *   https://www.anthropic.com/pricing
+ *
+ * Last verified 2026-05-12. Same as proxy.
+ *
+ * Unknown models → returns null + records the model name to a process-level
+ * Set so we surface them as an obvious warning rather than silently zeroing.
+ */
+const PRICING = {
+    // Claude Opus 4.x family — input 15, output 75, cache_read 1.50, cache_write 18.75
+    'claude-opus-4-7': { inputPer1M: 15.00, outputPer1M: 75.00, cacheReadPer1M: 1.50, cacheCreatePer1M: 18.75 },
+    'claude-opus-4-6': { inputPer1M: 15.00, outputPer1M: 75.00, cacheReadPer1M: 1.50, cacheCreatePer1M: 18.75 },
+    'claude-opus-4-5': { inputPer1M: 15.00, outputPer1M: 75.00, cacheReadPer1M: 1.50, cacheCreatePer1M: 18.75 },
+    'claude-opus-4': { inputPer1M: 15.00, outputPer1M: 75.00, cacheReadPer1M: 1.50, cacheCreatePer1M: 18.75 },
+    // Claude Sonnet 4.x family — input 3, output 15, cache_read 0.30, cache_write 3.75
+    'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00, cacheReadPer1M: 0.30, cacheCreatePer1M: 3.75 },
+    'claude-sonnet-4-5': { inputPer1M: 3.00, outputPer1M: 15.00, cacheReadPer1M: 0.30, cacheCreatePer1M: 3.75 },
+    'claude-sonnet-4': { inputPer1M: 3.00, outputPer1M: 15.00, cacheReadPer1M: 0.30, cacheCreatePer1M: 3.75 },
+    // Claude Haiku 4.x family — input 1, output 5, cache_read 0.10, cache_write 1.25
+    'claude-haiku-4-6-latest': { inputPer1M: 1.00, outputPer1M: 5.00, cacheReadPer1M: 0.10, cacheCreatePer1M: 1.25 },
+    'claude-haiku-4-5-20251001': { inputPer1M: 1.00, outputPer1M: 5.00, cacheReadPer1M: 0.10, cacheCreatePer1M: 1.25 },
+    'claude-haiku-4-5': { inputPer1M: 1.00, outputPer1M: 5.00, cacheReadPer1M: 0.10, cacheCreatePer1M: 1.25 },
+    'claude-haiku-4': { inputPer1M: 1.00, outputPer1M: 5.00, cacheReadPer1M: 0.10, cacheCreatePer1M: 1.25 },
+};
+const seenUnknownModels = new Set();
+/**
+ * Look up a per-1M-token rate for a model. Normalises to lowercase and
+ * strips Anthropic's optional `-YYYYMMDD` date suffix so e.g.
+ * `claude-haiku-4-5-20251001` matches `claude-haiku-4-5`.
+ *
+ * Returns null on unknown model and logs the name once per process.
+ * Callers should treat null as "skip cost calculation" — the worst case
+ * is the footer shows `$?` instead of a number.
+ */
+export function getRate(model) {
+    const normalized = model.toLowerCase();
+    if (PRICING[normalized])
+        return PRICING[normalized];
+    const stripDate = normalized.replace(/-\d{8}$/, '');
+    if (PRICING[stripDate])
+        return PRICING[stripDate];
+    if (!seenUnknownModels.has(normalized)) {
+        seenUnknownModels.add(normalized);
+        // Best-effort warn; don't crash if the console is unavailable.
+        try {
+            console.warn(JSON.stringify({ msg: 'pricing_unknown_model', model: normalized }));
+        }
+        catch { /* noop */ }
+    }
+    return null;
+}
+/**
+ * Compute the USD cost of a token bundle at the given model's rate.
+ *
+ * Returns 0 on unknown model (after `getRate` logged the warning).
+ *
+ * Rounded to 4 decimals (1/100 of a cent) — sufficient precision for the
+ * sub-cent per-tool-call line items we may surface later, avoids float
+ * drift in subsequent sums.
+ */
+export function computeCost(model, t) {
+    const r = getRate(model);
+    if (!r)
+        return 0;
+    const cost = (t.input * r.inputPer1M +
+        t.output * r.outputPer1M +
+        t.cacheRead * r.cacheReadPer1M +
+        t.cacheCreate * r.cacheCreatePer1M) / 1_000_000;
+    return Math.round(cost * 10000) / 10000;
+}
+/**
+ * Format a USD number for display in the REPL footer. Sub-cent values
+ * render as `<$0.01` so the user doesn't see a meaningless `$0.0023`.
+ */
+export function formatCost(usd) {
+    if (usd < 0.01)
+        return '<$0.01';
+    if (usd < 10)
+        return `$${usd.toFixed(2)}`;
+    return `$${usd.toFixed(1)}`;
+}

package/dist/one-shot.js

@@ -32,7 +32,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';
 export async function runOneShot(prompt, opts) {
     const cfg = await loadConfig();

package/dist/renderer/markdown.js

@@ -16,6 +16,7 @@ import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import Table from 'cli-table3';
 import { applySeverityToCell } from './severity.js';
+import { getEffectiveBodyWidth } from './tty.js';
 const PEACH = '#FFB88C';
 // marked-terminal uses these sentinels internally. We parse them back out to
 // rebuild a width-capped cli-table3 in our table renderer override below.
@@ -176,7 +177,12 @@ marked.use({
                     }
                 }
             }
-            const termWidth = process.stdout.columns || 120;
+            // Phase A #2 (2026-05-16) — was `process.stdout.columns || 120` which
+            // over-allocated in Ink mode: the Body sits next to a 30-col Sidebar,
+            // so tables sized for full terminal width wrapped inside Body and
+            // bled into the Sidebar visually. getEffectiveBodyWidth() returns
+            // `cols − sidebar − border` under Ink and the full width under classic.
+            const termWidth = getEffectiveBodyWidth();
             const colWidths = computeColWidths(naturalWidths, minWidths, termWidth);
             // Decide whether row separators are needed. When every row fits on one
             // visual line we suppress them (avoids stairstep on small tables, see

package/dist/renderer/status-footer.js

@@ -1,6 +1,14 @@
 import chalk from 'chalk';
+import { formatCost } from '../cost/pricing.js';
 const RULE_WIDTH = 72;
 const RULE = chalk.dim('─'.repeat(RULE_WIDTH));
+/**
+ * Phase 2 (2026-05-16) — when a session crosses this much non-cached input,
+ * we nudge the user to /compact. Threshold is "feel right" — tuned to fire
+ * after ~10-15 substantial turns of build work but not on light Q&A days.
+ * Re-evaluate after a week of real data.
+ */
+export const LARGE_SESSION_THRESHOLD = 100_000;
 /**
  * Prints a status footer after each turn ends.
  *
@@ -14,37 +22,52 @@ const RULE = chalk.dim('─'.repeat(RULE_WIDTH));
  * the session-lifetime `session.usage`. `cachedTokens` remains lifetime
  * (cache reads are rare per-turn; the session running count is more useful).
  *
- * M9 — Dollar display removed in v0.2: accurate pricing requires splitting
- * input / output / cached-read / cached-write tokens against four different
- * per-MTok prices, which the footer does not have access to post-turn.
- * A blended `$30/M * totalTokens` formula is wrong by up to 6× on cache-heavy
- * turns (cached reads are $0.30/M, not $30/M) and misleads rather than
- * informs. v0.3 adds proper usage breakdown via
- * `session.tokens_by_category` and restores a provably correct cost line.
+ * Phase 1 cost tracking (2026-05-16): the M9 caveat is resolved. The caller
+ * now snapshots all four token categories pre-turn (input, output, cache_read,
+ * cache_create) and computes the delta-driven $ cost via cost/pricing.ts at
+ * the correct per-MTok rates per category. `costThisTurn` and `costSession`
+ * are optional on the params for back-compat with callers that haven't been
+ * updated yet — when both are absent the footer renders the v0.2 cost-free
+ * format unchanged.
  *
  * v0.3 transition: this chalk status-footer-after-turn is replaced (not
  * augmented) by the Ink persistent footer region in Plan 4c.
  */
-export function printStatusFooter(params) {
-    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs } = params;
+/**
+ * Format the status footer as a single string (with embedded newlines).
+ * Pulled out from `printStatusFooter` so the Ink path can route the
+ * exact same line through chunkEmitter → Body's <Static> instead of
+ * direct stdout (which would corrupt the live Ink frame).
+ */
+export function formatStatusFooter(params) {
+    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs, costThisTurn, costSession, sessionInputTokens } = params;
     const shortSession = sessionId.slice(0, 8);
     const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
     const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
-    // H1 — "this turn" makes it explicit the token count is per-turn, not
-    // session-lifetime. The REPL passes the pre/post-runTurn delta.
     const tokStr = tokens.toLocaleString() + ' tok this turn';
     const cachedStr = cachedTokens > 0 ? `${cachedTokens.toLocaleString()} cached` : '';
     const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
+    const costTurnStr = costThisTurn != null ? formatCost(costThisTurn) : '';
+    const costSessStr = costSession != null ? `session: ${formatCost(costSession)}` : '';
     const parts = [
         chalk.dim(`session ${shortSession}`),
         chalk.dim(sapAlias),
         chalk.dim(skillDisplay),
         chalk.dim(turns),
         chalk.dim(tokStr),
+        ...(costTurnStr ? [chalk.dim(costTurnStr)] : []),
         ...(cachedStr ? [chalk.dim(cachedStr)] : []),
+        ...(costSessStr ? [chalk.dim(costSessStr)] : []),
         ...(elapsed ? [chalk.dim(elapsed)] : []),
     ];
-    console.log('\n' + RULE);
-    console.log(' ' + parts.join(chalk.dim(' │ ')));
-    console.log(RULE + '\n');
+    const lines = ['', RULE, ' ' + parts.join(chalk.dim(' │ '))];
+    if (sessionInputTokens != null && sessionInputTokens >= LARGE_SESSION_THRESHOLD) {
+        lines.push(' ' + chalk.yellow(`⚠  session getting large (${sessionInputTokens.toLocaleString()} input tokens)`
+            + ` — type /compact to summarise older turns, or /exit + cspeach (fresh) for a new topic`));
+    }
+    lines.push(RULE, '');
+    return lines.join('\n');
+}
+export function printStatusFooter(params) {
+    process.stdout.write(formatStatusFooter(params));
 }

package/dist/renderer/thinking-heartbeat.js

@@ -39,19 +39,31 @@ const THRESHOLDS_MS = [
     { at: 180_000, label: 'thinking… (3m — Ctrl+C is recommended; the stream may have stalled)' },
     { at: 300_000, label: 'thinking… (5m — Ctrl+C and try again)' },
 ];
-export function startThinkingHeartbeat() {
+export function startThinkingHeartbeat(opts) {
     const startedAt = Date.now();
     let nextIdx = 0;
     let stopped = false;
+    const emitLine = (line) => {
+        if (opts?.chunkEmitter) {
+            // Phase A #4 — route through Ink's chunk pipeline. The Body
+            // component's reducer treats this like any other model chunk and
+            // appends it as a node, so the heartbeat lives inside the React
+            // render tree and survives subsequent renders.
+            opts.chunkEmitter.emit('chunk', line);
+        }
+        else {
+            // Classic mode — direct stdout, plain newline-terminated line.
+            process.stdout.write(line);
+        }
+    };
     const tick = () => {
         if (stopped)
             return;
         const elapsed = Date.now() - startedAt;
         while (nextIdx < THRESHOLDS_MS.length && THRESHOLDS_MS[nextIdx].at <= elapsed) {
             const t = THRESHOLDS_MS[nextIdx];
-            // Plain newline-terminated line — survives any terminal mode.
             // Indent by 2 spaces to align with tool-call rows.
-            process.stdout.write(chalk.dim(`  ${t.label}\n`));
+            emitLine(chalk.dim(`  ${t.label}\n`));
             nextIdx++;
         }
     };

package/dist/renderer/tool-widget.js

@@ -22,7 +22,12 @@ import { PEACH } from './banners.js';
  */
 const peach = (s) => chalk.hex(PEACH)(s);
 const ARG_SUMMARY_MAX = 64;
-const RESULT_SUMMARY_MAX = 96;
+// 2026-05-15 (bug 1): widened from 96 → 240 so a parsed ADT exception
+// message ("CTS_WBO_API/047: Request S4HK903388 is not a local request"
+// — ~55 chars) plus a trailing ` · 1.2s` timing fits comfortably on one
+// terminal line without losing the human-readable cause. Anything past
+// 240 chars genuinely is XML/JSON noise and is fine to clip.
+const RESULT_SUMMARY_MAX = 240;
 /** Braille spinner — 8 frames at 80ms each gives a smooth rotation that
  *  reads as "still working" without being distracting. */
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];

package/dist/renderer/tty.js

@@ -64,3 +64,30 @@ export function isWindowsLegacyTerminal() {
 export function shouldUseUnicodeBoxChars() {
     return !isWindowsLegacyTerminal();
 }
+/**
+ * Extra cols reserved for the Body region's border (2 for left/right
+ * borders + 2 for safety against single-char rounding in Ink's flex
+ * layout). Subtracted from terminal width by getEffectiveBodyWidth.
+ */
+const BORDER_OVERHEAD = 4;
+/**
+ * Returns the effective horizontal width available to the Body region.
+ *
+ * In Ink mode the Body sits to the LEFT of a fixed-width Sidebar, so the
+ * effective width is `cols - SIDEBAR_WIDTH - BORDER_OVERHEAD`. In classic
+ * mode the full terminal width is available. Markdown table column
+ * allocation should call this, not `process.stdout.columns`, otherwise
+ * wide tables wrap inside the Body and bleed visually into the Sidebar.
+ *
+ * Phase A #2 (2026-05-16) — closes B1.
+ */
+export function getEffectiveBodyWidth() {
+    const cols = process.stdout.columns || 120;
+    if (!shouldUseInk())
+        return cols;
+    // Phase D (2026-05-16): Sidebar dropped — Body now spans the full
+    // terminal width minus the border overhead. Was `cols - SIDEBAR_WIDTH
+    // - BORDER_OVERHEAD` (= cols - 34), now `cols - BORDER_OVERHEAD`
+    // (= cols - 4). Wide tables get ~30 more cols to breathe.
+    return Math.max(40, cols - BORDER_OVERHEAD);
+}

package/dist/repl/cspeach-shell-detect.js

@@ -0,0 +1,33 @@
+/**
+ * Detect a `cspeach ...` shell command typed *inside* the REPL.
+ *
+ * Bug 11b (2026-05-15): during a live session, the user accidentally typed
+ * `cspeach --resume 17c04ce8` at the REPL prompt instead of in their
+ * terminal. The line was routed as a prompt to the skill classifier — at
+ * best wasted a turn, at worst poisoned the session further. The user
+ * had to /exit and re-run the command in the host shell anyway.
+ *
+ * Detection rule:
+ *   - Line (already trimmed) starts with the literal token `cspeach`
+ *     followed by either end-of-line OR whitespace.
+ *   - The word `cspeach` appearing inside a sentence ("How does cspeach
+ *     handle X?") does NOT match — only a leading token.
+ *
+ * The caller should print a friendly nudge and short-circuit the prompt.
+ */
+export function looksLikeCspeachShellCommand(line) {
+    if (!line)
+        return false;
+    // Match `cspeach` at the very start, followed by end-of-string OR a
+    // single space/tab. Critically NOT a newline — a multi-line paste whose
+    // first line happens to start with `cspeach` (e.g. a doc snippet or
+    // chat log) should pass through to the model, not get silently swallowed.
+    // Case-sensitive — the CLI binary is lowercase by convention and a
+    // capitalised "Cspeach" in a sentence should pass through normally.
+    return /^cspeach($|[ \t])/.test(line);
+}
+/**
+ * Human-facing message printed when the detector fires. Exported so tests
+ * can assert on the exact wording.
+ */
+export const CSPEACH_SHELL_NUDGE = 'That looks like a shell command for your terminal. Inside CSPeach, type `/exit` first, then run that in your shell.';

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

@@ -0,0 +1,68 @@
+/**
+ * Post-turn status push — shared helper for classic + Ink REPL paths.
+ *
+ * Phase D6 (2026-05-17) rewrite: with the alt-screen / Header removed
+ * in favour of inline + <Static>, BOTH modes now use the same chalk
+ * status line. The difference is just the sink:
+ *
+ *   Classic mode → printStatusFooter() writes to stdout directly
+ *   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.
+ */
+import { computeCost } from '../cost/pricing.js';
+import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
+import { shouldUseInk } from '../renderer/tty.js';
+export function snapshotTurnStart(session) {
+    return {
+        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,
+        startedAt: Date.now(),
+    };
+}
+export function pushPostTurnStatus(params) {
+    const { session, selectedAlias, snapshot, chunkEmitter } = 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;
+    const turnTokens = Math.max(0, lifetimeTokensAfter - lifetimeTokensBefore);
+    const turnCostTokens = {
+        input: session.usage.input_tokens - snapshot.input,
+        output: session.usage.output_tokens - snapshot.output,
+        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 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,
+    });
+    const statusPayload = {
+        sessionId: session.id,
+        sapAlias: selectedAlias,
+        skill: session.skill ?? '(none)',
+        turnCount: userTurns,
+        tokens: turnTokens,
+        cachedTokens: session.usage.cache_read_input_tokens,
+        elapsedMs: Date.now() - snapshot.startedAt,
+        costThisTurn: turnCost,
+        costSession: sessionCost,
+        sessionInputTokens: session.usage.input_tokens,
+    };
+    if (shouldUseInk() && chunkEmitter) {
+        // 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));
+    }
+    else {
+        printStatusFooter(statusPayload);
+    }
+}

package/dist/repl/slash-completer.js

@@ -20,6 +20,8 @@ import { SKILL_CATALOG } from '../skill-catalog.js';
  */
 const BUILTIN_COMMANDS = [
     '/cancel',
+    '/compact',
+    '/cost',
     '/exit',
     '/quit',
     '/help',

package/dist/repl/slash-picker.js

@@ -24,6 +24,8 @@ 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' },