@cspeach/cli 1.1.18 → 1.1.20

package/dist/commands/auto-compact.js

@@ -1,9 +1,11 @@
 /**
  * Auto-compact orchestration — Phase 2 #9 (2026-05-16).
  *
- * Calls `runCompact` end-of-turn when the session has crossed
- * `compact.auto_threshold_tokens` non-cached input tokens AND enough turns
- * have passed since the last auto-compact run.
+ * Calls `runCompact` end-of-turn when the last model call's full context
+ * (input + cache read + cache write — Task 19, ruling F12) has reached
+ * `compact.auto_threshold_tokens` AND enough turns have passed since the last
+ * auto-compact run. The caller passes the RESOLVED threshold (file > served
+ * `auto_compact_tokens` > 150 000; see models/resolve.ts).
  *
  * Why end-of-turn (not start-of-turn): firing at the end means the cost
  * (one Haiku call to summarise) is amortised over the user's natural
@@ -21,7 +23,11 @@
  */
 import chalk from 'chalk';
 import { saveSession } from '../session/store.js';
-import { runCompact, formatCompactResult, } from './compact.js';
+import { runCompact, planCompaction, canCompact } from './compact.js';
+/** The number the gate compares: the context size, else the legacy counter. */
+function gateTokens(input) {
+    return input.lastContextTokens ?? input.sessionInputTokens ?? 0;
+}
 /**
  * Pure decision function — no IO. Decides whether auto-compact should
  * fire given the current session state and config. Extracted so the
@@ -29,11 +35,11 @@ import { runCompact, formatCompactResult, } from './compact.js';
  * Summariser.
  */
 export function shouldAutoCompact(input) {
-    const { sessionInputTokens, turnNumber, lastAutoCompactTurn, config } = input;
+    const { turnNumber, lastAutoCompactTurn, config } = input;
     if (!config.auto_enabled) {
         return { fire: false, reason: 'disabled' };
     }
-    if (sessionInputTokens < config.auto_threshold_tokens) {
+    if (gateTokens(input) < config.auto_threshold_tokens) {
         return { fire: false, reason: 'below-threshold' };
     }
     // Throttle: don't bounce. If we just ran auto-compact a few turns ago
@@ -43,7 +49,10 @@ export function shouldAutoCompact(input) {
     const turnsSince = lastAutoCompactTurn === undefined
         ? Number.POSITIVE_INFINITY
         : turnNumber - lastAutoCompactTurn;
-    if (turnsSince < config.min_turns_between_auto) {
+    // Final review I4 — a marker ahead of the turn number (a legacy marker from
+    // the old user-message count, which shrinks after a compaction) never
+    // throttles; the loop now passes a monotonic per-session counter.
+    if (turnsSince >= 0 && turnsSince < config.min_turns_between_auto) {
         return { fire: false, reason: 'throttled' };
     }
     return { fire: true };
@@ -58,19 +67,28 @@ export function shouldAutoCompact(input) {
 export async function maybeAutoCompact(params) {
     const { session, config, turnNumber, summarise } = params;
     const emit = params.emit ?? ((line) => console.log(line));
-    const decision = shouldAutoCompact({
+    const gate = {
+        lastContextTokens: session.last_context_tokens,
         sessionInputTokens: session.usage?.input_tokens ?? 0,
+    };
+    const decision = shouldAutoCompact({
+        ...gate,
         turnNumber,
         lastAutoCompactTurn: session.lastAutoCompactTurn,
         config,
     });
     if (!decision.fire)
         return;
-    // Banner BEFORE the work so the user understands the pause they're about
-    // to see. ~3s for a Haiku call on a long history.
-    emit('');
-    emit(chalk.yellow(`⚙  auto-compact: session crossed ${config.auto_threshold_tokens.toLocaleString()} input tokens`
-        + ` — summarising older turns to keep the next turn cheap.`));
+    // Task 19 — at 150k a session can cross the gate with too few user turns
+    // for runCompact to cut anything (it would return "nothing to do"). Stay
+    // silent then, instead of printing the line on every turn (canCompact is
+    // the predicate runCompact's own bail-outs use).
+    if (!canCompact(planCompaction(session.messages, config.keep_recent_turns), config.keep_recent_turns))
+        return;
+    // Task 19 — ONE short line, printed when the work is done so it can carry
+    // the backup path (the one-step rollback). A failure prints its own line.
+    const head = `⚙  auto-compact: context ${gateTokens(gate).toLocaleString('en-US')} tokens ≥ `
+        + `${config.auto_threshold_tokens.toLocaleString('en-US')}`;
     try {
         const result = await runCompact({
             session,
@@ -82,13 +100,12 @@ export async function maybeAutoCompact(params) {
             // runCompact already saved the session inside its happy path, but we
             // mutate one more field (the throttle marker) so re-save to capture it.
             await saveSession(session);
+            emit(chalk.yellow(`${head} — older turns summarised · backup: ${result.backupPath}`));
         }
-        emit(formatCompactResult(result, config.keep_recent_turns));
     }
     catch (err) {
         // Defensive: never let a summariser blow take down the turn.
         const msg = err instanceof Error ? err.message : String(err);
-        emit(chalk.yellow(`⚙  auto-compact bailed: ${msg}`));
-        emit(chalk.dim('   session left intact; /compact still available manually.'));
+        emit(chalk.yellow(`⚙  auto-compact bailed: ${msg} — session left intact; /compact still works.`));
     }
 }

package/dist/commands/compact.js

@@ -26,8 +26,11 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import chalk from 'chalk';
 import { sessionsDir } from '../config/paths.js';
+import { panelHeading, panelRow } from '../renderer/panel-rows.js';
+import { formatInfo } from '../renderer/notice-shape.js';
+import { paint } from '../renderer/theme.js';
+import { getGlyphs } from '../renderer/glyphs.js';
 import { saveSession } from '../session/store.js';
 import { isUserPrompt } from '../session/user-prompt.js';
 /** Keep this many recent user-prompt anchored turns verbatim. */
@@ -213,6 +216,32 @@ export function buildSummaryMessage(summary, droppedTurns, todos) {
         ].join('\n'),
     };
 }
+const THINKING_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking']);
+/** Text left in an assistant message that held only thinking (an interrupted turn): the API rejects empty content. */
+export const THINKING_ONLY_PLACEHOLDER = '(thinking removed by /compact)';
+/**
+ * Task 7 — drop `thinking` / `redacted_thinking` blocks from an assistant
+ * message. User messages and string content are returned unchanged (the same
+ * object); every other block is kept as-is and in order. Never mutates the
+ * input. Idempotent.
+ */
+export function stripThinking(m) {
+    if (m.role !== 'assistant' || !Array.isArray(m.content))
+        return m;
+    const blocks = m.content;
+    if (!blocks.some((b) => THINKING_BLOCK_TYPES.has(b?.type ?? '')))
+        return m;
+    const rest = blocks.filter((b) => !THINKING_BLOCK_TYPES.has(b?.type ?? ''));
+    return { ...m, content: rest.length > 0 ? rest : [{ type: 'text', text: THINKING_ONLY_PLACEHOLDER }] };
+}
+/**
+ * Task 19 — true when `plan` leaves enough older history for runCompact to
+ * summarise. The one predicate runCompact's bail-outs and the auto-compact
+ * silent check share.
+ */
+export function canCompact(plan, keepRecentTurns) {
+    return plan.userPromptCount >= keepRecentTurns && plan.toSummarise.length >= MIN_COMPACT_THRESHOLD;
+}
 /**
  * Top-level compact orchestration. Pure async function — caller wires it
  * into the REPL slash dispatcher. Throws only on catastrophic IO failure
@@ -226,7 +255,8 @@ export async function runCompact(opts) {
     const { session, summarise } = opts;
     const keep = opts.keepRecentTurns ?? KEEP_RECENT_TURNS;
     const plan = planCompaction(session.messages, keep);
-    // Bail if there's not enough older history to be worth compacting.
+    // Bail if there's not enough older history to be worth compacting
+    // (the two checks canCompact combines; kept apart for their messages).
     if (plan.userPromptCount < keep) {
         return {
             performed: false,
@@ -259,7 +289,15 @@ export async function runCompact(opts) {
     // we accept losing the original first prompt because the summary should
     // mention what the goal was.)
     const summaryMsg = buildSummaryMessage(summary, plan.toSummarise.length, session.todos);
-    session.messages = [summaryMsg, ...plan.toKeep];
+    // Task 7 — the API's conversation check rejects a replayed thinking block
+    // whose earlier turns changed (Opus 5.5 binds each block to the exact prefix
+    // that produced it). The summary changed them, so the kept tail goes out
+    // without thinking; text and tool calls stay. The backup above keeps all.
+    const kept = plan.toKeep.map(stripThinking);
+    session.messages = [summaryMsg, ...kept];
+    // Task 19 — the recorded context size described the old history; the next
+    // call records the new one. Clearing it keeps the auto-compact gate honest.
+    delete session.last_context_tokens;
     await saveSession(session);
     return {
         performed: true,
@@ -277,18 +315,18 @@ export function formatCompactResult(result,
 /** Optional — falls back to the legacy constant for back-compat. */
 keepRecentTurns = KEEP_RECENT_TURNS) {
     if (!result.performed) {
-        return chalk.dim(`/compact: ${result.reason ?? 'nothing to do'}`);
+        return formatInfo(`/compact: ${result.reason ?? 'nothing to do'}`).trimEnd();
     }
     const lines = [
         '',
-        chalk.bold('/compact complete'),
-        chalk.dim(`  dropped:   ${result.droppedTurns} messages`),
-        chalk.dim(`  kept:      ${result.keptTurns} messages (most recent ${keepRecentTurns} user turns intact)`),
-        chalk.dim(`  summary:   ~${result.summaryTokens?.toLocaleString()} tokens`),
-        chalk.dim(`  backup:    ${result.backupPath}`),
+        panelHeading('Compacted', 'older turns summarised'),
+        panelRow('Dropped', `${result.droppedTurns} messages`),
+        panelRow('Kept', `${result.keptTurns} messages (most recent ${keepRecentTurns} user turns intact)`),
+        panelRow('Summary', `~${result.summaryTokens?.toLocaleString()} tokens`),
+        panelRow('Backup', `${result.backupPath}`),
         '',
-        chalk.green('Next turn\'s context is now roughly summary-size instead of full history.'),
-        chalk.dim('Heads-up: the very next turn rebuilds the prompt cache (one-off cost), then turns after that are cheap again.'),
+        `${paint('ok', getGlyphs().done)} The next turn's context is roughly summary-size instead of the full history.`,
+        formatInfo('The very next turn rebuilds the prompt cache once; turns after that are cheap again.').trimEnd(),
         '',
     ];
     return lines.join('\n');

package/dist/commands/config-set.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { formatAttention } from '../renderer/notice-shape.js';
 import { loadConfig, saveConfig, isValidWriteMode } from '../config/loader.js';
 import { STANDALONE_PLATFORMS, STANDALONE_DATABASES, STANDALONE_DEPLOYMENTS, STANDALONE_IDES, isStandalonePlatform, deriveDatabase, deriveDeployment, defaultAbapCloudOnly, defaultRelease, } from '../sap/standalone-profile.js';
 /**
@@ -95,7 +96,7 @@ function errUnset(msg) {
  * Internal, loader-derived flags that are never serialised (stripped by
  * saveConfig). They must never be targets of `config set`/`config unset`.
  */
-const INTERNAL_KEYS = new Set(['default_model_set', 'file_keys']);
+const INTERNAL_KEYS = new Set(['default_model_set', 'effort_set', 'file_keys']);
 /**
  * Virtual keys whose values live in the OS keychain, not config.toml. `config
  * unset` cannot remove them — that is a keychain operation — so they are
@@ -265,6 +266,10 @@ export async function runConfigUnset(args) {
     }
     const cfg = await loadConfig();
     const removed = unsetConfigKey(cfg, key);
+    // Task 4 — `effort` and its explicit marker go together: removing the value
+    // without the marker would leave a stale marker for a later bare effort.
+    if (key === 'effort')
+        unsetConfigKey(cfg, 'effort_explicit');
     if (!removed) {
         console.log(chalk.dim(`${key} was not set — nothing to unset.`));
         return;
@@ -350,8 +355,11 @@ export async function runConfigSet(args) {
         }
         cfg.sap[alias].insecure_skip_tls_verify = b;
         if (b) {
-            console.log(chalk.yellow(`  ⚠ TLS verification will be DISABLED for ${alias} — dev only, NEVER use in production. ` +
-                `Prefer: cspeach config set sap.${alias}.ca_cert_path <path-to-corporate-CA>`));
+            console.log(formatAttention({
+                text: `TLS verification is off for ${alias}`,
+                fact: 'dev only, never in production',
+                next: `cspeach config set sap.${alias}.ca_cert_path <path-to-corporate-CA>`,
+            }).trimEnd());
         }
         await saveConfig(cfg);
         console.log(chalk.green(`Set ${key} = ${b}`));
@@ -455,6 +463,11 @@ export async function runConfigSet(args) {
                 err(`Invalid effort value "${value}". Allowed: ${EFFORT_VALUES.join(', ')}`);
             }
             cfg.effort = value;
+            // Task 4 (ruling F2) — the marker makes this an explicit act: only then
+            // does resolveEffort send output_config.effort. Kept on save even when
+            // the value equals the built-in default (xhigh).
+            cfg.effort_explicit = true;
+            markExplicit(cfg, 'effort_explicit');
             break;
         case 'telemetry':
             if (!TELEMETRY_VALUES.includes(value)) {

package/dist/commands/config-show.js

@@ -1,5 +1,8 @@
 import chalk from 'chalk';
 import { loadConfig } from '../config/loader.js';
+import { paint } from '../renderer/theme.js';
+import { formatAttention } from '../renderer/notice-shape.js';
+import { getCustomerModelConfig } from '../models/server-config.js';
 /**
  * Dotted paths of keys that must never appear in plaintext config output.
  * SAP passwords live in the keychain and should never land in config.toml,
@@ -23,6 +26,10 @@ const REDACTED_KEYS = new Set([
 const INTERNAL_KEYS = new Set([
     'default_model_set',
     'file_keys',
+    // Task 4 — effort_set is loader-derived; effort_explicit is the stored
+    // marker behind it (plumbing, not a user-facing setting).
+    'effort_set',
+    'effort_explicit',
 ]);
 function formatTomlValue(value) {
     if (typeof value === 'string')
@@ -57,7 +64,7 @@ function printLlmMissingHints(llm) {
     for (const key of required) {
         const value = llm[key];
         if (value === undefined || value === null || value === '') {
-            console.log(`${key} = ${chalk.red('<not set>')}`);
+            console.log(`${key} = ${paint('bad', '<not set>')}`);
         }
     }
 }
@@ -83,14 +90,14 @@ function printConfigAsToml(cfg, prefix = '') {
             // the implication (writes proposed, never executed) without having to
             // read the docs.
             if (fullKey === 'write_mode' && v === 'advisory-only') {
-                console.log(chalk.yellow('  → Advisory mode: writes will be proposed, never executed.'));
+                console.log('  ' + formatAttention({ text: 'Advisory mode', fact: 'writes are proposed, never executed' }).trimEnd());
             }
         }
     }
     for (const [k, v] of tables) {
         const fullKey = prefix ? `${prefix}.${k}` : k;
         console.log('');
-        console.log(chalk.cyan(`[${fullKey}]`));
+        console.log(chalk.bold(`[${fullKey}]`));
         printConfigAsToml(v, fullKey);
         // Mode-aware extras for the `[llm]` section — print required keys that
         // are empty as `<not set>` so a user who ran `cspeach config set llm.mode
@@ -136,6 +143,12 @@ export async function runConfigShow(args) {
         console.log(chalk.gray('# ~/.cspeach/config.toml'));
         printConfigAsToml(cfg);
         console.log('');
+        // Task 12 — one trailing line when the account admin's model is enforced
+        // by the proxy (/v1/me/model-config). No snapshot ⇒ output unchanged.
+        const customer = getCustomerModelConfig();
+        if (customer?.model && customer.enforced) {
+            console.log(chalk.gray(`# model set by your account admin: ${customer.model} (enforced)`));
+        }
         return;
     }
     const keyPath = args[0];
@@ -158,7 +171,7 @@ export async function runConfigShow(args) {
     if (typeof resolved === 'object' && resolved !== null) {
         // Sub-object (e.g. sap.S4H-DEV) — print as TOML section
         console.log('');
-        console.log(chalk.cyan(`[${keyPath}]`));
+        console.log(chalk.bold(`[${keyPath}]`));
         for (const [k, v] of Object.entries(resolved)) {
             const subKey = `${keyPath}.${k}`;
             if (REDACTED_KEYS.has(subKey)) {
@@ -173,7 +186,7 @@ export async function runConfigShow(args) {
     else {
         console.log(String(resolved));
         if (keyPath === 'write_mode' && resolved === 'advisory-only') {
-            console.log(chalk.yellow('  → Advisory mode: writes will be proposed, never executed.'));
+            console.log('  ' + formatAttention({ text: 'Advisory mode', fact: 'writes are proposed, never executed' }).trimEnd());
         }
     }
 }

package/dist/commands/cost.js

@@ -12,6 +12,10 @@ import chalk from 'chalk';
 import { readCostLog, summarise } from '../cost/cost-log.js';
 import { formatCost } from '../cost/pricing.js';
 import { creditsActive, formatCredits, globalCredits, CREDITS_PENDING, } from '../cost/credits.js';
+import { panelHeading, panelRow } from '../renderer/panel-rows.js';
+import { formatInfo } from '../renderer/notice-shape.js';
+import { countLabel } from '../renderer/checklist-format.js';
+import { sanitizeControlChars } from '../renderer/sanitize.js';
 /**
  * Sum the credits the proxy charged across the logged turns. Entries written
  * before credits existed (or on turns whose balance fetch failed) carry no
@@ -21,6 +25,9 @@ function summariseCredits(entries) {
     let total = 0;
     let unknown = 0;
     for (const e of entries) {
+        // Final review I6 — a zero-token reader rollup line is not a turn.
+        if (e.kind === 'reader_rollup')
+            continue;
         if (typeof e.credits_charged === 'number')
             total += e.credits_charged;
         else
@@ -28,12 +35,18 @@ function summariseCredits(entries) {
     }
     return { total, unknown };
 }
-export async function runCostCommand(sessionId, credits = globalCredits.snapshot()) {
+/** Model ids can come from server-side model governance: one line, no control chars. */
+const modelText = (m) => sanitizeControlChars(m).replace(/\s*\r?\n\s*/g, ' ').trim();
+/**
+ * `emit` (piece 2) — Ink passes the chunkEmitter so the panel lands in the
+ * transcript, not above the React frame. Default: console.log (classic).
+ */
+export async function runCostCommand(sessionId, credits = globalCredits.snapshot(), emit = (l) => console.log(l)) {
     const entries = await readCostLog(sessionId);
     if (entries.length === 0) {
-        console.log('');
-        console.log(chalk.dim('No cost data yet for this session. Run a turn first.'));
-        console.log('');
+        emit('');
+        emit(formatInfo('No cost data yet for this session. Run a turn first.').trimEnd());
+        emit('');
         return;
     }
     const s = summarise(entries);
@@ -43,47 +56,53 @@ export async function runCostCommand(sessionId, credits = globalCredits.snapshot
     // stay: they are a usage fact, not a COGS leak.
     const inCredits = creditsActive();
     const perTurn = summariseCredits(entries);
-    // Header
-    console.log('');
+    const turnsNote = `${s.turns} turn${s.turns === 1 ? '' : 's'}`;
+    emit('');
     if (inCredits) {
         const unit = credits?.unitLabel ?? 'credits';
         // Prefer the live session tracker (balance deltas observed this run);
         // fall back to the logged per-turn charges when it has nothing yet.
         const total = credits && credits.sessionTotal > 0 ? credits.sessionTotal : perTurn.total;
-        console.log(chalk.bold(`Session usage so far: ${formatCredits(total, unit)}`) + chalk.dim(`   (${s.turns} turn${s.turns === 1 ? '' : 's'})`));
-        if (credits?.balance != null) {
-            console.log(chalk.dim(`Remaining balance: ${formatCredits(credits.balance, unit)}`));
-        }
+        emit(panelHeading(`Session usage so far: ${formatCredits(total, unit)}`, turnsNote));
+        if (credits?.balance != null)
+            emit(panelRow('Balance', formatCredits(credits.balance, unit)));
     }
     else {
-        console.log(chalk.bold(`Session cost so far: ${formatCost(s.totalCost)}`) + chalk.dim(`   (${s.turns} turn${s.turns === 1 ? '' : 's'})`));
+        emit(panelHeading(`Session cost so far: ${formatCost(s.totalCost)}`, turnsNote));
+    }
+    emit('');
+    emit(chalk.bold('Tokens'));
+    emit(panelRow('input', s.totalTokens.input.toLocaleString().padStart(12)));
+    emit(panelRow('output', s.totalTokens.output.toLocaleString().padStart(12)));
+    emit(panelRow('cache read', s.totalTokens.cacheRead.toLocaleString().padStart(12)));
+    emit(panelRow('cache create', s.totalTokens.cacheCreate.toLocaleString().padStart(12)));
+    // Task 18 fix M3 — reader subagent spend (already inside the total above).
+    // USD only: in credits mode the balance delta already carries it.
+    if (s.readerCalls > 0 && !inCredits) {
+        emit('');
+        emit(panelRow('Readers', `${s.readerCalls} run${s.readerCalls === 1 ? '' : 's'}   ${formatCost(s.readerCost)}`));
     }
-    // Token breakdown
-    console.log('');
-    console.log(chalk.dim('Tokens:'));
-    console.log(`  input         ${s.totalTokens.input.toLocaleString().padStart(12)}`);
-    console.log(`  output        ${s.totalTokens.output.toLocaleString().padStart(12)}`);
-    console.log(`  cache read    ${s.totalTokens.cacheRead.toLocaleString().padStart(12)}`);
-    console.log(`  cache create  ${s.totalTokens.cacheCreate.toLocaleString().padStart(12)}`);
-    // Per-model split (Phase 2 will make this interesting)
     if (s.byModel.length > 1) {
-        console.log('');
-        console.log(chalk.dim('By model:'));
+        emit('');
+        emit(chalk.bold('By model:'));
         for (const m of s.byModel) {
             // Credits mode: turn counts only. A per-model dollar split is a direct
             // read on our per-model COGS.
             const tail = inCredits ? '' : `   ${formatCost(m.cost)}`;
-            console.log(`  ${m.model.padEnd(24)} ${m.turns} turn${m.turns === 1 ? '' : 's'}${tail}`);
+            emit(panelRow(modelText(m.model), `${m.turns} turn${m.turns === 1 ? '' : 's'}${tail}`, 24));
         }
     }
     else if (s.byModel[0]) {
-        console.log('');
-        console.log(chalk.dim(`Model: ${s.byModel[0].model}`));
+        emit('');
+        emit(panelRow('Model', modelText(s.byModel[0].model)));
     }
-    // Recent turns — last 5 lines, most recent first
-    const recent = entries.slice(-5).reverse();
-    console.log('');
-    console.log(chalk.dim(`Recent turns (last ${recent.length}):`));
+    // Recent turns — last 5, most recent first. Piece 2: one count format, "N of M" (P1's countLabel).
+    // Final review I6 — reader rollup lines (interrupted turns) are not turns:
+    // they stay out of the list and the count (summarise() already skips them).
+    const turnEntries = entries.filter((e) => e.kind !== 'reader_rollup');
+    const recent = turnEntries.slice(-5).reverse();
+    emit('');
+    emit(chalk.bold(`Recent turns · ${countLabel(recent.length, turnEntries.length)}`));
     for (const e of recent) {
         const tok = (e.tokens.input + e.tokens.output).toLocaleString();
         // Credits mode: the per-turn figure is what the LEDGER charged (a balance
@@ -95,14 +114,14 @@ export async function runCostCommand(sessionId, credits = globalCredits.snapshot
                 ? formatCredits(e.credits_charged, credits?.unitLabel ?? 'credits')
                 : CREDITS_PENDING)
             : formatCost(e.cost);
-        console.log(`  turn ${String(e.turn).padStart(3)}   ${tok.padStart(10)} tok   ${tail}`);
+        emit(panelRow(`turn ${String(e.turn).padStart(3)}`, `${tok.padStart(10)} tok   ${tail}`, 8));
     }
     if (inCredits && perTurn.unknown > 0) {
-        console.log('');
-        console.log(chalk.dim(`${perTurn.unknown} turn${perTurn.unknown === 1 ? '' : 's'} had no balance reading — `
-            + `their usage is included in a later turn's figure.`));
+        emit('');
+        emit(formatInfo(`${perTurn.unknown} turn${perTurn.unknown === 1 ? '' : 's'} had no balance reading — `
+            + `their usage is included in a later turn's figure.`).trimEnd());
     }
-    console.log('');
-    console.log(chalk.dim(`Detailed JSONL: ~/.cspeach/sessions/${sessionId}-cost.jsonl`));
-    console.log('');
+    emit('');
+    emit(formatInfo(`Detailed JSONL: ~/.cspeach/sessions/${sessionId}-cost.jsonl`).trimEnd());
+    emit('');
 }