@cspeach/cli 1.1.18 → 1.1.19

package/dist/renderer/change-card.js

@@ -0,0 +1,156 @@
+// src/renderer/change-card.ts
+//
+// Panels look (2026-09-26): one card per completed SAP write. The footer is
+// the SAME honest chain as verify-chain.ts; "activated" only when the write
+// result says the write itself activated (round 8 item 5). Diff lines only when old AND new source are known.
+import { diffLines } from 'diff';
+import { paint } from './theme.js';
+import { getBoxChars } from '../ui/ascii-chars.js';
+import { ANSI_RE } from './tool-labels.js';
+export const MIN_CARD_WIDTH = 40;
+const DIFF_LINES = 6;
+const DETAIL_MAX = 60;
+/** Myers diff is O(N·D) and synchronous: past this budget we show no diff
+ *  at all (object + footer only), never a partial one. */
+const DIFF_TIMEOUT_MS = 200;
+const defaultDiffer = (a, b) => diffLines(a, b, { timeout: DIFF_TIMEOUT_MS });
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;]*m/g;
+const visibleLen = (s) => s.replace(ANSI, '').length;
+const cut = (s, max) => (s.length > max ? s.slice(0, Math.max(0, max - 1)) + '…' : s);
+const flat = (s) => s.replace(/\s+/g, ' ').trim();
+// Source lines go inside a fixed-width box: tabs and control characters
+// (including stray escape sequences in the source) would break the border
+// arithmetic or leak into the terminal, so they are neutralised here. Whole
+// ANSI sequences go first (stripping only ESC would leave "[31m" visible);
+// leading spaces survive so code indentation stays readable.
+// eslint-disable-next-line no-control-regex
+const clean = (s) => s.replace(ANSI_RE, '').replace(/\t/g, '  ').replace(/[\x00-\x1f\x7f]/g, '');
+function footerParts(input) {
+    const parts = [];
+    if (input.snapshot === 'taken')
+        parts.push(`${paint('ok', '✓')} snapshot`);
+    else if (input.snapshot === 'new_object')
+        parts.push(paint('dim', '– snapshot (new object)'));
+    else if (input.snapshot === 'source_read_failed')
+        parts.push(paint('dim', `– snapshot (no source read${input.snapshotDetail ? ': ' + cut(flat(clean(input.snapshotDetail)), 40) : ''})`));
+    else
+        parts.push(paint('dim', '– snapshot (skipped)'));
+    parts.push(input.written ? `${paint('ok', '✓')} written` : `${paint('bad', '✗')} written`);
+    if (input.syntax === 'not_checked') {
+        parts.push(paint('dim', '– syntax (checked at activation)'));
+        parts.push(paint('dim', '· activate pending'));
+    }
+    else if (input.syntax.ok) {
+        parts.push(`${paint('ok', '✓')} syntax`);
+        // Round 8 item 5 — the real activation state from the write result.
+        const a = input.activation;
+        if (!a)
+            parts.push(paint('dim', '· activate pending'));
+        else if (a.state === 'active')
+            parts.push(`${paint('ok', '✓')} activated`);
+        else if (a.state === 'still_inactive')
+            parts.push(`${paint('bad', '✗')} still inactive`);
+        else if (a.state === 'unverified')
+            parts.push(paint('warn', '· activation unverified'));
+        else
+            parts.push(`${paint('bad', '✗')} activation${a.detail ? ' ' + paint('bad', `(${cut(flat(clean(a.detail)), DETAIL_MAX)})`) : ''}`);
+    }
+    else {
+        // Activation is blocked — say so; a pending step would lie.
+        parts.push(`${paint('bad', '✗')} syntax ${paint('bad', `(${cut(flat(clean(input.syntax.errors[0] ?? 'syntax errors')), DETAIL_MAX)})`)}`);
+        parts.push(paint('dim', '· activation blocked'));
+    }
+    return parts;
+}
+/** Changed lines for the card. Exported for tests only. */
+export function diffBody(card, differ = defaultDiffer) {
+    if (card.oldSource === undefined || card.newSource === undefined)
+        return { lines: [], hidden: 0 };
+    const changed = [];
+    // SAP serves CRLF source while written source is usually LF: compare on
+    // normalised text so an EOL-only difference is never shown as a change.
+    const norm = (s) => s.replace(/\r\n?/g, '\n').replace(/\n$/, '');
+    const parts = differ(norm(card.oldSource), norm(card.newSource));
+    if (parts === undefined)
+        return { lines: [], hidden: 0 }; // gave up: no diff, never a partial one
+    for (const part of parts) {
+        if (!part.added && !part.removed)
+            continue;
+        for (const l of part.value.replace(/\r?\n$/, '').split(/\r?\n/))
+            changed.push(`${part.added ? '+' : '-'} ${clean(l)}`);
+    }
+    return { lines: changed.slice(0, DIFF_LINES), hidden: Math.max(0, changed.length - DIFF_LINES) };
+}
+export function buildChangeCard(input, width, box = getBoxChars()) {
+    const { card } = input;
+    const title = clean(`Changed ${card.object} · ${card.what}`);
+    const parts = footerParts(input);
+    const chain = parts.join('  ');
+    const transportText = card.transport ? `· ${clean(card.transport)}` : '';
+    const body = diffBody(card);
+    if (width < MIN_CARD_WIDTH) {
+        const out = [cut(title, width)];
+        for (const l of body.lines)
+            out.push(paint(l.startsWith('+') ? 'ok' : 'bad', cut(l, width)));
+        if (body.hidden > 0)
+            out.push(paint('dim', cut(`… +${body.hidden} lines`, width)));
+        // Narrow terminal: the same honest parts, same order, one per line, each
+        // cut to the width so nothing wraps (colour dropped only on a cut part).
+        for (const p of parts)
+            out.push(visibleLen(p) > width ? cut(p.replace(ANSI, ''), width) : p);
+        if (card.transport)
+            out.push(paint('dim', cut(`· ${clean(card.transport)}`, width)));
+        return out.join('\n');
+    }
+    const b = box;
+    const inner = width - 4; // "│ " + content + " │"
+    const row = (content) => {
+        const pad = Math.max(0, inner - visibleLen(content));
+        return `${paint('frame', b.v)} ${content}${' '.repeat(pad)} ${paint('frame', b.v)}`;
+    };
+    // Top: "╭─ " + title + " " + fill + "╮" = width  →  fill = width - 5 - titleLen (≥ 1).
+    const titleText = cut(title, width - 6);
+    const top = paint('frame', b.tl + b.h) + ' ' + titleText + ' ' + paint('frame', b.h.repeat(width - 5 - titleText.length) + b.tr);
+    const lines = [top];
+    for (const l of body.lines)
+        lines.push(row(paint(l.startsWith('+') ? 'ok' : 'bad', cut(l, inner))));
+    if (body.hidden > 0)
+        lines.push(row(paint('dim', `  … +${body.hidden} lines`)));
+    lines.push(...footerLines(parts, chain, transportText, width, b, row));
+    return lines.join('\n');
+}
+/**
+ * Footer placement. Preferred: the whole footer on the bottom border. Too
+ * wide: the chain stays on the border and the transport becomes a row inside
+ * the box (a cut transport number would be wrong, a dropped one hides where
+ * the change went). Chain still too wide: the chain parts become rows INSIDE
+ * the box (same parts, same order, each cut to the inner width, like the
+ * narrow path) and a plain bottom border closes it — "activate pending" and
+ * the transport are never dropped.
+ */
+function footerLines(parts, chain, transportText, width, b, row) {
+    const room = width - 7;
+    const chainLen = visibleLen(chain);
+    const inner = width - 4;
+    if (transportText) {
+        const full = chain + ' ' + paint('dim', transportText);
+        if (visibleLen(full) <= room)
+            return [bottom(full, width, b)];
+        // Chain fits the border, the transport does not: transport as a boxed row.
+        if (chainLen <= room)
+            return [row(paint('dim', cut(transportText, inner))), bottom(chain, width, b)];
+    }
+    if (chainLen <= room)
+        return [bottom(chain, width, b)];
+    const out = parts.map((p) => row(visibleLen(p) > inner ? cut(p.replace(ANSI, ''), inner) : p));
+    if (transportText)
+        out.push(row(paint('dim', cut(transportText, inner))));
+    out.push(paint('frame', b.bl + b.h.repeat(width - 2) + b.br));
+    return out;
+}
+/** Bottom: "╰──" + " " + footer + " " + fill + "╯" = width  →  fill = width - 6 - footerLen (≥ 1). Callers guarantee the footer fits. */
+function bottom(footer, width, b) {
+    const fill = width - 6 - visibleLen(footer);
+    return `${paint('frame', b.bl + b.h + b.h)} ${footer} ${paint('frame', b.h.repeat(fill) + b.br)}`;
+}

package/dist/renderer/checklist-format.js

@@ -0,0 +1,130 @@
+// src/renderer/checklist-format.ts
+//
+// Piece 2 (spec §4) — the plan checklist, as pure strings. The live Ink
+// checklist (ui/checklist.tsx), the classic/headless scrollback block
+// (renderer/todo-block.ts) and the turn-end close line all come from here, so
+// the three can never disagree about counts, glyphs or which step is current.
+import chalk from 'chalk';
+import { getGlyphs } from './glyphs.js';
+import { paint } from './theme.js';
+import { sanitizeControlChars } from './sanitize.js';
+import { truncateToWidth } from './ui-width.js';
+import { shouldUseInk, isHeadless } from './tty.js';
+/** Item rows shown before folding (spec §4: "At most 7 rows"). The header is extra. */
+export const CHECKLIST_MAX_ROWS = 7;
+const INDENT = '  ';
+/** The one count format used everywhere (spec §4): "N of M". */
+export function countLabel(done, total) {
+    return `${done} of ${total}`;
+}
+/**
+ * The live step: the LAST in_progress item, or -1. Same rule as todo_set's
+ * `in_progress` echo (tools/todo.ts, pinned by todo-current-pin.test.ts) —
+ * models batch transitions, so an earlier in_progress item is stale.
+ */
+export function currentTodoIndex(todos) {
+    for (let i = todos.length - 1; i >= 0; i--) {
+        if (todos[i].status === 'in_progress')
+            return i;
+    }
+    return -1;
+}
+/** True when nothing is left to show: an empty list, or every item completed. */
+export function isPlanFinished(todos) {
+    return todos.length === 0 || todos.every((t) => t.status === 'completed');
+}
+function doneCount(todos) {
+    return todos.filter((t) => t.status === 'completed').length;
+}
+function allRows(todos, cur) {
+    return todos.map((t, i) => {
+        if (t.status === 'completed')
+            return { kind: 'done', text: t.text };
+        return { kind: i === cur ? 'current' : 'pending', text: t.text };
+    });
+}
+/**
+ * Folded view (spec §4): "✓ K done", then the current row and the rows after
+ * it, then "… N more". Open items BEFORE the current one (rare — a stale
+ * pending step) come after the ones that follow it. `cap` is the item-row cap.
+ */
+function foldedRows(todos, cur, cap) {
+    const done = doneCount(todos);
+    const open = todos.map((t, i) => ({ t, i })).filter((x) => x.t.status !== 'completed');
+    const pivot = cur >= 0 ? cur : (open[0]?.i ?? 0);
+    const ordered = [...open.filter((x) => x.i >= pivot), ...open.filter((x) => x.i < pivot)];
+    const toRow = (x) => ({ kind: x.i === cur ? 'current' : 'pending', text: x.t.text });
+    if (cap <= 1) {
+        return ordered.length > 0 ? [toRow(ordered[0])] : [{ kind: 'summary', n: done }];
+    }
+    const head = done > 0 && cap >= 3 ? [{ kind: 'summary', n: done }] : [];
+    const slots = Math.max(1, cap - head.length - 1); // one row kept for "… N more"
+    const shown = ordered.slice(0, slots).map(toRow);
+    const more = ordered.length - shown.length;
+    const rows = [...head, ...shown];
+    if (more > 0)
+        rows.push({ kind: 'more', n: more });
+    return rows;
+}
+function renderRow(r, width) {
+    const g = getGlyphs();
+    const fit = (s) => truncateToWidth(INDENT + s, width);
+    switch (r.kind) {
+        case 'done': return paint('dim', fit(`${g.done} ${r.text}`));
+        case 'current': return chalk.bold(paint('sap', fit(`${g.current} ${r.text}`)));
+        case 'pending': return paint('dim', fit(`${g.pending} ${r.text}`));
+        case 'summary': return paint('dim', fit(`${g.done} ${r.n} done`));
+        case 'more': return paint('dim', fit(`${g.more} ${r.n} more`));
+    }
+}
+/**
+ * The checklist as display lines: `Plan · N of M` header, then rows.
+ * - maxRows: cap on ITEM rows (header excluded). Not expanded → also capped
+ *   at CHECKLIST_MAX_ROWS; expanded → only maxRows (the §2 height cap) applies.
+ * - foldedToOne: exactly one line (used while a card is open).
+ * Todo text comes from the model: control characters are neutralised
+ * (sanitizeControlChars) and every line is truncated to `width` before it is
+ * painted, as the question cards do.
+ */
+export function formatChecklist(list, o) {
+    if (list.length === 0)
+        return [];
+    const todos = list.map((t) => ({ ...t, text: sanitizeControlChars(t.text) }));
+    const width = Math.max(1, Math.floor(o.width));
+    const cur = currentTodoIndex(todos);
+    const count = `Plan · ${countLabel(doneCount(todos), todos.length)}`;
+    if (o.foldedToOne) {
+        const tail = cur >= 0 ? ` · ${getGlyphs().current} ${todos[cur].text}` : '';
+        return [chalk.bold(truncateToWidth(count + tail, width))];
+    }
+    const cap = Math.max(1, o.expanded ? o.maxRows : Math.min(o.maxRows, CHECKLIST_MAX_ROWS));
+    const rows = todos.length <= cap ? allRows(todos, cur) : foldedRows(todos, cur, cap);
+    return [chalk.bold(truncateToWidth(count, width)), ...rows.map((r) => renderRow(r, width))];
+}
+/**
+ * The one line a turn leaves in scrollback when its plan changed (spec §4):
+ * `✓ Plan · M of M done` (ok) when finished, else `Plan · N of M done` (dim).
+ */
+export function formatPlanClose(todos) {
+    const done = doneCount(todos);
+    const total = todos.length;
+    if (total > 0 && done === total) {
+        return paint('ok', `${getGlyphs().done} Plan · ${countLabel(done, total)} done`);
+    }
+    return paint('dim', `Plan · ${countLabel(done, total)} done`);
+}
+let modeOverride;
+/** Test seam — force a mode; `undefined` restores detection. */
+export function setChecklistModeForTest(m) {
+    modeOverride = m;
+}
+export function checklistRenderMode() {
+    if (modeOverride)
+        return modeOverride;
+    // Headless first: a one-shot or piped run under a `ui.rendering = "ink"`
+    // override still has a stdout TTY, so shouldUseInk() is true, but no live
+    // frame is mounted — the plan must print per update.
+    if (isHeadless())
+        return 'per-update';
+    return shouldUseInk() ? 'live' : 'turn-end';
+}

package/dist/renderer/color-mode.js

@@ -0,0 +1,45 @@
+// src/renderer/color-mode.ts
+//
+// NO_COLOR (CLI look piece 2, spec §1.2). One switch: applyColorMode() at
+// startup maps NO_COLOR (set and non-empty) to chalk.level = 0. Colour
+// sources that are NOT the app's chalk (cli-table3's @colors/colors,
+// cli-highlight's chalk 4, the raw legacy zebra escape) key on colorOff(),
+// i.e. chalk.level === 0 — so NO_COLOR, a piped stream and a test that sets
+// chalk.level all behave the same, and the legacy pins (chalk.level = 3)
+// cannot be flipped by a CI NO_COLOR. Ink components use ui/role-props.ts.
+import chalk from 'chalk';
+let override;
+export function isNoColor() {
+    if (override !== undefined)
+        return override;
+    const v = process.env['NO_COLOR'];
+    return typeof v === 'string' && v !== '';
+}
+/** Tests only. `undefined` clears the override. */
+export function setNoColorForTest(v) {
+    override = v;
+}
+/**
+ * Call once at startup, before the first line of output.
+ *
+ * Under NO_COLOR it also sets FORCE_COLOR=0: chalk 5's bundled supports-color
+ * ignores NO_COLOR but honours FORCE_COLOR, so a chalk instance loaded AFTER
+ * this call (Ink and ink-text-input, if a package manager gives them their own
+ * copy) starts at level 0 too. That only works because cli.ts main() calls
+ * this before its lazy `await import('./repl.js')` / `('./one-shot.js')`, and
+ * cli.ts's static import graph does not reach Ink.
+ */
+export function applyColorMode() {
+    if (isNoColor()) {
+        chalk.level = 0;
+        process.env['FORCE_COLOR'] = '0';
+    }
+}
+/** True when colour output is off (NO_COLOR applied, non-colour stream, or level 0). */
+export function colorOff() {
+    return chalk.level === 0;
+}
+/** cli-table3 style: the coloured one, or empty head/border styles when colour is off. */
+export function tableStyle(colored) {
+    return colorOff() ? { head: [], border: [] } : colored;
+}

package/dist/renderer/error-detail.js

@@ -0,0 +1,104 @@
+/**
+ * humanErrorDetail — readable detail lines for a failed tool row.
+ *
+ * Live fix 2026-09-26: a failed `sap_activate` row printed its raw JSON
+ * result (`{"success":false,"activation_results":[{"name":"ZC_X",…`). The
+ * row detail must say what went wrong, in words:
+ *   - activation results → one line per failed object: `ZC_X: <error text>`
+ *     (error-severity messages first; still-inactive objects when SAP gave
+ *     no message);
+ *   - other JSON → its `message` / `reason` field, or the existing
+ *     error/detail + ADT-exception summary (formatToolErrorSummary);
+ *   - anything still JSON-shaped → collapsed to ONE line (the caller
+ *     truncates it to the width).
+ * Plain text passes through line by line. The model's tool result is not
+ * touched — this only shapes the on-screen row.
+ */
+import { formatToolErrorSummary } from '../sap-errors/parse-adt-exception.js';
+import { cleanErrorText, looksLikeMarkup } from '../sap-errors/clean-error-text.js';
+function messageText(m) {
+    if (typeof m === 'string')
+        return m;
+    if (m && typeof m === 'object') {
+        const o = m;
+        for (const k of ['shortText', 'text', 'message', 'longText']) {
+            const v = o[k];
+            if (typeof v === 'string' && v.trim())
+                return v;
+        }
+    }
+    return '';
+}
+function isErrorMessage(m) {
+    if (typeof m === 'string')
+        return true;
+    const sev = m && typeof m === 'object' ? String(m['severity'] ?? m['type'] ?? '') : '';
+    return /^(e|error|a|abort|fatal)$/i.test(sev);
+}
+function activationLines(obj) {
+    const results = obj['activation_results'];
+    if (!Array.isArray(results))
+        return [];
+    const lines = [];
+    for (const r of results) {
+        if (!r || typeof r !== 'object' || r['success'] === true)
+            continue;
+        const msgs = Array.isArray(r['messages']) ? r['messages'] : [];
+        const ordered = [...msgs.filter(isErrorMessage), ...msgs.filter((m) => !isErrorMessage(m))];
+        const text = ordered.map(messageText).find((t) => t.trim()) ?? 'activation failed';
+        lines.push(`${String(r['name'] ?? '?')}: ${text}`);
+    }
+    if (lines.length === 0) {
+        const still = obj['still_inactive'];
+        if (Array.isArray(still))
+            for (const s of still)
+                lines.push(`${String(s)} still inactive`);
+        const unv = obj['unverifiable'];
+        if (Array.isArray(unv)) {
+            for (const u of unv)
+                lines.push(`${String(u?.['object'] ?? '?')} not verified: ${String(u?.['reason'] ?? '')}`.trim());
+        }
+    }
+    if (lines.length === 0 && typeof obj['note'] === 'string')
+        lines.push(obj['note']);
+    return lines;
+}
+const oneLine = (s) => s.replace(/\s+/g, ' ').trim();
+function detailLines(raw) {
+    const t = raw.trim();
+    if (t.startsWith('{')) {
+        let obj;
+        try {
+            obj = JSON.parse(t);
+        }
+        catch {
+            obj = undefined;
+        }
+        if (obj && typeof obj === 'object') {
+            const act = activationLines(obj);
+            if (act.length > 0)
+                return act;
+            for (const k of ['message', 'reason']) {
+                const v = obj[k];
+                if (typeof v === 'string' && v.trim() && typeof obj['error'] !== 'string' && typeof obj['detail'] !== 'string') {
+                    return v.split('\n');
+                }
+            }
+        }
+        const summary = formatToolErrorSummary(raw);
+        if (summary.trim().startsWith('{'))
+            return [oneLine(summary)];
+        return summary.split('\n');
+    }
+    return raw.split('\n');
+}
+// Fix round 3 (item 10): a thrown sap-client error reaches the tool result as
+// String(err) — "SapNotFoundError: Object not found: …". The class name is
+// developer noise on a failure row; the message after it is the reason.
+const SAP_ERROR_CLASS = /^Sap[A-Za-z]*Error:\s+/;
+export function humanErrorDetail(raw) {
+    // An ICM HTML error page inside a message: no tags or CSS on screen.
+    return detailLines(raw)
+        .map((l) => l.replace(SAP_ERROR_CLASS, ''))
+        .map((l) => (looksLikeMarkup(l) ? cleanErrorText(l, 400) : l));
+}

package/dist/renderer/fence-state.js

@@ -0,0 +1,46 @@
+// src/renderer/fence-state.ts
+//
+// Piece 2 §11.2 — while the markdown renderer holds back an unfinished fenced
+// code block (it never flushes inside a fence), the answer looks frozen. The
+// status strip says "writing code…" for exactly that stretch.
+//
+// One CommonMark fence rule, shared with pipeline.ts panelsFlushPoint so the
+// label and the hold-back can never disagree: ``` or ~~~, the closer uses the
+// same character, is at least as long, and has nothing after it; a ``` line
+// with a backtick in its info string is not a fence. Lines are taken as-is
+// (a trailing '\r' is not stripped, exactly as panelsFlushPoint has always
+// behaved). Only complete lines are scanned.
+/** CommonMark fence line: up to 3 spaces, then 3+ backticks or tildes. */
+export const FENCE_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+/**
+ * Advance the fence state by one complete line. `consumed` is true when the
+ * line is inside a fence (including its closer) or opens one, so the caller
+ * must not treat it as ordinary text (e.g. a blank-line flush point).
+ */
+export function stepFence(fence, line) {
+    const f = FENCE_RE.exec(line);
+    if (fence) {
+        if (f && f[1][0] === fence.ch && f[1].length >= fence.len && f[2].trim() === '')
+            return { fence: undefined, consumed: true };
+        return { fence, consumed: true };
+    }
+    if (f && !(f[1][0] === '`' && f[2].includes('`')))
+        return { fence: { ch: f[1][0], len: f[1].length }, consumed: true };
+    return { fence: undefined, consumed: false };
+}
+export const WRITING_CODE_LABEL = 'writing code…';
+export const WRITING_RESPONSE_LABEL = 'writing response';
+export function hasOpenFence(text) {
+    let fence;
+    const lines = text.split('\n');
+    lines.pop(); // the last element is an incomplete line (or '' after a final \n)
+    for (const line of lines)
+        fence = stepFence(fence, line).fence;
+    return fence !== undefined;
+}
+export function nextWritingActivity(prevWritingCode, pending) {
+    const writingCode = hasOpenFence(pending);
+    if (writingCode === prevWritingCode)
+        return { writingCode, label: null };
+    return { writingCode, label: writingCode ? WRITING_CODE_LABEL : WRITING_RESPONSE_LABEL };
+}

package/dist/renderer/footer-line.js

@@ -0,0 +1,96 @@
+// src/renderer/footer-line.ts
+//
+// Piece 2 (spec §8) — the one footer line under the input box, and the
+// one-line per-turn receipt. Pure strings (roles via theme.ts), so the Ink
+// component, the classic receipt and one-shot share one formatter.
+import stringWidth from 'string-width';
+import { paint } from './theme.js';
+import { truncateToWidth } from './ui-width.js';
+import { sanitizeControlChars } from './sanitize.js';
+import { formatCost } from '../cost/pricing.js';
+import { formatCredits, CREDITS_PENDING, creditsActive } from '../cost/credits.js';
+export const SHORTCUTS_HINT = '? shortcuts';
+const SEP = ' · ';
+/**
+ * The live spend segment (moved verbatim from ui/status-line.tsx). Single home
+ * for the credits/dollar switch: a managed customer sees the session credit
+ * total, BYOK/local see the session dollars — never the other.
+ */
+export function formatSpendSegment(s) {
+    if (!s.creditsMode)
+        return `$${s.dollarSpendToday.toFixed(2)}`;
+    if (s.creditsPending && s.creditsSessionTotal === 0)
+        return CREDITS_PENDING;
+    return formatCredits(s.creditsSessionTotal, s.creditsUnitLabel);
+}
+/** Store → footer facts. F-L2-1: the transport falls back to the one a write actually stamped. */
+export function footerStateFrom(s) {
+    return {
+        system: s.system || undefined,
+        user: s.user || undefined,
+        transport: (s.transport ?? s.lastWriteTransport) || undefined,
+        standalone: s.standalone === true,
+        mode: s.writeMode ?? '',
+        spend: formatSpendSegment(s),
+    };
+}
+const MODE_ROLE = { 'advisory-only': 'warn', 'approval-gated': 'ok', auto: 'sap' };
+/**
+ * `<SYS> · <USER> · transport <TR> · <mode> · <spend>` on the left and a dim
+ * `? shortcuts` on the right, padded to exactly `width`. When it does not fit,
+ * the hint drops first, then the left side truncates.
+ */
+export function formatFooterLine(s, width) {
+    const parts = [];
+    if (s.standalone) {
+        parts.push({ text: 'standalone', role: 'sap' }, { text: 'local files', role: 'dim' });
+    }
+    else {
+        // System, user and transport come from config / SAP responses (the
+        // write-stamped transport has no format check) — never let them drive
+        // the terminal.
+        parts.push(s.system ? { text: sanitizeControlChars(s.system), role: 'sap' } : { text: 'no system', role: 'dim' });
+        if (s.user)
+            parts.push({ text: sanitizeControlChars(s.user), role: 'dim' });
+        parts.push({ text: s.transport ? `transport ${sanitizeControlChars(s.transport)}` : 'no transport', role: 'dim' });
+    }
+    if (s.mode)
+        parts.push({ text: s.mode, role: MODE_ROLE[s.mode] ?? 'dim' });
+    if (s.spend)
+        parts.push({ text: s.spend, role: 'dim' });
+    const w = Math.max(1, Math.floor(width));
+    const plain = parts.map((p) => p.text).join(SEP);
+    const plainW = stringWidth(plain);
+    const hintW = stringWidth(SHORTCUTS_HINT);
+    if (plainW + 2 + hintW <= w) {
+        const left = parts.map((p) => paint(p.role, p.text)).join(paint('dim', SEP));
+        return left + ' '.repeat(w - plainW - hintW) + paint('dim', SHORTCUTS_HINT);
+    }
+    return paint('dim', truncateToWidth(plain, w));
+}
+/**
+ * This turn's spend for the receipt: credits charged this turn in credits mode
+ * (updating marker when unknown — never a dollar fallback), the turn's USD
+ * cost otherwise, '' when there is none.
+ */
+export function turnSpendText(p) {
+    if (creditsActive()) {
+        const c = p.credits;
+        if (!c || c.chargedThisTurn === null)
+            return CREDITS_PENDING;
+        return formatCredits(c.chargedThisTurn, c.unitLabel);
+    }
+    return p.costThisTurn != null ? formatCost(p.costThisTurn) : '';
+}
+/** `/<skill> · <tokens> tokens · <this-turn spend> · <time>` — one dim line, no newline. */
+export function formatTurnReceipt(p) {
+    const parts = [];
+    if (p.skill && p.skill !== '(none)')
+        parts.push(p.skill.startsWith('/') ? p.skill : `/${p.skill}`);
+    parts.push(`${p.tokens.toLocaleString('en-US')} tokens`);
+    if (p.spend)
+        parts.push(p.spend);
+    if (p.ms > 0)
+        parts.push(`${(p.ms / 1000).toFixed(1)}s`);
+    return paint('dim', parts.join(SEP));
+}

package/dist/renderer/glyphs.js

@@ -0,0 +1,25 @@
+// src/renderer/glyphs.ts
+//
+// One glyph set for every panels / new surface (CLI look piece 2, spec §1.3).
+// The glyphs this set replaces are retired outside legacy-pinned code; the
+// list lives in spec §1.3 and in test/unit/ui-guards.test.ts (not spelled out
+// here, or the guard would flag this comment). ASCII fallback reuses the same
+// legacy-Windows-console detection as ui/ascii-chars.ts.
+import { shouldUseUnicodeBoxChars } from './tty.js';
+export const UNICODE_GLYPHS = {
+    done: '✓', failed: '✗', attention: '!', info: '·', current: '◼', pending: '☐',
+    answered: '☒', cursor: '❯', trace: '?', tickOn: '[x]', tickOff: '[ ]', more: '…', arrow: '→',
+};
+export const ASCII_GLYPHS = {
+    done: 'v', failed: 'x', attention: '!', info: '-', current: '>', pending: '[ ]',
+    answered: '[x]', cursor: '>', trace: '?', tickOn: '[x]', tickOff: '[ ]', more: '...', arrow: '->',
+};
+let modeOverride;
+/** Tests only: pin the set regardless of platform / terminal. `undefined` clears. */
+export function setGlyphModeForTest(mode) {
+    modeOverride = mode;
+}
+export function getGlyphs() {
+    const unicode = modeOverride !== undefined ? modeOverride === 'unicode' : shouldUseUnicodeBoxChars();
+    return unicode ? UNICODE_GLYPHS : ASCII_GLYPHS;
+}

package/dist/renderer/goodbye.js

@@ -0,0 +1,38 @@
+// src/renderer/goodbye.ts
+//
+// Piece 2 §10: the /exit block — aligned label/value rows, spend in the
+// current display mode (credits for managed users; the caller passes the
+// value from formatSessionSpendValue), and ONE Next: line to resume.
+// Session id and skill come from the session file, so they are sanitized
+// before they reach the terminal.
+import chalk from 'chalk';
+import { panelRow } from './panel-rows.js';
+import { paint } from './theme.js';
+import { formatInfo } from './notice-shape.js';
+import { sanitizeControlChars } from './sanitize.js';
+const LABEL = 10; // 'Last skill'
+/**
+ * `logDir` — the display path of this session's turn-stream folder, passed
+ * only when it EXISTS (fix round 3, item 11b: the block named
+ * `streams/<id>.md`, a file that never exists — the logs are
+ * `streams/<id>/<timestamp>.md`). Absent → no log line.
+ */
+export function formatGoodbye(p) {
+    const id = sanitizeControlChars(p.sessionId);
+    const skill = p.lastSkill ? `/${sanitizeControlChars(p.lastSkill)}` : '(none)';
+    return [
+        '',
+        chalk.bold(`Session ${id}`),
+        panelRow('Turns', String(p.turns), LABEL),
+        panelRow('Last skill', skill, LABEL),
+        panelRow('Tokens', `${p.tokens.toLocaleString('en-US')}  (input + output + cache)`, LABEL),
+        panelRow('Spend', p.spend, LABEL),
+        '',
+        // Round 6 review I1 — a session never written (no turns) has nothing to resume.
+        p.saved === false
+            ? `  ${paint('dim', 'No session saved (no turns)')}`
+            : `  ${paint('dim', 'Next:')} cspeach --resume ${id}`,
+        ...(p.logDir ? [formatInfo(`Full log: ${sanitizeControlChars(p.logDir)}`).trimEnd()] : []),
+        '',
+    ];
+}