@cspeach/cli 1.1.18 → 1.1.19

package/dist/renderer/tool-widget.js

@@ -1,5 +1,12 @@
 import chalk from 'chalk';
-import { PEACH } from './banners.js';
+import { LEGACY_PEACH as PEACH } from './legacy-palette.js';
+import { getLook } from './look.js';
+import { paint } from './theme.js';
+import { toolLabel, toolActivityLabel, foldOutput, clean } from './tool-labels.js';
+import { getEffectiveBodyWidth } from './tty.js';
+import { flowFor, stdoutFlow, writeStdout, canAnimateInPlace } from './transcript-flow.js';
+import { humanErrorDetail } from './error-detail.js';
+export { canAnimateInPlace };
 /**
  * Tool-dispatch renderer — CC-style two-line format with peach spinner.
  *
@@ -46,6 +53,14 @@ const WIDGET_SUPPRESSED_TOOLS = new Set(['ask_question', 'todo_set']);
 export function isWidgetSuppressedTool(name) {
     return WIDGET_SUPPRESSED_TOOLS.has(name);
 }
+/** Live activity text (TurnStatus). Legacy = the raw tool name, as today. */
+export function toolActivityText(name, args) {
+    return getLook() === 'panels' ? toolActivityLabel(name, args) : name;
+}
+/** Heartbeat label. Legacy = `${name} running…`, as today. */
+export function toolHeartbeatLabel(name, args) {
+    return getLook() === 'panels' ? `${toolActivityLabel(name, args)}…` : `${name} running…`;
+}
 const ARG_SUMMARY_MAX = 64;
 // 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"
@@ -65,17 +80,72 @@ const SPINNER_VERBS = ['slicing peach', 'mashing pulp', 'pitting', 'pressing', '
  *  tool. Tool dispatch = peach-cooking metaphor; thinking = peach-growing
  *  metaphor (a beat slower in pacing). */
 const THINKING_VERBS = ['thinking', 'ripening', 'steeping', 'marinating', 'pondering', 'considering'];
+let activeSpinner = null;
+export function clearActiveSpinner() {
+    if (activeSpinner) {
+        activeSpinner.stop();
+        activeSpinner = null;
+    }
+}
 /**
- * Module-level reference to the currently-running spinner's stop function.
- * Set by startToolSpinner; cleared on stop. Lets unrelated subsystems
- * (e.g. inquirer-guard, when an inquirer prompt is about to open) silence
- * the spinner so it doesn't fight inquirer for stdout/cursor.
+ * Piece 2 §11.3 — pause the in-place spinner while an inquirer prompt owns the
+ * terminal and hand back a resume function (inquirer-guard calls it when it
+ * releases the terminal). Fixes the classic spinner vanishing for the rest of
+ * a tool after an approval mid-tool.
  */
-let activeSpinnerStop = null;
-export function clearActiveSpinner() {
-    if (activeSpinnerStop) {
-        activeSpinnerStop();
-        activeSpinnerStop = null;
+export function suspendActiveSpinner() {
+    const s = activeSpinner;
+    if (!s)
+        return () => undefined;
+    return s.suspend();
+}
+/**
+ * Review M1 (2026-09-27): run a print-then-prompt sequence with the active
+ * tool spinner suspended for the WHOLE sequence. The classic plan gate and
+ * the method diff preview print their preamble before withInquirer opens;
+ * without this the spinner kept repainting around that text and a stale
+ * frame was left in scrollback. Ref-counted like any suspend, so the nested
+ * withInquirer suspend is harmless. No spinner → just runs fn.
+ */
+export async function withSpinnerSuspended(fn) {
+    const resume = suspendActiveSpinner();
+    try {
+        return await fn();
+    }
+    finally {
+        resume();
+    }
+}
+/**
+ * Live fix 2026-09-26 — the ONE way classic output is written while a tool
+ * runs. The in-place spinner owns the current line (erase + `\r<frame>`), so
+ * a notice or change card written straight to stdout was glued onto the
+ * spinner text. When the spinner is painting: suspend it (erases its line,
+ * cursor to column 0), write the text on the clean line (with a trailing
+ * newline so the resumed spinner cannot erase it), then resume the spinner
+ * below. No spinner (Ink, pipes, between tools) → a plain write.
+ */
+/**
+ * Round 6 review M3 — true when writeAboveSpinner(text) would add a newline
+ * of its own (a spinner is painting and `text` does not end a line), so a
+ * caller that counts newlines (one-shot's AnswerTrim) can account for it.
+ */
+export function aboveSpinnerAddsNewline(text) {
+    const s = activeSpinner;
+    return !!s && s.painting() && !text.endsWith('\n');
+}
+export function writeAboveSpinner(text, write = writeStdout) {
+    const s = activeSpinner;
+    if (!s || !s.painting()) {
+        write(text);
+        return;
+    }
+    const resume = s.suspend();
+    try {
+        write(text.endsWith('\n') ? text : text + '\n');
+    }
+    finally {
+        resume();
     }
 }
 export function renderToolCallTop(params) {
@@ -88,8 +158,23 @@ export function renderToolCallTop(params) {
         if (chunkEmitter)
             chunkEmitter.emit('chunk', s);
         else
-            process.stdout.write(s);
+            writeStdout(s);
     };
+    // Panels look: no dispatch line — the live TurnStatus row carries
+    // "Reading x…" while the step runs; the transcript gets ONE row at the end.
+    // Start a fresh line so the classic spinner and the panels row never erase
+    // or glue onto assistant text that didn't end in a newline. Polish P1: the
+    // newline is only added when the output is really mid-line (the transcript
+    // flow knows), so consecutive tool rows sit together with no blank line.
+    // A raw emitter with no Body attached (tests, subagent/audit sinks) has no
+    // flow: it gets the unconditional "\n" as before.
+    if (getLook() === 'panels') {
+        const flow = chunkEmitter ? flowFor(chunkEmitter) : stdoutFlow;
+        const brk = flow ? flow.lineBreakIfNeeded() : '\n';
+        if (brk)
+            write(brk);
+        return;
+    }
     const summary = summariseToolArgs(name, args);
     const wrapped = summary ? chalk.gray('(') + chalk.gray(summary) + chalk.gray(')') : '';
     const line = `${peach('⏺')} ${chalk.bold(name)}${wrapped}`;
@@ -106,66 +191,109 @@ export function renderToolCallTop(params) {
  * prompt opens, same as tool spinner).
  */
 export function startThinkingSpinner(params) {
-    return startSpinnerWithVerbs(params, THINKING_VERBS, 'thinking');
+    return startSpinnerWithVerbs(params, THINKING_VERBS, 'thinking', getLook() === 'panels' ? 'thinking' : undefined);
 }
+/**
+ * `label` (panels look only): the step's activity text, e.g.
+ * `Searching "*AGING*" · PROG` — classic has no live status row, so the
+ * spinner carries it (spec §4). Legacy ignores it and keeps its verbs.
+ */
 export function startToolSpinner(params) {
-    return startSpinnerWithVerbs(params, SPINNER_VERBS, 'slicing peach');
+    return startSpinnerWithVerbs(params, SPINNER_VERBS, 'slicing peach', getLook() === 'panels' ? params.label : undefined);
 }
-function startSpinnerWithVerbs(params, verbs, defaultVerb) {
+/** Panels spinner: elapsed time appears after this long (matches the heartbeat's first "(10s)"). */
+const SPINNER_ELAPSED_AFTER_MS = 10_000;
+function startSpinnerWithVerbs(params, verbs, defaultVerb, fixedLabel) {
     const { chunkEmitter } = params;
-    const disabled = chunkEmitter !== undefined ||
-        !process.stdout.isTTY ||
-        process.env['CI'] === '1' ||
-        process.env['TERM'] === 'dumb';
+    const disabled = !canAnimateInPlace(chunkEmitter);
     if (disabled)
         return { stop: () => undefined };
     // Pick one verb per dispatch so the indicator doesn't churn.
-    const verb = verbs[Math.floor(Math.random() * verbs.length)] ?? defaultVerb;
+    const verb = fixedLabel !== undefined ? clean(fixedLabel) : (verbs[Math.floor(Math.random() * verbs.length)] ?? defaultVerb);
     let frameIdx = 0;
-    let stopped = false;
-    const paint = () => {
-        if (stopped)
+    let stopped = false; // for good
+    let running = false; // painting right now
+    let suspendCount = 0; // open suspenders (prompts / focus claims)
+    let interval;
+    const startedAt = Date.now();
+    const paintFrame = () => {
+        if (!running)
             return;
         const frame = SPINNER_FRAMES[frameIdx];
         frameIdx = (frameIdx + 1) % SPINNER_FRAMES.length;
-        // Erase current line + reprint. First call appends a fresh line; later
-        // calls cursor-up to the spinner row and overwrite in place.
-        const line = `  ${peach(frame)} ${chalk.dim(verb + '…')}`;
+        // Erase current line + reprint in place.
+        let line = `  ${peach(frame)} ${chalk.dim(verb + '…')}`;
+        if (fixedLabel !== undefined) {
+            // Panels: elapsed time once the wait is long, and never wider than the
+            // terminal — a wrapped spinner row would leave its first half behind
+            // when the erase clears only the current row.
+            const elapsed = Date.now() - startedAt;
+            // Piece 2 §8 — one cancel wording on every live surface (I2's strip says "stop").
+            const tail = elapsed >= SPINNER_ELAPSED_AFTER_MS ? ` (${Math.floor(elapsed / 1000)}s · ctrl+c to stop)` : '';
+            const room = Math.max(10, (process.stdout.columns || 80) - 1) - 4;
+            line = `  ${peach(frame)} ${chalk.dim(truncate(verb + '…' + tail, room))}`;
+        }
         process.stdout.write(`\x1B[2K\r${line}`);
     };
-    // Hide the terminal cursor while the spinner animates so it doesn't blink
-    // mid-frame and confuse the user about whether their typing went through.
-    process.stdout.write('\x1B[?25l');
-    // Print the initial spinner line.
-    process.stdout.write('\r');
-    paint();
-    const interval = setInterval(paint, SPINNER_TICK_MS);
-    interval.unref?.();
-    const stopFn = () => {
-        if (stopped)
+    // Hide the cursor (so it doesn't blink mid-frame), start at column 0,
+    // paint, tick. Used at start and on resume.
+    const begin = () => {
+        if (stopped || running)
+            return;
+        running = true;
+        process.stdout.write('\x1B[?25l');
+        process.stdout.write('\r');
+        paintFrame();
+        interval = setInterval(paintFrame, SPINNER_TICK_MS);
+        interval.unref?.();
+    };
+    // Erase the spinner line and re-show the cursor (paired with the hide above).
+    // No newline, so the bottom renderer's \n keeps the spacing correct.
+    const halt = () => {
+        if (!running)
             return;
-        stopped = true;
-        clearInterval(interval);
-        // Erase the spinner line so the result row paints in its place.
-        // \r → start of line, \x1B[2K → erase entire line. No newline so the
-        // bottom renderer's \n keeps the spacing correct.
-        // Also re-show the cursor (\x1B[?25h) — paired with the hide above.
+        running = false;
+        if (interval)
+            clearInterval(interval);
         process.stdout.write('\r\x1B[2K\x1B[?25h');
-        // Clear the global handle if it's still pointing at us. (If a newer
-        // spinner already replaced us, leave its registration alone.)
-        if (activeSpinnerStop === stopFn)
-            activeSpinnerStop = null;
+    };
+    const controller = {
+        painting: () => running,
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            halt();
+            // Clear the global handle if it's still pointing at us. (If a newer
+            // spinner already replaced us, leave its registration alone.)
+            if (activeSpinner === controller)
+                activeSpinner = null;
+        },
+        suspend: () => {
+            suspendCount += 1;
+            halt();
+            let used = false;
+            return () => {
+                if (used)
+                    return;
+                used = true;
+                suspendCount -= 1;
+                if (suspendCount === 0 && activeSpinner === controller)
+                    begin();
+            };
+        },
     };
     // Defensive: if a previous spinner is somehow still active when we start
     // (shouldn't happen — agent loop stops the previous one before next
     // dispatch — but easy to guarantee here), stop it before claiming the slot.
-    if (activeSpinnerStop)
-        activeSpinnerStop();
-    activeSpinnerStop = stopFn;
-    return { stop: stopFn };
+    if (activeSpinner)
+        activeSpinner.stop();
+    activeSpinner = controller;
+    begin();
+    return { stop: controller.stop };
 }
 export function renderToolCallBottom(params) {
-    const { durationMs, isError, resultSummary, chunkEmitter, name, args } = params;
+    const { durationMs, isError, resultSummary, chunkEmitter, name, args, resultContent } = params;
     // Ask-form de-clutter: paired with the top-line suppression — on SUCCESS
     // the answer already came back through the form; a ⎿ row would be noise.
     // ERRORS still render (review fix): an ask_form_invalid /
@@ -178,8 +306,12 @@ export function renderToolCallBottom(params) {
         if (chunkEmitter)
             chunkEmitter.emit('chunk', s);
         else
-            process.stdout.write(s);
+            writeStdout(s);
     };
+    if (getLook() === 'panels') {
+        write(panelsRow({ name: name ?? '', args: args ?? {}, isError, resultSummary, resultContent, durationMs }));
+        return;
+    }
     const icon = isError ? chalk.red('✗') : chalk.green('✓');
     // Label: plain (not bold — the top line keeps visual primacy) name +
     // dim arg summary, mirroring the top-line shape so orphaned rows still
@@ -253,3 +385,65 @@ function formatDuration(ms) {
         return `${ms}ms`;
     return `${(ms / 1000).toFixed(1)}s`;
 }
+const VERB_COL = 12;
+const ERROR_DETAIL_LINES = 3;
+const OUTPUT_LINES = 3;
+/** 'cancelled' / 'not approved' when a request_approval result declined; undefined otherwise. */
+function approvalDeclined(content) {
+    if (!content || !content.trim().startsWith('{'))
+        return undefined;
+    try {
+        const r = JSON.parse(content);
+        if (r.approved !== false)
+            return undefined;
+        return r.reason === 'plan_rejected' || r.reason === 'user_cancelled_turn' ? 'cancelled' : 'not approved';
+    }
+    catch {
+        return undefined;
+    }
+}
+function panelsRow(p) {
+    const width = Math.max(20, getEffectiveBodyWidth());
+    const label = toolLabel(p.name, p.args, p.isError ? undefined : p.resultContent);
+    // Round 8 item 2 — a cancelled / rejected approval is not a success: no
+    // green tick, and the row says what happened.
+    const declined = !p.isError && p.name === 'request_approval' ? approvalDeclined(p.resultContent) : undefined;
+    const icon = p.isError ? paint('bad', '✗') : declined ? paint('warn', '·') : paint('ok', '✓');
+    const timing = p.durationMs >= 1000 ? formatDuration(p.durationMs) : '';
+    const tail = [declined ?? label.detail, timing].filter(Boolean).join(' · ');
+    const verb = label.verb.padEnd(VERB_COL);
+    // Budget: "✓ " + verb + " " + object + "  " + tail must fit the width.
+    const budget = width - 2 - verb.length - 1 - (tail ? tail.length + 2 : 0);
+    const object = budget <= 1 ? '' : truncate(label.object, budget);
+    let line = `${icon} ${verb} ${object}`;
+    if (tail)
+        line += `  ${paint('dim', tail)}`;
+    const out = [truncatePlain(line, width)];
+    // Live fix 2026-09-26: a JSON tool result (e.g. sap_activate's
+    // activation_results) is turned into readable lines, never shown raw.
+    const errorSource = p.resultContent?.trim().startsWith('{') ? p.resultContent : p.resultSummary;
+    if (p.isError && errorSource) {
+        // Raw error text can carry ANSI codes, \r redraws and tabs: clean() each
+        // line (the one sanitiser, shared with the labels) before truncate + paint.
+        for (const d of humanErrorDetail(errorSource).map(clean).filter(Boolean).slice(0, ERROR_DETAIL_LINES)) {
+            out.push('    ' + paint('bad', truncate(d, width - 4)));
+        }
+    }
+    else if (!p.isError && p.name === 'shell_exec' && p.resultContent) {
+        const stdout = /stdout:\n([\s\S]*?)\n\nstderr:/.exec(p.resultContent)?.[1] ?? '';
+        // Real command output carries ANSI colour, \r progress redraws and tabs:
+        // clean() every line before folding so counts, truncation and colour are safe.
+        const folded = foldOutput(stdout.split('\n').map(clean).join('\n'), OUTPUT_LINES);
+        for (const l of folded.lines)
+            out.push('    ' + paint('dim', truncate(l, width - 4)));
+        if (folded.hidden > 0)
+            out.push('    ' + paint('dim', `… +${folded.hidden} lines`));
+    }
+    return out.join('\n') + '\n';
+}
+/** Truncate a string that may hold ANSI codes, measuring visible characters only. */
+function truncatePlain(s, max) {
+    // eslint-disable-next-line no-control-regex
+    const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+    return visible.length <= max ? s : truncate(visible, max);
+}

package/dist/renderer/trace.js

@@ -0,0 +1,42 @@
+import stringWidth from 'string-width';
+import { getGlyphs } from './glyphs.js';
+import { paint } from './theme.js';
+import { sanitizeControlChars } from './sanitize.js';
+import { truncateToWidth, uiWidth } from './ui-width.js';
+let emitter;
+export function setTraceEmitter(e) {
+    emitter = e;
+}
+/** One line, no terminal control: tabs/newlines flattened, other controls → space. */
+function flat(s) {
+    return sanitizeControlChars(s.replace(/\t/g, '  ').replace(/\r?\n/g, ' '));
+}
+/** `<glyph> <label> → <value>`: glyph/label/arrow dim, value plain, the whole line ≤ width. */
+function traceLine(glyph, label, value, width) {
+    const head = `${glyph} `;
+    const sep = ` ${getGlyphs().arrow} `;
+    const l = flat(label);
+    const v = flat(value);
+    const avail = Math.max(0, width - stringWidth(head) - stringWidth(sep));
+    const lw = stringWidth(l);
+    const vw = stringWidth(v);
+    let lt = l;
+    let vt = v;
+    if (lw + vw > avail) {
+        // The answer keeps at least half the room (it is what the reader scans
+        // for); a short label hands the rest to the answer.
+        const vBudget = Math.min(vw, Math.max(Math.ceil(avail / 2), avail - lw));
+        vt = truncateToWidth(v, vBudget);
+        lt = truncateToWidth(l, Math.max(0, avail - vBudget));
+    }
+    return paint('dim', head + lt + sep) + vt;
+}
+export function formatAnswerTrace(label, answer, width = uiWidth()) {
+    return traceLine(getGlyphs().trace, label, answer, width);
+}
+export function formatDecisionTrace(label, decision, width = uiWidth()) {
+    return traceLine(getGlyphs().info, label, decision, width);
+}
+export function emitTrace(line) {
+    emitter?.emit('chunk', `${line}\n`);
+}

package/dist/renderer/transcript-flow.js

@@ -0,0 +1,132 @@
+import { getLook } from './look.js';
+// eslint-disable-next-line no-control-regex
+const ESC_SEQ = /^\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07]*\x07)/;
+export class TranscriptFlow {
+    /** Newlines at the end of the output: 0 = mid-line, 1 = line start, 2 = after a blank line. */
+    nl = 1;
+    /** Spaces at a line start, held until the line proves not to be blank. */
+    held = '';
+    /** Normalise one chunk: runs of blank lines collapse to one; blank lines of spaces count as blank. */
+    feed(s) {
+        let out = '';
+        let i = 0;
+        while (i < s.length) {
+            const ch = s[i];
+            if (ch === '\x1b') {
+                const m = ESC_SEQ.exec(s.slice(i));
+                if (m) {
+                    out += m[0];
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            if (ch === '\n') {
+                this.held = '';
+                if (this.nl < 2) {
+                    out += '\n';
+                    this.nl++;
+                }
+            }
+            else if ((ch === ' ' || ch === '\t') && this.nl > 0) {
+                this.held += ch;
+            }
+            else if (ch === '\r') {
+                out += ch;
+            }
+            else {
+                out += this.held + ch;
+                this.held = '';
+                this.nl = 0;
+            }
+            i++;
+        }
+        return out;
+    }
+    /**
+     * "\n" when the output is mid-line, else "" — start the next row on a fresh
+     * line without adding a blank one. A new block row starts at column 0, so
+     * spaces held at the line start (never written) are dropped here; they
+     * would otherwise indent the row (fix round 1).
+     */
+    lineBreakIfNeeded() {
+        this.held = '';
+        return this.nl === 0 ? '\n' : '';
+    }
+    /** Forget the history (the next output starts on a fresh line). */
+    reset() {
+        this.nl = 1;
+        this.held = '';
+    }
+}
+const flows = new WeakMap();
+/** Ink Body: the flow for this emitter (created on first use). */
+export function attachFlow(emitter) {
+    let f = flows.get(emitter);
+    if (!f) {
+        f = new TranscriptFlow();
+        flows.set(emitter, f);
+    }
+    return f;
+}
+/** The flow a Body attached to this emitter, if any (raw emitters have none). */
+export function flowFor(emitter) {
+    return flows.get(emitter);
+}
+/**
+ * True when a spinner can redraw in place: classic stdout on a real terminal.
+ * Ink (an emitter) owns its frame; pipes, CI and dumb terminals cannot redraw.
+ * Polish P2: in the panels look the heartbeat stays silent when a live
+ * indicator exists — the classic spinner, or Ink's TurnStatus row.
+ */
+export function canAnimateInPlace(chunkEmitter) {
+    return !(chunkEmitter !== undefined ||
+        !process.stdout.isTTY ||
+        process.env['CI'] === '1' ||
+        process.env['TERM'] === 'dumb');
+}
+/** Classic / one-shot stdout flow. */
+export const stdoutFlow = new TranscriptFlow();
+/** Transcript write to stdout: panels normalises spacing; legacy writes verbatim. */
+export function writeStdout(s) {
+    process.stdout.write(getLook() === 'panels' ? stdoutFlow.feed(s) : s);
+}
+// eslint-disable-next-line no-control-regex
+const LEADING_NL = /^((?:\x1b\[[0-9;]*m)*)\n/;
+// eslint-disable-next-line no-control-regex
+const TRAILING_NL = /\n((?:\x1b\[[0-9;]*m)*)$/;
+// eslint-disable-next-line no-control-regex
+const ONLY_BREAKS = /^(?:\x1b\[[0-9;]*m|\n)*$/;
+/**
+ * Ink commits every batch as a <Static> node, and each node starts on its own
+ * line. So a node ending in "\n" rendered one extra blank line, and a node of
+ * only "\n" rendered two. The committer turns a byte stream into nodes that
+ * render exactly like the same bytes on a terminal:
+ *   - the one newline that ends a batch is dropped (the node boundary is it);
+ *   - a batch that is only line breaks is carried into the next batch;
+ *   - after a batch that ended mid-line, the next batch's first newline is
+ *     dropped (Ink already started a new line).
+ */
+export class InkNodeCommitter {
+    carry = '';
+    midLine = false;
+    /** The node text for this batch, or null when it is carried forward. */
+    commit(batch) {
+        let s = this.carry + batch;
+        this.carry = '';
+        if (this.midLine) {
+            s = s.replace(LEADING_NL, '$1');
+            this.midLine = false;
+        }
+        if (ONLY_BREAKS.test(s)) {
+            this.carry = s;
+            return null;
+        }
+        if (TRAILING_NL.test(s)) {
+            s = s.replace(TRAILING_NL, '$1');
+        }
+        else {
+            this.midLine = true;
+        }
+        return s;
+    }
+}

package/dist/renderer/tty.js

@@ -13,9 +13,42 @@ export function isTTY() {
  * e.g. `cspeach "/radar ZTTT_GAME"` vs interactive REPL.
  */
 export function isOneShot() {
+    if (oneShotOverride !== null)
+        return oneShotOverride;
     const args = process.argv.slice(2);
-    return args.some((a) => a === '--one-shot') || args.some((a) => !a.startsWith('-'));
+    if (args.some((a) => a === '--one-shot'))
+        return true;
+    // The token that follows a value-taking flag (`--resume <id>`,
+    // `--sap-alias <name>`) is that flag's value, not a prompt. Counting it made
+    // `cspeach --resume <id>` fall back to the classic look (live fix 2026-09-26).
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (VALUE_FLAGS.has(a)) {
+            i++;
+            continue;
+        }
+        if (!a.startsWith('-'))
+            return true;
+    }
+    return false;
 }
+/**
+ * The entry point knows whether this run is one-shot — runRepl sets false,
+ * runOneShot sets true — so an argv token the heuristic below misreads (an
+ * unknown flag's value, say) can never drop an interactive REPL to the
+ * classic renderer. null (tests, pre-entry calls) falls back to the argv scan.
+ */
+let oneShotOverride = null;
+/** Set (or clear with null) the explicit one-shot decision. */
+export function setOneShotOverride(v) {
+    oneShotOverride = v;
+}
+/** True only when the one-shot entry point declared this run one-shot. */
+export function isDeclaredOneShot() {
+    return oneShotOverride === true;
+}
+/** CLI flags (see cli.ts) whose next token is the flag's value. */
+const VALUE_FLAGS = new Set(['--resume', '--sap-alias']);
 let renderingOverride = 'classic';
 /** Set the rendering mode override. Call once at startup after loadConfig(). */
 export function setRenderingOverride(mode) {

package/dist/renderer/ui-width.js

@@ -0,0 +1,42 @@
+// src/renderer/ui-width.ts
+//
+// One width rule for live and new surfaces (CLI look piece 2, spec §1.4):
+// min(terminal columns, 100), never below 20. Non-UI caps (SLUG_MAX,
+// DETAIL_MAX …) are not width rules and stay where they are.
+import stringWidth from 'string-width';
+import { getGlyphs } from './glyphs.js';
+export const UI_MAX_WIDTH = 100;
+export const UI_MIN_WIDTH = 20;
+export function uiWidth(columns) {
+    const cols = columns ?? process.stdout.columns ?? 80;
+    return Math.min(UI_MAX_WIDTH, Math.max(UI_MIN_WIDTH, cols));
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/**
+ * Cut PLAIN text (no ANSI; paint after truncating) to `width` terminal cells.
+ * Tabs become two spaces and newlines one space, so a row never wraps or
+ * collapses inside the live frame. Wide characters count two cells and are
+ * never split. When cut, the result ends with the `more` glyph (… / ...).
+ */
+export function truncateToWidth(text, width) {
+    if (width <= 0)
+        return '';
+    const flat = text.replace(/\t/g, '  ').replace(/\r?\n/g, ' ');
+    if (stringWidth(flat) <= width)
+        return flat;
+    const more = getGlyphs().more;
+    const moreWidth = stringWidth(more);
+    if (width <= moreWidth)
+        return more.slice(0, width);
+    const budget = width - moreWidth;
+    let out = '';
+    let used = 0;
+    for (const { segment } of segmenter.segment(flat)) {
+        const w = stringWidth(segment);
+        if (used + w > budget)
+            break;
+        out += segment;
+        used += w;
+    }
+    return out + more;
+}

package/dist/renderer/verify-chain.js

@@ -18,8 +18,10 @@
  *     activation is blocked, so we don't show a fake pending step
  *   - syntax 'not_checked' → "③ syntax – (checked at activation)" —
  *     sap_set_class_include has no standalone syntax gate
- *   - ④ is always 'pending', never '✓': activation is a SEPARATE tool call
- *     (sap_activate); these write tools never activate.
+ *   - legacy line: ④ is always 'pending'. The panels change card (round 8
+ *     item 5 + final review A-I1) shows the write's own activation instead:
+ *     '✓ activated' only after the inactive-objects list confirms it,
+ *     otherwise '✗ still inactive' / '· activation unverified' / '✗ activation'.
  *
  * Consumed by the write tools in tools/sap-write.ts, emitted on the
  * 'chunk' channel so it lands between the ⏺ dispatch line and the ⎿