@cspeach/cli 1.1.19 → 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

@@ -12,7 +12,7 @@ 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';
@@ -44,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';
@@ -65,6 +66,7 @@ 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();
@@ -78,10 +80,18 @@ export async function runOneShot(prompt, opts) {
     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).
-    void loadServerModelConfig(cfg);
+    // 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,

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;
 }

package/dist/renderer/footer-line.js

@@ -23,12 +23,16 @@ export function formatSpendSegment(s) {
         return CREDITS_PENDING;
     return formatCredits(s.creditsSessionTotal, s.creditsUnitLabel);
 }
-/** Store → footer facts. F-L2-1: the transport falls back to the one a write actually stamped. */
+/**
+ * Store → footer facts. F-L2-1: the transport falls back to the one a write
+ * actually stamped; UI fix round (1.1.20): then to one a transport lookup
+ * confirmed. A transport the user only typed is never shown.
+ */
 export function footerStateFrom(s) {
     return {
         system: s.system || undefined,
         user: s.user || undefined,
-        transport: (s.transport ?? s.lastWriteTransport) || undefined,
+        transport: (s.transport ?? s.lastWriteTransport ?? s.confirmedTransport) || undefined,
         standalone: s.standalone === true,
         mode: s.writeMode ?? '',
         spend: formatSpendSegment(s),

package/dist/renderer/startup-lines.js

@@ -9,7 +9,7 @@ import stringWidth from 'string-width';
 import { getLook } from './look.js';
 import { paint, BRAND_HEX } from './theme.js';
 import { formatAttention } from './notice-shape.js';
-import { truncateToWidth, uiWidth } from './ui-width.js';
+import { truncateToWidth, uiWidth, frameWidth } from './ui-width.js';
 import { sanitizeControlChars } from './sanitize.js';
 import { holdBrand } from './brand-settled.js';
 export { brandSettled } from './brand-settled.js';
@@ -144,9 +144,11 @@ export function panelsStartTail(p) {
     const head = `${panelsStatusLine(p.status)}\n${p.third}\n`;
     return p.notices.length === 0 ? head + '\n' : head + '\n' + p.notices.join('') + '\n';
 }
-export function formatPromptEcho(text, width) {
+export function formatPromptEcho(text, columns) {
     if (getLook() !== 'panels') {
         return chalk.dim('\n──────────────────────────────────\n') + chalk.cyan(`› ${text}\n`);
     }
-    return '\n' + paint('frame', '─'.repeat(Math.min(60, Math.max(20, width - 4)))) + '\n' + paint('dim', 'you ›') + ` ${text}\n`;
+    // UI fix round (1.1.20): the rule is the FRAME width — as wide as the input
+    // box (frameWidth), not the old fixed 60. `columns` is the terminal width.
+    return '\n' + paint('frame', '─'.repeat(frameWidth(columns))) + '\n' + paint('dim', 'You ›') + ` ${text}\n`;
 }

package/dist/renderer/tool-labels.js

@@ -1,3 +1,4 @@
+import { spillLabelFor } from '../lib/spill-labels.js';
 const OBJECT_MAX = 60;
 /**
  * Every value shown in a label goes through here: ANSI escape sequences and
@@ -48,8 +49,25 @@ const activateObject = (a) => {
     const shown = list.slice(0, list.length > 3 ? 2 : 3).join(', ');
     return list.length > 3 ? `${shown} +${list.length - 2} more` : shown;
 };
-/** Length of a JSON array result (e.g. sap_search_object); undefined when it is not one — never a guess. */
+/** One sap_search_object hit line (Task 17): NAME  TYPE  PACKAGE  DESCRIPTION  URI ("-" when empty). */
+const SEARCH_HIT_RE = /^\S+ {2}\S+ {2}\S+ {2}.+ {2}(\/\S*|-)$/;
+/** A spilled result's pointer line (tools/result-spill.ts): "[N lines / M chars — full output saved to …]". */
+const SPILL_POINTER_RE = /^\[(\d+) lines \/ \d+ chars — full output saved to .*\]$/;
+/**
+ * Hit count of a sap_search_object result: the Task 17 line format (a spilled
+ * preview counts from its pointer line), or a legacy JSON array. undefined
+ * when it is neither — never a guess.
+ */
 const arrayCount = (r) => {
+    if (r === '(no hits)')
+        return 0;
+    const lines = r.split('\n');
+    // Only the LAST line is the pointer — a hit description can't fake a count.
+    const spilled = SPILL_POINTER_RE.exec(lines[lines.length - 1] ?? '');
+    if (spilled)
+        return Number(spilled[1]);
+    if (lines.length > 0 && lines.every((l) => SEARCH_HIT_RE.test(l)))
+        return lines.length;
     try {
         const v = JSON.parse(r);
         return Array.isArray(v) ? v.length : undefined;
@@ -62,7 +80,19 @@ const arrayCount = (r) => {
 const SEARCH_DEFAULT_MAX = 100;
 const fileCount = (v) => (Array.isArray(v) ? `${v.length} ${v.length === 1 ? 'file' : 'files'}` : '');
 const commandLine = (a) => [str(a['command']) ?? '', ...(Array.isArray(a['args']) ? a['args'].map(str).filter((x) => x !== undefined) : [])].join(' ').trim();
+/** Never the internal spill path: the object the output came from, else "saved output". */
+const savedOutputLabel = (a) => {
+    const from = spillLabelFor(raw(a['path']) ?? ''); // lookup only — never displayed
+    const offset = typeof a['offset'] === 'number' ? a['offset'] : undefined;
+    const limit = typeof a['limit'] === 'number' ? a['limit'] : undefined;
+    const range = offset !== undefined && limit !== undefined ? `lines ${offset + 1}–${offset + limit}`
+        : offset !== undefined ? `from line ${offset + 1}` : undefined;
+    if (from === undefined)
+        return { verb: 'Read', object: 'saved output', ...(range ? { detail: range } : {}) };
+    return { verb: 'Read', object: from, detail: range ? `saved output · ${range}` : 'saved output' };
+};
 const RULES = {
+    tool_output_read: (a) => savedOutputLabel(a),
     file_read: (a, r) => ({ verb: 'Read', object: shortLeft(str(a['path']) ?? ''), ...(r !== undefined ? { detail: `${lineCount(r)} lines` } : {}) }),
     file_write: (a) => ({ verb: 'Wrote', object: shortLeft(str(a['path']) ?? ''), detail: `${lineCount(raw(a['content']) ?? '')} lines` }),
     file_edit: (a) => ({
@@ -152,6 +182,7 @@ const RULES = {
     upgrade_merge_progress: (a) => ({ verb: 'Merged progress', object: fileCount(a['inputs']) }),
     monitor_emit: (a) => ({ verb: 'Checked background', object: shortRight(str(a['bg_id']) ?? '') }),
     agent_run: (a) => ({ verb: 'Subagent', object: shortRight(str(a['skill']) ?? '') }),
+    read_agent: (a) => ({ verb: 'Reader', object: shortRight(str(a['brief']) ?? '') }),
     schedule_draft_create: (a) => ({ verb: 'Drafted schedule', object: shortRight(str(a['when']) ?? '') }),
     fiori_scaffold: (a) => ({ verb: 'Scaffolded app', object: shortLeft(str(a['basePath']) ?? '') }),
     fiori_apply: (a) => ({ verb: 'Applied', object: shortRight([str(a['entry']), str(a['appDir'])].filter(Boolean).join(' · ')) }),
@@ -221,7 +252,7 @@ const PRESENT = {
     'Searched web': 'Searching web', 'Read project context': 'Reading project context',
     'Read playbook': 'Reading playbook', 'Read convention': 'Reading convention', 'Merged CCA': 'Merging CCA',
     'Merged progress': 'Merging progress', 'Checked background': 'Checking background',
-    Subagent: 'Running subagent', 'Drafted schedule': 'Drafting schedule', Applied: 'Applying',
+    Subagent: 'Running subagent', Reader: 'Running reader', 'Drafted schedule': 'Drafting schedule', Applied: 'Applying',
     'Listed patterns': 'Listing patterns', 'Deploy config': 'Writing deploy config', 'Extended app': 'Extending app',
     Preview: 'Preview', 'Searched samples': 'Searching samples', 'Read sample': 'Reading sample',
     'Audited metadata': 'Auditing metadata', 'Extended model': 'Extending model',

package/dist/renderer/ui-width.js

@@ -11,6 +11,19 @@ export function uiWidth(columns) {
     const cols = columns ?? process.stdout.columns ?? 80;
     return Math.min(UI_MAX_WIDTH, Math.max(UI_MIN_WIDTH, cols));
 }
+/** Narrowest the frame ever gets (the input box needs its chrome + a few cells). */
+export const FRAME_MIN_WIDTH = 12;
+/**
+ * The FRAME width (UI fix round, CLI 1.1.20): the input box, the footer line
+ * under it and the rule above each `You ›` echo span the whole terminal —
+ * no 100-column cap. The −1 keeps the frame off the exact-terminal-width
+ * deferred-wrap edge on Windows Terminal. Text (answers, tool rows, card
+ * bodies) still wraps at uiWidth() so it stays readable on wide screens.
+ */
+export function frameWidth(columns) {
+    const cols = columns ?? process.stdout.columns ?? 80;
+    return Math.max(FRAME_MIN_WIDTH, cols - 1);
+}
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 /**
  * Cut PLAIN text (no ANSI; paint after truncating) to `width` terminal cells.

package/dist/repl/current-transport.js

@@ -57,6 +57,19 @@ export function noteWriteTransport(trkorr) {
         return;
     globalStore.update({ lastWriteTransport: trkorr });
 }
+/**
+ * Footer-only wire (UI fix round, 1.1.20): record a transport a read-only
+ * lookup CONFIRMED (sap_transport_for_object found the object locked in one
+ * open transport the connected user may write to). Live incident: the user
+ * named S4HK903731, the lookup confirmed it, and the footer still read
+ * "no transport". Like noteWriteTransport it never touches the session write
+ * pointer — the lookup is read-only and must not change where writes go.
+ */
+export function noteConfirmedTransport(trkorr) {
+    if (!trkorr)
+        return;
+    globalStore.update({ confirmedTransport: trkorr });
+}
 /**
  * Handles the `/transport [<trkorr>|clear]` slash command. Returns user-facing
  * status text. Mirrors the shape of handleSafetyModeCommand in safety-mode-state.ts.

package/dist/repl/post-turn-status.js

@@ -20,6 +20,7 @@
 import { computeCost } from '../cost/pricing.js';
 import { computeSessionCost } from '../cost/session-cost.js';
 import { globalStore } from '../ui/sap-state-store.js';
+import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
 import { globalCredits } from '../cost/credits.js';
 import { printStatusFooter, formatStatusFooter } from '../renderer/status-footer.js';
 import { shouldUseInk } from '../renderer/tty.js';
@@ -32,8 +33,14 @@ export function snapshotTurnStart(session) {
         cacheRead: session.usage.cache_read_input_tokens,
         cacheCreate: session.usage.cache_creation_input_tokens ?? 0,
         startedAt: Date.now(),
+        pausedMs: turnStatusEmitter.pausedMs(),
     };
 }
+/** Wall-clock since the turn started, less the time it spent waiting on the user. */
+export function turnElapsedMs(snapshot, now = Date.now()) {
+    const waited = snapshot.pausedMs === undefined ? 0 : turnStatusEmitter.pausedMs(now) - snapshot.pausedMs;
+    return Math.max(0, now - snapshot.startedAt - waited);
+}
 /**
  * The per-turn numbers every receipt prints — extracted (piece 2 I3a) so the
  * REPL receipt and the one-shot receipt compute them the same way.
@@ -54,7 +61,7 @@ export function computeTurnFacts(session, snapshot, turnModel) {
         turnCost,
         // F-L2-2: cost/session-cost.ts so the agent loop can push the SAME total mid-stream.
         sessionCost: computeSessionCost(session),
-        elapsedMs: Date.now() - snapshot.startedAt,
+        elapsedMs: turnElapsedMs(snapshot),
     };
 }
 export function pushPostTurnStatus(params) {