@cspeach/cli 1.1.17 → 1.1.19

package/dist/doctor/run.js

@@ -14,8 +14,93 @@ import { checkCredits } from './checks/credits.js';
 import { checkForgeRules } from './checks/forge-rules.js';
 import { checkSystemRoles } from './checks/system-roles.js';
 import { checkStandards } from './checks/standards.js';
-export async function runDoctor() {
-    console.log(chalk.cyan.bold('\nCSPeach — doctor\n'));
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
+import { isNoColor } from '../renderer/color-mode.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
+import { CLI_VERSION } from '../lib/version.js';
+const NAME_WIDTH = 20;
+/** Check messages can carry server text (HTTP bodies, SAP errors): one line, no control characters. */
+const oneLine = (s) => sanitizeControlChars(s).replace(/\s*\r?\n\s*/g, ' ').trim();
+/** Human name of the terminal CSPeach is running in (for the doctor title). */
+export function terminalName(env = process.env, platform = process.platform) {
+    if (env['WT_SESSION'])
+        return 'Windows Terminal';
+    const tp = env['TERM_PROGRAM'];
+    if (tp === 'vscode')
+        return 'VS Code terminal';
+    if (tp === 'iTerm.app')
+        return 'iTerm2';
+    if (tp === 'Apple_Terminal')
+        return 'Terminal.app';
+    if (tp)
+        return oneLine(tp);
+    if (env['TERM'])
+        return oneLine(env['TERM']);
+    return platform === 'win32' ? 'Windows console' : 'unknown terminal';
+}
+export function colourLevelName(level, noColor = isNoColor()) {
+    if (noColor)
+        return 'no colour (NO_COLOR)';
+    if (level >= 3)
+        return 'truecolor';
+    if (level === 2)
+        return '256 colours';
+    if (level === 1)
+        return '16 colours';
+    return 'no colour';
+}
+/** 1 when any check failed; a skipped check (C.2 permission skip) is not a failure. */
+export function doctorExitCode(checks) {
+    return checks.some((c) => !c.ok && !c.skipped) ? 1 : 0;
+}
+export function formatDoctorTitle(meta) {
+    return ['', `${chalk.bold('CSPeach doctor')}  ${paint('dim', `${meta.version} · ${meta.terminal} · ${meta.colour}`)}`, ''];
+}
+export function formatDoctorRows(checks) {
+    const g = getGlyphs();
+    const lines = [];
+    let passed = 0;
+    let warnings = 0;
+    let failed = 0;
+    for (const c of checks) {
+        let glyph;
+        if (c.skipped) {
+            glyph = paint('warn', g.attention);
+            warnings++;
+        }
+        else if (c.ok) {
+            glyph = paint('ok', g.done);
+            passed++;
+        }
+        else {
+            glyph = paint('bad', g.failed);
+            failed++;
+        }
+        lines.push(`${glyph} ${oneLine(c.name).padEnd(NAME_WIDTH)} ${paint('dim', oneLine(c.message))}`);
+        if (c.hint && oneLine(c.hint) !== '')
+            lines.push(`  ${paint('dim', 'Next:')} ${oneLine(c.hint)}`);
+    }
+    const summary = `${passed} of ${checks.length} checks passed · ${warnings} warning${warnings === 1 ? '' : 's'} · ${failed} failed`;
+    lines.push('', paint('dim', summary), '');
+    return lines;
+}
+/**
+ * Re-review 2 item 3 — the forge-rules probe writes to SAP (create, lock,
+ * write, snapshot list, delete); any throw there (lock refused, snapshot
+ * store unreadable, connection drop) is a failed row with a readable one-line
+ * message, never a crashed doctor run.
+ */
+async function safeForgeRules() {
+    try {
+        return await checkForgeRules();
+    }
+    catch (err) {
+        const msg = String(err?.message ?? err).replace(/\s+/g, ' ').trim().slice(0, 160);
+        return { name: 'forge-rules', ok: false, message: `Rule 7/10 probe failed: ${msg}` };
+    }
+}
+export async function collectChecks() {
     const cfg = await loadConfig();
     const checks = [];
     checks.push(await checkProxy());
@@ -30,23 +115,19 @@ export async function runDoctor() {
     checks.push(await checkCert());
     checks.push(await checkSkill());
     checks.push(await checkKeychainFallback());
-    checks.push(await checkForgeRules());
+    checks.push(await safeForgeRules());
     checks.push(await checkStandards());
-    let failed = 0;
-    for (const c of checks) {
-        const icon = c.skipped
-            ? chalk.yellow('-  ')
-            : c.ok
-                ? chalk.green('OK ')
-                : chalk.red('X  ');
-        console.log(`  ${icon} ${c.name.padEnd(22)} ${c.message}`);
-        if (c.hint)
-            console.log(chalk.gray(`      -> ${c.hint}`));
-        if (!c.ok && !c.skipped)
-            failed++;
-    }
-    console.log(failed === 0
-        ? chalk.green('\nAll checks passed.\n')
-        : chalk.yellow(`\n${failed} check(s) failed.\n`));
-    return failed === 0 ? 0 : 1;
+    return checks;
+}
+export async function runDoctor(deps = {}) {
+    const print = deps.print ?? ((l) => console.log(l));
+    const meta = deps.meta ?? { version: CLI_VERSION, terminal: terminalName(), colour: colourLevelName(chalk.level) };
+    // Title first: the checks take seconds (network), and the user should see
+    // that doctor is running.
+    for (const l of formatDoctorTitle(meta))
+        print(l);
+    const checks = await (deps.collect ?? collectChecks)();
+    for (const l of formatDoctorRows(checks))
+        print(l);
+    return doctorExitCode(checks);
 }

package/dist/index.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { main } from './cli.js';
-main(process.argv).then((code) => process.exit(code), (err) => {
+import { gracefulExit } from './lib/graceful-exit.js';
+// Round 7 item 5 — close fetch's sockets before exiting (Windows libuv
+// assertion on process.exit with live undici handles, nodejs/node#56645).
+main(process.argv).then((code) => gracefulExit(code), (err) => {
     console.error('cspeach: unhandled error:', err);
-    process.exit(1);
+    return gracefulExit(1);
 });

package/dist/lib/graceful-exit.js

@@ -0,0 +1,56 @@
+/**
+ * Round 7 item 5 — exit without tearing live network handles down under Node.
+ *
+ * On Windows, process.exit() while fetch (Node's built-in undici) still holds
+ * sockets can abort with the libuv assertion
+ * `!(handle->flags & UV_HANDLE_CLOSING), src\win\async.c line 76`
+ * (known Node bug: nodejs/node#56645, #64322). The matrix saw it once after a
+ * routing cancel + /exit. We close fetch's global dispatcher first and give the
+ * loop a short, capped chance to settle, then exit as before.
+ *
+ * Review r7 M-1 — drain with close() (in-flight requests finish) and only
+ * destroy() when that does not finish inside the cap. A fire-and-forget fetch
+ * that rejects inside the window must not surface as a crash on the way out,
+ * so a no-op unhandledRejection guard is installed for the window only.
+ */
+/** The global symbol Node's bundled undici stores its dispatcher under. */
+export const UNDICI_DISPATCHER = Symbol.for('undici.globalDispatcher.1');
+function capped(p, ms) {
+    let timer;
+    return Promise.race([
+        p.then(() => true, () => true),
+        new Promise((r) => { timer = setTimeout(() => r(false), ms); }),
+    ]).finally(() => { if (timer)
+        clearTimeout(timer); });
+}
+function call(fn, self) {
+    try {
+        return Promise.resolve(fn?.call(self));
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+}
+export async function gracefulExit(code, opts = {}) {
+    const exit = opts.exit ?? ((c) => process.exit(c));
+    const graceMs = opts.graceMs ?? 250;
+    process.exitCode = code;
+    const guard = () => { };
+    process.on('unhandledRejection', guard);
+    try {
+        const dispatcher = globalThis[UNDICI_DISPATCHER];
+        if (dispatcher) {
+            let done = false;
+            if (typeof dispatcher.close === 'function')
+                done = await capped(call(dispatcher.close, dispatcher), graceMs);
+            if (!done && typeof dispatcher.destroy === 'function')
+                await capped(call(dispatcher.destroy, dispatcher), graceMs);
+        }
+        // One more loop turn so socket 'close' callbacks run before the teardown.
+        await new Promise((r) => setImmediate(r));
+    }
+    finally {
+        process.off('unhandledRejection', guard);
+    }
+    exit(code);
+}

package/dist/lib/piped-prompt.js

@@ -0,0 +1,65 @@
+// A command head: "/name" followed by a space or the end of the line —
+// "/cost", "/abap-explain ZFOO". A path ("/sap/bc/adt/…", "/usr/sap/…") has
+// a second "/" in its first token and is prose (final review B M-3).
+const SCRIPT_LINE = /(^|\n)[ \t]*\/[A-Za-z][\w-]*(?=[ \t]|\r?\n|$)/;
+export function readPipedPrompt(stdin, opts = {}) {
+    if (stdin.isTTY)
+        return Promise.resolve({ kind: 'repl' });
+    const firstMs = opts.firstMs ?? 250;
+    const endMs = opts.endMs ?? 1500;
+    return new Promise((resolve) => {
+        const chunks = [];
+        let sawData = false;
+        let settled = false;
+        let t1;
+        let t2;
+        const text = () => Buffer.concat(chunks).toString('utf8').replace(/^/, '');
+        const done = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            if (t1)
+                clearTimeout(t1);
+            if (t2)
+                clearTimeout(t2);
+            stdin.off('readable', onReadable);
+            stdin.off('end', onEnd);
+            resolve(r);
+        };
+        const giveBack = () => {
+            if (settled)
+                return;
+            if (chunks.length > 0)
+                stdin.unshift(Buffer.concat(chunks));
+            done({ kind: 'repl' });
+        };
+        const onEnd = () => {
+            const t = text().trim();
+            done(t ? { kind: 'prompt', text: t } : { kind: 'repl' });
+        };
+        const onReadable = () => {
+            // EOF with nothing read: leave it unread so the REPL sees the end.
+            if (!sawData && stdin.readableLength === 0) {
+                done({ kind: 'repl' });
+                return;
+            }
+            let c;
+            while ((c = stdin.read()) !== null)
+                chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c));
+            if (SCRIPT_LINE.test(text())) {
+                giveBack();
+                return;
+            }
+            if (!sawData) {
+                sawData = true;
+                if (t1)
+                    clearTimeout(t1);
+                t2 = setTimeout(giveBack, endMs);
+            }
+        };
+        stdin.on('readable', onReadable);
+        stdin.on('end', onEnd);
+        t1 = setTimeout(() => { if (!sawData)
+            done({ kind: 'repl' }); }, firstMs);
+    });
+}

package/dist/lock-contention.js

@@ -1,7 +1,7 @@
 import { select } from '@inquirer/prompts';
-import chalk from 'chalk';
+import { formatAttention } from './renderer/notice-shape.js';
 export async function handleLockConflict(info) {
-    console.log(chalk.yellow(`\n⚠  ${info.object} is locked by ${info.user} since ${info.lockTime}.`));
+    console.log('\n' + formatAttention({ text: `${info.object} is locked`, fact: `by ${info.user} since ${info.lockTime}` }).trimEnd());
     return (await select({
         message: 'How do you want to proceed?',
         choices: [

package/dist/one-shot.js

@@ -1,9 +1,13 @@
 import chalk from 'chalk';
 import { loadConfig, resolveLocalBuild, resolveStandalone } from './config/loader.js';
+import { applyColorMode } from './renderer/color-mode.js';
+import { formatAttention, formatInfo } from './renderer/notice-shape.js';
+import { formatRoutingLine } from './renderer/routing-line.js';
 import { createOfflineAdtClient } from './sap/offline-adt-client.js';
 import { STANDALONE_ALIAS } from './tools/index.js';
 import { getStore } from './auth/api-key.js';
 import { getConnection } from './sap/connection-manager.js';
+import { unreachableCode, unreachableMessage } from './sap/unreachable.js';
 import { AdtClient } from '@cspeach/sap-client';
 import { makeSessionId, saveSession } from './session/store.js';
 import { newSession } from './session/schema.js';
@@ -13,13 +17,23 @@ import { createProviderForMode } from './agent/providers/factory.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
 import { classifyPrompt, parseShortcut, rejectUnknownSkill } from './router/classifier.js';
-import { setRenderingOverride, setHeadlessOverride } from './renderer/tty.js';
+import { routingFailureFromResult, routingFailureOneShotLine } from './router/routing-failure.js';
+import { startThinkingHeartbeat, ROUTING_HEARTBEAT_THRESHOLDS } from './renderer/thinking-heartbeat.js';
+import { setRenderingOverride, setHeadlessOverride, setOneShotOverride } from './renderer/tty.js';
+import { resolveRenderingMode } from './renderer/rendering-mode.js';
+import { setLook, setBackground } from './renderer/look.js';
 import { alwaysDeclinePreviewHook } from './repl/update-method-preview-hook.js';
 import { createClassicOutputEmitter } from './renderer/notices.js';
+import { AnswerTrim } from './renderer/answer-trim.js';
+import { writeStdout } from './renderer/transcript-flow.js';
+import { writeAboveSpinner, aboveSpinnerAddsNewline } from './renderer/tool-widget.js';
 import { todoEmitter } from './ui/todo-emitter.js';
 import { applyLocalBuildConfig, applyStandaloneFileTools } from './tools/local-build.js';
 import { getEffectiveWriteMode } from './repl/mode-cycle.js';
 import { initCredits } from './cost/credits-wire.js';
+import { formatTurnReceipt, turnSpendText } from './renderer/footer-line.js';
+import { snapshotTurnStart, computeTurnFacts } from './repl/post-turn-status.js';
+import { globalCredits } from './cost/credits.js';
 // Side-effect imports for tool registration.
 import './tools/sap-read.js';
 import './tools/sap-write.js';
@@ -52,11 +66,18 @@ import './tools/subagent/monitor_emit.js';
 import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 export async function runOneShot(prompt, opts) {
+    applyColorMode(); // NO_COLOR (piece 2 §1.2)
     const cfg = await loadConfig();
     // Standalone (2026-09-16) — run with no SAP system at all: no connection, no
     // AdtClient, SAP tools hidden. `--no-sap` for this run, or `no_sap = true`.
     const standalone = resolveStandalone(cfg, opts?.noSap === true);
-    setRenderingOverride(cfg.ui.rendering);
+    // One-shot output is unchanged by the classic retirement: `auto` never
+    // mounts Ink for a one-shot run. CSPEACH_UI=classic is honoured here too;
+    // the stored-value rewrite happens only on an interactive start.
+    setOneShotOverride(true);
+    setRenderingOverride(resolveRenderingMode(cfg.ui.rendering).mode);
+    setLook(cfg.ui.look);
+    setBackground(cfg.ui.background);
     // model-governance step 2d — fire-and-forget fetch of the served model-config
     // (managed mode only, never blocks). A turn that starts before it lands uses
     // the built-ins (fail-safe).
@@ -80,8 +101,10 @@ export async function runOneShot(prompt, opts) {
     // write_mode stands on its own.
     const oneShotAlias = standalone ? undefined : (opts?.sapAlias ?? Object.keys(cfg.sap)[0]);
     const oneShotRole = oneShotAlias !== undefined ? cfg.sap[oneShotAlias]?.role : undefined;
+    // Fix round 3 (item 7): every startup notice below goes to STDERR — piped
+    // stdout stays the answer only (spec §8).
     if (getEffectiveWriteMode(cfg.write_mode, oneShotRole) === 'advisory-only') {
-        console.log(chalk.yellow('⚠  Advisory mode: writes will be proposed, not executed.'));
+        console.error(formatAttention({ text: 'Write mode: advisory', fact: 'writes are proposed, not executed' }).trimEnd());
     }
     // local_build toggle — force-enable the flag-gated filesystem tools AND
     // shell_exec BEFORE the (single) turn when persisted-on. Resolve with backward
@@ -91,11 +114,11 @@ export async function runOneShot(prompt, opts) {
     {
         const announce = applyLocalBuildConfig(resolveLocalBuild(cfg), process.cwd());
         if (announce)
-            console.log(chalk.dim(announce));
+            console.error(chalk.dim(announce));
         // 2026-09-17 — standalone writes files by contract; enable the file tools
         // without the separate local_build step (see repl.tsx for the live case).
         else if (standalone)
-            console.log(chalk.dim(applyStandaloneFileTools(process.cwd())));
+            console.error(chalk.dim(applyStandaloneFileTools(process.cwd())));
     }
     const store = await getStore();
     if (!(await store.get())) {
@@ -104,9 +127,9 @@ export async function runOneShot(prompt, opts) {
     }
     // Credits (2026-09-16) — resolve the display mode before the turn runs, so
     // the per-turn cost JSONL records the ledger charge and nothing downstream
-    // can print a dollar to a managed customer. One-shot prints no cost figure
-    // of its own today, but the agent loop's cost-log path is shared with the
-    // REPL and must not diverge. Capped + fail-safe; BYOK/local skip the call.
+    // can print a dollar to a managed customer — including the one-line stderr
+    // receipt after the turn (piece 2 I3a), and the agent loop's cost-log path,
+    // which is shared with the REPL. Capped + fail-safe; BYOK/local skip the call.
     await initCredits(cfg, async () => (await store.get()) ?? '');
     const aliases = Object.keys(cfg.sap);
     let alias;
@@ -117,12 +140,12 @@ export async function runOneShot(prompt, opts) {
         // filter + dispatch guard.
         alias = STANDALONE_ALIAS;
         adt = createOfflineAdtClient();
-        console.log(chalk.dim('Standalone mode: no SAP system connected — skills work from pasted code. ' +
+        console.error(chalk.dim('Standalone mode: no SAP system connected — skills work from pasted code. ' +
             'Connect later with: cspeach config add-sap'));
         // One-shot is headless by design (no prompts), so an unanswered standalone
         // profile can't be filled in here — say how, and carry on with "unknown".
         if (!cfg.standalone) {
-            console.log(chalk.dim('Standalone profile not set — run: cspeach config set standalone.platform ...'));
+            console.error(chalk.dim('Standalone profile not set — run: cspeach config set standalone.platform ...'));
         }
     }
     else {
@@ -133,9 +156,19 @@ export async function runOneShot(prompt, opts) {
         // C.1 — --sap-alias flag override
         alias = opts?.sapAlias ?? aliases[0];
         if (opts?.sapAlias) {
-            console.log(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+            console.error(chalk.dim(`Using --sap-alias ${opts.sapAlias}`));
+        }
+        let conn;
+        try {
+            conn = await getConnection(alias, cfg.sap[alias]);
+        }
+        catch (err) {
+            const code = unreachableCode(err);
+            if (!code)
+                throw err;
+            console.error(unreachableMessage(alias, cfg.sap[alias].host, cfg.sap[alias].port, code));
+            return 1;
         }
-        const conn = await getConnection(alias, cfg.sap[alias]);
         adt = new AdtClient(conn);
     }
     const session = newSession(makeSessionId(), alias, null, resolveModelRole('session_default', cfg));
@@ -155,30 +188,51 @@ export async function runOneShot(prompt, opts) {
         skill = parsed.skill;
     }
     else {
-        // One-shot has no interactive picker — always uses top-1 and prints the
-        // confidence band on a dim prelude line. If < 0.6, emit a stderr warning
-        // with top-3 alternates so the user can rerun with an explicit /skill.
-        const c = await classifyPrompt(body, {
-            sap_system: alias,
-            last_skill: session.last_skill ?? null,
-            last_object: parsed.object ?? session.last_object ?? null,
-        });
+        // One-shot has no interactive picker — always uses top-1 and names it on
+        // a dim stderr line. If < 0.6, add a stderr `!` notice with the top-3
+        // candidates so the user can rerun with an explicit /skill.
+        // Fix round 3 (item 8) — say we are routing while the classifier runs
+        // (stderr; nothing prints when it answers within a second).
+        const routingBeat = startThinkingHeartbeat({ thresholds: ROUTING_HEARTBEAT_THRESHOLDS });
+        let c;
+        try {
+            c = await classifyPrompt(body, {
+                sap_system: alias,
+                last_skill: session.last_skill ?? null,
+                last_object: parsed.object ?? session.last_object ?? null,
+            });
+        }
+        catch (err) {
+            // Round 4 item 4 — a missing key here was an uncaught `no_api_key`
+            // with a stack (and a libuv assertion on exit). One clean line, exit 1.
+            if (err instanceof Error && err.message === 'no_api_key') {
+                console.error('No API key configured. Run `cspeach` (interactive) first to set one.');
+                return 1;
+            }
+            throw err;
+        }
+        finally {
+            routingBeat.stop();
+        }
         if (c.offline) {
             // Remote classify failed twice — local-rules fallback fired. Print
             // to stderr so it doesn't pollute stdout for scripted callers, but
             // is still visible.
-            console.error(chalk.dim(`[offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
+            // Fix 9 (2026-09-26): same true wording as the REPL — a timeout is not "offline".
+            console.error(chalk.dim(routingFailureOneShotLine(routingFailureFromResult(c), c.transport_error)));
         }
-        const pct = Math.round(c.confidence * 100);
+        // Piece 2 (spec §8/§9) — routing chatter goes to STDERR so piped stdout
+        // stays the answer only. Confidence percentages are dropped everywhere.
         if (c.screenshot)
-            console.log(chalk.dim(`┄ Screenshot: ${c.screenshot}`));
+            process.stderr.write(formatInfo(`Screenshot: ${c.screenshot}`));
+        process.stderr.write(formatRoutingLine({ kind: 'using', skill: c.skill }));
         if (c.confidence < 0.6) {
             const alternates = [c.skill, ...c.alternates].slice(0, 3).map((s) => `/${s}`).join(', ');
-            console.error(chalk.yellow(`[classifier] Low confidence (${pct}%). Using /${c.skill}. ` +
-                `Candidates: ${alternates}. Rerun with an explicit /skill to override.`));
-        }
-        else {
-            console.log(chalk.dim(`┄ Routed to /${c.skill} (${pct}%)`));
+            process.stderr.write(formatAttention({
+                text: 'Low confidence',
+                fact: `candidates: ${alternates}`,
+                next: 'rerun with an explicit /skill to override',
+            }));
         }
         skill = c.skill;
     }
@@ -201,18 +255,59 @@ export async function runOneShot(prompt, opts) {
             throw new Error('No API key configured');
         return key;
     });
-    await runTurn({
-        provider,
-        userMessage: body,
-        skill,
-        // B2 fix (2026-06-12): one-shot runs render tool notices ('warn'/'info'
-        // — Rule 9 transport overrides, snapshot lines) to stdout instead of
-        // dropping them. Headless transcripts need these for auditability.
-        // Task 5 (ux-wave2): todoEmitter wired for the uniform top-level-ctx
-        // contract — no listener exists in one-shot, so emits are no-ops, but
-        // "top-level ctxs carry it / subagent ctxs omit it" stays the single
-        // rule (see ui/todo-emitter.ts).
-        ctx: { adt, sapAlias: alias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: alwaysDeclinePreviewHook, chunkEmitter: createClassicOutputEmitter(), todoEmitter },
+    const turnSnapshot = snapshotTurnStart(session);
+    // Round 6 item 4f — stdout is the answer, trimmed: no blank lines before
+    // it, exactly one newline after it.
+    const answerTrim = new AnswerTrim();
+    const answerEmitter = createClassicOutputEmitter((s) => {
+        const out = answerTrim.feed(s);
+        if (!out)
+            return;
+        // Review M3 — a painting spinner ends the line itself; tell the trim so
+        // its held newline does not become a stray blank line.
+        const forced = aboveSpinnerAddsNewline(out);
+        writeAboveSpinner(out, writeStdout);
+        if (forced)
+            answerTrim.noteForcedNewline();
     });
+    // Owner ruling (r3 M11) — stdout is the answer only, everywhere: tool
+    // notices (Rule 9 transport overrides, snapshot lines, the write chain)
+    // and tool rows go to STDERR in one-shot.
+    const noticeEmitter = createClassicOutputEmitter((s) => { process.stderr.write(s); });
+    try {
+        await runTurn({
+            provider,
+            userMessage: body,
+            skill,
+            // Fix round 7 item 2 — runTurn reads params.chunkEmitter (NOT
+            // ctx.chunkEmitter) for the answer stream; without this the trim never
+            // ran. Liveness stays off stdout (see loop.ts livenessEmitter).
+            chunkEmitter: answerEmitter,
+            // B2 fix (2026-06-12): one-shot runs render tool notices ('warn'/'info'
+            // — Rule 9 transport overrides, snapshot lines) instead of dropping them;
+            // headless transcripts need them for auditability. Owner ruling (r3 M11):
+            // they go to STDERR (noticeEmitter) — stdout is the answer only.
+            // Task 5 (ux-wave2): todoEmitter wired for the uniform top-level-ctx
+            // contract — no listener exists in one-shot, so emits are no-ops, but
+            // "top-level ctxs carry it / subagent ctxs omit it" stays the single
+            // rule (see ui/todo-emitter.ts).
+            ctx: { adt, sapAlias: alias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: alwaysDeclinePreviewHook, chunkEmitter: noticeEmitter, todoEmitter },
+        });
+    }
+    finally {
+        // Review M2 — even when the turn throws, the answer so far ends with its
+        // newline (and any held colour reset) instead of being cut mid-line.
+        const answerTail = answerTrim.end();
+        if (answerTail)
+            writeStdout(answerTail);
+    }
+    // Piece 2 (spec §8) — the one-line receipt, on STDERR (stdout = the answer).
+    const facts = computeTurnFacts(session, turnSnapshot);
+    process.stderr.write(formatTurnReceipt({
+        skill,
+        tokens: facts.turnTokens,
+        spend: turnSpendText({ costThisTurn: facts.turnCost, credits: globalCredits.snapshot() }),
+        ms: facts.elapsedMs,
+    }) + '\n');
     return 0;
 }

package/dist/projects/answer-blockers.js

@@ -1,6 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import { readProjectFile } from './status.js';
 import { validateEnvelope } from './validate.js';
+import { askYesNo } from './yes-no.js';
 /**
  * The still-open BLOCKER-severity questions of a spec-gap envelope, in item
  * order. Returns [] for any non-spec-gap artefact (only spec-gap has gaps with
@@ -81,7 +82,11 @@ export async function offerAnswerBlockers(args) {
     const blockers = openBlockers(env);
     if (blockers.length === 0)
         return null;
-    const reply = await args.prompt(`Answer the ${blockers.length} unanswered blocker(s) now? [y/N]: `);
+    const reply = await askYesNo({
+        question: `Answer the ${blockers.length} unanswered blocker(s) now?`,
+        confirm: args.confirm,
+        prompt: args.prompt,
+    });
     if (!affirmative(reply))
         return null;
     const answers = new Map();

package/dist/projects/handover-md.js

@@ -17,32 +17,33 @@ import { basename, dirname, join } from 'node:path';
 import chalk from 'chalk';
 import { statusesFromItems, computeNextPhase, isPhaseSatisfied, planCompletionLines, } from './plan-run.js';
 import { projectFilename } from './filename.js';
+import { UNICODE_GLYPHS } from '../renderer/glyphs.js';
 import { readProjectFile } from './status.js';
 /**
- * Plain-text mirror of the tracker's auditGlyph wording (plan-run.ts) — same
- * words, no chalk. Empty-audit phases render NO segment, matching the
- * tracker's legacy-envelope behaviour. The `default` arm is deliberate
- * forward-compat: an unknown future PlanAuditState reads "audit not run"
- * instead of crashing the projection.
+ * Plain-text mirror of the tracker's audit words (plan-run.ts, piece 2 §4) —
+ * same words, no chalk, LITERAL unicode glyphs: this is file content, so it
+ * never follows a terminal's ASCII fallback. Empty-audit phases render NO
+ * segment, matching the tracker's legacy-envelope behaviour. The `default`
+ * arm is deliberate forward-compat: an unknown future PlanAuditState reads
+ * "audit not run" instead of crashing the projection.
  */
 function auditWords(audit) {
     if (!audit)
         return null;
     switch (audit.state) {
-        case 'passed': return '✔ audited';
+        case 'passed': return '✓ audited';
         case 'warn': {
-            // Non-blocking tier — passed WITH notes. Plain-text mirror of the
-            // tracker's warn glyph; count comes from findings.
+            // Non-blocking tier — passed WITH notes; count comes from findings.
             const n = audit.findings?.length ?? 0;
-            return `⚠ passed with ${n} note${n === 1 ? '' : 's'}`;
+            return `! ${n} note${n === 1 ? '' : 's'}`;
         }
-        case 'waived': return `✎ waived${audit.waiveCategory ? ` (${audit.waiveCategory})` : ''}`;
-        case 'failed': return '✖ audit failed';
-        case 'not_audited_hand_edited': return '✋ hand-edited';
+        case 'waived': return `· waived${audit.waiveCategory ? ` (${audit.waiveCategory})` : ''}`;
+        case 'failed': return '✗ audit failed';
+        case 'not_audited_hand_edited': return '· hand-edited';
         case 'pending':
         case 'infra_failed':
         default:
-            return '⚠ audit not run';
+            return '! audit not run';
     }
 }
 /**
@@ -117,7 +118,7 @@ export function renderPlanHandover(envelope) {
     // resolves — version-less/newest-version resolution in plan-resume.ts
     // matches the whole family.
     const nextAction = allSatisfied
-        ? planCompletionLines(content.phases).join(' ')
+        ? planCompletionLines(content.phases, UNICODE_GLYPHS).join(' ')
         : `/abap-plan --resume @${projectFilename({
             title: envelope.title, artefactType: 'plan', id: envelope.id, version: envelope.version,
         })}`;