@cspeach/cli 1.1.18 → 1.1.20

package/dist/models/server-config.js

@@ -4,6 +4,9 @@
 // The proxy serves `GET {proxy_url}/v1/model-config` (Task 3):
 //   { roles: { session_default, audit, compact, router },
 //     pricing: Record<model, { inputPer1M, outputPer1M, cacheReadPer1M, cacheCreatePer1M? }>,
+//     effort: { session_default?, audit?, compact? },          (Task 4; {} = none)
+//     tool_loading: 'deferred' | 'static',                     (Task 4)
+//     auto_compact_tokens: number | null,                      (Task 4; null = CLI default)
 //     updated_at }
 // top-level keys snake_case, pricing entries camelCase, Cache-Control 60s, no auth.
 //
@@ -24,6 +27,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { cspeachRoot } from '../config/paths.js';
+export const EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max'];
+const EFFORT_ROLE_KEYS = ['session_default', 'audit', 'compact'];
+export function isEffort(v) {
+    return typeof v === 'string' && EFFORT_VALUES.includes(v);
+}
 // ── Synchronous module snapshot ───────────────────────────────────────────────
 let snapshot = null;
 /** The current served-config snapshot, or null (⇒ built-ins win). Pure sync read. */
@@ -60,6 +68,27 @@ function coercePricing(raw) {
         ? raw
         : {};
 }
+/** Keep only valid effort levels for the known effort roles. */
+function coerceEffort(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return out;
+    const r = raw;
+    for (const k of EFFORT_ROLE_KEYS) {
+        if (isEffort(r[k]))
+            out[k] = r[k];
+    }
+    return out;
+}
+function coerceToolLoading(raw) {
+    return raw === 'deferred' || raw === 'static' ? raw : undefined;
+}
+/** Same bounds as the proxy column CHECK (migration 021). */
+function coerceAutoCompactTokens(raw) {
+    return typeof raw === 'number' && Number.isInteger(raw) && raw >= 10_000 && raw <= 10_000_000
+        ? raw
+        : undefined;
+}
 /**
  * Map a served (or cached) document to a ServerModelConfig, or null when the
  * shape is unusable. `fetchedAt`, when provided, is preserved (disk-cache read);
@@ -73,9 +102,14 @@ function coerceDocument(body, fetchedAt) {
     const roles = coerceRoles(b.roles);
     if (Object.keys(roles).length === 0)
         return null;
+    const toolLoading = coerceToolLoading(b.tool_loading);
+    const autoCompactTokens = coerceAutoCompactTokens(b.auto_compact_tokens);
     return {
         roles,
         pricing: coercePricing(b.pricing),
+        effort: coerceEffort(b.effort),
+        ...(toolLoading ? { tool_loading: toolLoading } : {}),
+        ...(autoCompactTokens !== undefined ? { auto_compact_tokens: autoCompactTokens } : {}),
         fetchedAt: typeof fetchedAt === 'string' && fetchedAt.length > 0 ? fetchedAt : new Date().toISOString(),
     };
 }
@@ -112,9 +146,11 @@ async function readFreshDiskCache() {
 // ── Public entrypoint ─────────────────────────────────────────────────────────
 /**
  * Fetch the served model-config and update the module snapshot. Managed mode
- * ONLY. Fire-and-forget from startup; NEVER throws.
+ * ONLY. NEVER throws. Startup awaits it with `timeoutMs: 1500` (Task 3) so the
+ * session model is pinned from the served config before call 0; a slower
+ * fetch aborts and falls back to a fresh disk cache. Default cap: 5 s.
  */
-export async function loadServerModelConfig(cfg) {
+export async function loadServerModelConfig(cfg, opts) {
     // Non-managed modes bypass the proxy for inference and must never fetch.
     if (cfg.llm?.mode !== 'managed')
         return;
@@ -125,7 +161,7 @@ export async function loadServerModelConfig(cfg) {
         // rejection that crashes startup. Keep it caught like every other failure.
         const url = `${cfg.proxy_url.replace(/\/$/, '')}/v1/model-config`;
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? FETCH_TIMEOUT_MS);
         timer.unref?.();
         let body;
         try {
@@ -153,3 +189,122 @@ export async function loadServerModelConfig(cfg) {
             snapshot = cached;
     }
 }
+let customerSnapshot = null;
+/** The current customer snapshot, or null (⇒ layer skipped). Pure sync read. */
+export function getCustomerModelConfig() {
+    return customerSnapshot;
+}
+/** Test-only setter for the customer snapshot. */
+export function __setCustomerModelConfigForTests(c) {
+    customerSnapshot = c;
+}
+function coerceCustomer(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return null;
+    const b = body;
+    const model = typeof b.model === 'string' && b.model.trim().length > 0 ? b.model.trim() : null;
+    return {
+        model,
+        effort: isEffort(b.effort) ? b.effort : null,
+        enforced: b.enforced === true,
+    };
+}
+/**
+ * Fetch the caller's customer model-config and update the customer snapshot.
+ * NEVER throws; on any failure the snapshot is null.
+ */
+export async function loadCustomerModelConfig(cfg, getBearer, opts) {
+    customerSnapshot = null;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? FETCH_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+        // The keychain read shares the cap: a hanging getBearer loses the race to
+        // the same timer that aborts the fetch (review M1).
+        const aborted = new Promise((_resolve, reject) => {
+            controller.signal.addEventListener('abort', () => reject(new Error('timeout')), { once: true });
+        });
+        aborted.catch(() => { });
+        const key = await Promise.race([getBearer(), aborted]);
+        if (!key)
+            return;
+        const url = `${cfg.proxy_url.replace(/\/$/, '')}/v1/me/model-config`;
+        const r = await fetch(url, {
+            headers: { Authorization: `Bearer ${key}` },
+            signal: controller.signal,
+        });
+        if (!r.ok)
+            return;
+        customerSnapshot = coerceCustomer(await r.json());
+    }
+    catch {
+        customerSnapshot = null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ── Tool-loading kill switch (Task 16, ruling F13) ───────────────────────────
+//
+// Managed mode reads `tool_loading` from the served snapshot above. BYOK never
+// loads that snapshot (its roles must not steer a BYOK session), so it reads
+// ONLY `tool_loading` from the same public endpoint — and only when signed in
+// (a CSPeach bearer exists). No bearer, any failure, or an invalid value ⇒
+// undefined, which resolveToolLoading turns into 'static' for BYOK. No disk
+// cache. NEVER throws. Startup runs it alongside the other loads under the
+// same 1.5 s cap.
+let byokToolLoading;
+/** Test-only setter for the BYOK tool-loading value. */
+export function __setByokToolLoadingForTests(v) {
+    byokToolLoading = v;
+}
+/**
+ * The served tool-loading mode: the managed snapshot's `tool_loading`, else
+ * the BYOK fetch result, else undefined. Pure sync read.
+ */
+export function servedToolLoading() {
+    return snapshot?.tool_loading ?? byokToolLoading;
+}
+/**
+ * Task 21 fix round (controller ruling) — the managed proxy's capability
+ * signal: its served config carries `tool_loading` (migration 021 and later).
+ * An older proxy serves no such field and adds none of the new betas, so the
+ * loop sends the new wire shapes (deferred tools, tool search, tool_addition,
+ * `thinking.block_binding`) on the managed path only when this is true.
+ * Managed snapshot only; BYOK never reads it. Pure sync read.
+ */
+export function managedProxyServesNewShapes() {
+    return snapshot?.tool_loading !== undefined;
+}
+/** BYOK only: fetch `/v1/model-config` and keep its `tool_loading`. */
+export async function fetchToolLoadingMode(cfg, getBearer, opts) {
+    byokToolLoading = undefined;
+    if (cfg.llm?.mode !== 'byok')
+        return undefined;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? FETCH_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+        const aborted = new Promise((_resolve, reject) => {
+            controller.signal.addEventListener('abort', () => reject(new Error('timeout')), { once: true });
+        });
+        aborted.catch(() => { });
+        const key = await Promise.race([getBearer(), aborted]);
+        if (!key)
+            return undefined;
+        const url = `${cfg.proxy_url.replace(/\/$/, '')}/v1/model-config`;
+        const r = await fetch(url, { signal: controller.signal });
+        if (!r.ok)
+            return undefined;
+        const body = (await r.json());
+        byokToolLoading = coerceToolLoading(body && typeof body === 'object' ? body.tool_loading : undefined);
+        return byokToolLoading;
+    }
+    catch {
+        byokToolLoading = undefined;
+        return undefined;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/one-shot.js

@@ -1,25 +1,39 @@
 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';
 import { resolveModelRole } from './models/resolve.js';
-import { loadServerModelConfig } from './models/server-config.js';
+import { loadServerModelConfig, loadCustomerModelConfig, fetchToolLoadingMode } from './models/server-config.js';
 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';
@@ -30,6 +44,7 @@ import './tools/ask-question.js';
 import './tools/dispatch-skill.js';
 import './tools/todo.js';
 import './tools/filesystem/file-read.js';
+import './tools/tool-output-read.js';
 import './tools/filesystem/read-document.js';
 import './tools/filesystem/file-edit.js';
 import './tools/filesystem/file-write.js';
@@ -51,16 +66,32 @@ import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
 import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
+import './tools/subagent/read_agent.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);
-    // 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).
-    void loadServerModelConfig(cfg);
+    // 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 — fetch the served model-config (managed mode
+    // only). Task 3: awaited, but startup waits at most 1.5 s (then a fresh disk
+    // cache, else the built-ins), so the session model pinned at newSession
+    // below comes from the served config. Never throws.
+    // Task 12 — the customer layer (/v1/me/model-config, every mode with a
+    // key) loads in parallel under the SAME 1.5 s cap. Fails open.
+    await Promise.all([
+        loadServerModelConfig(cfg, { timeoutMs: 1500 }),
+        loadCustomerModelConfig(cfg, async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }),
+        // Task 16 (F13) — BYOK reads only the served tool_loading (signed in only).
+        fetchToolLoadingMode(cfg, async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }),
+    ]);
     // B5 (2026-06-11) — one-shot is headless by design: a single turn, no
     // REPL, often piped (CI / battery). Any stdin prompt would hang forever
     // (defect D1). The headless answer policy (ask_question auto-answers,
@@ -80,8 +111,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 +124,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 +137,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 +150,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 +166,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 +198,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 +265,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,
         })}`;

package/dist/projects/image-attachments.js

@@ -135,6 +135,14 @@ export function buildUserContent(text, images) {
  * hits the 32 MB request cap (and stops paying for stale screenshots).
  */
 export const MAX_HISTORY_IMAGES = 10;
+/**
+ * Task 7 — stub images in batches, not one per turn. Each stub edits an
+ * earlier user message, and Opus 5.5 binds every later thinking block to the
+ * exact prefix that produced it, so each trim invalidates them (and the prompt
+ * cache). Once over `max`, the live count drops to `max - IMAGE_TRIM_BATCH + 1`
+ * (6 at max 10), so the next trim is IMAGE_TRIM_BATCH images away.
+ */
+export const IMAGE_TRIM_BATCH = 5;
 /** Mutates `messages`; returns how many image blocks were removed. */
 export function trimHistoryImages(messages, max = MAX_HISTORY_IMAGES) {
     const slots = [];
@@ -146,10 +154,15 @@ export function trimHistoryImages(messages, max = MAX_HISTORY_IMAGES) {
                 slots.push({ blocks: m.content, i });
         });
     }
-    const excess = slots.length - max;
+    if (slots.length <= max)
+        return 0;
+    // Ruling F11: stub slots.length − (max − batch + 1) ⇒ 11 images at max 10
+    // stub the oldest 5. Clamped for a tiny `max` (never keep fewer than 1).
+    const keep = Math.max(1, max - IMAGE_TRIM_BATCH + 1);
+    const excess = slots.length - keep;
     for (let k = 0; k < excess; k++) {
         const { blocks, i } = slots[k];
         blocks[i] = { type: 'text', text: '[image removed from history]' };
     }
-    return Math.max(0, excess);
+    return excess;
 }