@cspeach/cli 1.1.19 → 1.1.20

package/dist/repl.js

@@ -36,7 +36,8 @@ import { AdtClient, snapshots } from '@cspeach/sap-client';
 import { makeSessionId, saveSession, sessionSaved } 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 { repinResumedSessionModel } from './session/repin-model.js';
 import { computeCost } from './cost/pricing.js';
 import { formatSessionSpendValue } from './repl/session-spend-line.js';
 import { formatGoodbye } from './renderer/goodbye.js';
@@ -45,6 +46,7 @@ import { initCredits } from './cost/credits-wire.js';
 import { createProviderForMode } from './agent/providers/factory.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
+import { IdleKeepalive } from './agent/cache-keepalive.js';
 import { renderTurnError } from './agent/turn-error-ux.js';
 import { runRerouteTurn } from './repl/reroute-turn.js';
 // BUG-2b (2026-07-05 live smoke) — pure (no-Ink) modules, safe to import
@@ -105,7 +107,7 @@ function prefillReadline(rl, text) {
 import { BracketedPasteDecoder, enableBracketedPaste, disableBracketedPaste, } from './repl/bracketed-paste.js';
 import { InkStdinPasteGuard } from './repl/ink-stdin-guard.js';
 import { printHelp } from './commands/help.js';
-import { shouldUseInk, setOneShotOverride, getEffectiveBodyWidth } from './renderer/tty.js';
+import { shouldUseInk, setOneShotOverride } from './renderer/tty.js';
 import { applyStartupRendering } from './renderer/rendering-mode.js';
 import { createClassicOutputEmitter } from './renderer/notices.js';
 import { saveConfig } from './config/loader.js';
@@ -137,6 +139,8 @@ 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 { pruneSpillFiles } from './tools/result-spill.js';
 import './tools/filesystem/read-document.js';
 import './tools/filesystem/file-edit.js';
 import './tools/filesystem/file-write.js';
@@ -158,6 +162,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';
 const HISTORY_SIZE = 500;
 // Persistence (read + dedup-guarded append) lives in ./repl/history.ts —
 // the single writer shared with the Ink Footer (Task 8, ux-wave1).
@@ -527,11 +532,22 @@ export async function runRepl(opts) {
             cfg = await loadConfig();
         }
     }
-    // model-governance step 2d — fire-and-forget fetch of the served model-config
-    // (managed mode only). NEVER blocks startup: a turn that starts before the
-    // fetch lands simply uses the built-ins (fail-safe). Precedence when it does
-    // land: env > local config > server > built-in.
-    void loadServerModelConfig(cfg);
+    // model-governance step 2d — fetch the served model-config (managed mode
+    // only). Task 3 (2026-09-27): AWAITED, but startup waits at most 1.5 s — a
+    // slower fetch aborts and falls back to a fresh disk cache, else the
+    // built-ins. The session model is resolved ONCE at newSession below and
+    // pinned, so call 0 and call 1 never run on different models (a switch
+    // forces a full cache rewrite). Precedence: env > local config > server >
+    // built-in. 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: no extra wait. Final
+    // precedence: env > local > customer > server > built-in. Fails open.
+    await Promise.all([
+        loadServerModelConfig(cfg, { timeoutMs: 1500 }),
+        loadCustomerModelConfig(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
+        // Task 16 (F13) — BYOK reads only the served tool_loading (signed in only).
+        fetchToolLoadingMode(cfg, async () => apiKey ?? '', { timeoutMs: 1500 }),
+    ]);
     // Credits (2026-09-16) — resolve ONCE, before any cost figure can render.
     // A managed customer is billed in credits at a multiplier we do not
     // disclose, so the dollar figures (our Anthropic COGS) must never reach
@@ -688,6 +704,10 @@ export async function runRepl(opts) {
     // preserves messages[], usage, last_skill, awaitingSkillAnswer, and the
     // turnInterrupted flag from the prior run. Skipping newSession() avoids
     // overwriting the saved file with an empty fresh one.
+    // Task 3 fix I1 — except the model: a resumed session re-resolves it ONCE
+    // through the same role resolution new sessions use (after the awaited
+    // served config), marks it 'predicted', saves, then stays pinned. Every
+    // resume entry (picker, --resume <id>) lands here via session/resume.ts.
     const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg));
     // Round 6 item 4c — a resumed session keeps its skill for the first plain prompt.
     let resumeKeepsSkill = Boolean(opts?.resumedSession?.skill);
@@ -710,9 +730,16 @@ export async function runRepl(opts) {
                 console.log(line.trimEnd());
         },
     });
+    // Merge (cost branch Task 3 + UI round 6) — a resumed session re-pins its
+    // model from the current config (after any --sap-alias switch above).
+    if (opts?.resumedSession) {
+        await repinResumedSessionModel(session, cfg);
+    }
     // Live fix 2026-09-26 — notices cut to one screen line keep their full text here.
     // Review M6: sanitised id; notice logs older than 14 days are collected.
     pruneNoticeLogs(logsDir());
+    // Task 17 — saved large tool outputs (tool-*.txt) older than 14 days go too.
+    pruneSpillFiles();
     setNoticeLogPath(noticeLogPathFor(logsDir(), session.id));
     // License gate: non-managed modes (byok/local/ai-hub) bypass our proxy for
     // inference, so without this anyone who never logged in could use the bundled
@@ -733,6 +760,13 @@ export async function runRepl(opts) {
             throw new Error('No API key configured');
         return key;
     });
+    // Task 15 — keep the prompt cache warm while the user is idle between
+    // turns: armed after a turn, disarmed on the next submit and on exit;
+    // `[keepalive] idle_pings` per idle period (managed / BYOK only).
+    const idleKeepalive = new IdleKeepalive({
+        provider,
+        maxPings: () => (cfg.keepalive?.enabled === false ? 0 : (cfg.keepalive?.idle_pings ?? 4)),
+    });
     // Panels status line — writeMode is the same EFFECTIVE (role-clamped) mode
     // the legacy line prints.
     const panelsStatus = {
@@ -941,7 +975,7 @@ export async function runRepl(opts) {
             // new turn's content touched with no separator and looked like
             // garbled overlap).
             if (trimmed !== '/exit' && trimmed !== '/quit') {
-                chunkEmitter.emit('chunk', formatPromptEcho(trimmed, getEffectiveBodyWidth()));
+                chunkEmitter.emit('chunk', formatPromptEcho(trimmed, process.stdout.columns || 80));
             }
             if (trimmed === '/exit' || trimmed === '/quit') {
                 done = true;
@@ -1042,7 +1076,7 @@ export async function runRepl(opts) {
                     return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), 
                     // model-governance step 2d — compact model resolves env > local >
                     // server > built-in (== COMPACTION_MODEL when nothing set).
-                    { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                    { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact', 'X-CSPeach-Model-Role': 'compact' } });
                 };
                 try {
                     chunkEmitter.emit('chunk', '\n' + formatInfo('Compacting older turns into a summary…'));
@@ -1123,6 +1157,7 @@ export async function runRepl(opts) {
                         ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                         chunkEmitter,
                         pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
+                        autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
                         signal: rerouteAbort.signal,
                     }),
                     session,
@@ -1638,8 +1673,13 @@ export async function runRepl(opts) {
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     signal: currentTurnAbort.signal,
                     suppressSaveHook: planResume !== null || planContinue !== null,
+                    // Task 19 — auto-compact at turn end, except plan resume/continue
+                    // turns (their post-turn persist indexes messages from turn start).
+                    autoCompact: planResume === null && planContinue === null,
                     // A4 — undefined on every non-plan turn (and when tiering is off).
                     modelOverride: planModelOverride,
+                    // Task 9 — a tier-down, never the session role (proxy must not enforce it).
+                    modelRole: planModelOverride ? 'audit' : undefined,
                     // Persist the plan revision the instant its manifest is finalised
                     // (before the continuation modal) so a Ctrl+C can't lose the phase.
                     onPlanManifest: planResumeForHook
@@ -1948,6 +1988,7 @@ export async function runRepl(opts) {
                 }
                 return;
             }
+            idleKeepalive.disarm(); // Task 15 — a submit ends the idle period
             turnStatusEmitter.reserve();
             postTurn = false;
             postTurnMayChain = false;
@@ -1972,6 +2013,11 @@ export async function runRepl(opts) {
                     if (resolveDone)
                         resolveDone();
                 }
+                // Task 15 — back at the prompt: warm the cache while the user reads
+                // (no-op unless this submit made a new cacheable request). Not when
+                // the submit ended in an exit (merge: UI round-3 /exit mid-turn).
+                if (!done)
+                    idleKeepalive.armAfterTurn(session);
             }
         };
         // Fix round 3 (item 5) — `/exit` / `/quit` typed while a turn runs:
@@ -2160,6 +2206,7 @@ export async function runRepl(opts) {
         const exitTail = await settleWithin(dispatchTail, EXIT_TAIL_CAP_MS);
         unmount();
         setTraceEmitter(undefined);
+        idleKeepalive.disarm(); // Task 15 — no pings after /exit
         // Bug 2 (wave1 live-fix) — undo the paste plumbing so the user's
         // shell doesn't keep receiving marker-wrapped pastes after exit.
         process.stdin.unpipe(inkStdin);
@@ -2514,8 +2561,12 @@ export async function runRepl(opts) {
         }
         else {
             const effectivePrompt = pendingPrefill ? promptStr + pendingPrefill : promptStr;
+            // Task 15 — idle at the prompt: warm the cache (no-op unless the last
+            // turn made a new cacheable request); disarmed once the line arrives.
+            idleKeepalive.armAfterTurn(session);
             try {
                 line = await rl.question(effectivePrompt);
+                idleKeepalive.disarm();
             }
             catch {
                 // rl.question rejects for two distinct reasons:
@@ -2529,6 +2580,7 @@ export async function runRepl(opts) {
                 // discriminates the two cases reliably.
                 const rlAny = rl;
                 if (rlAny.closed) {
+                    idleKeepalive.disarm();
                     // UX-5 #5 — piped stdin: a multi-line chunk can resolve the
                     // pending question with line 1 and QUEUE line 2+ before EOF
                     // closes the readline. Drain the queue before exiting.
@@ -2686,7 +2738,7 @@ export async function runRepl(opts) {
                 return await summariseViaProvider(provider, buildSummarisationPrompt(), serialiseForSummariser(toSummarise), 
                 // model-governance step 2d — compact model resolves env > local >
                 // server > built-in (== COMPACTION_MODEL when nothing set).
-                { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact' } });
+                { model: resolveModelRole('compact', cfg), maxTokens: 4000, headers: { 'X-CSForge-Skill': 'compact', 'X-CSPeach-Model-Role': 'compact' } });
             };
             try {
                 console.log('\n' + formatInfo('Compacting older turns into a summary…').trimEnd());
@@ -2766,6 +2818,7 @@ export async function runRepl(opts) {
                     skill: rr.skill,
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor },
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
+                    autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
                 }),
                 session,
                 print: (line) => console.error(line),
@@ -3264,6 +3317,8 @@ export async function runRepl(opts) {
         let planSubagentDispatches;
         const planResumeForHook = planResume;
         const turnStart = Date.now();
+        // UI fix round (1.1.20) — card waits are excluded from the receipt's time.
+        const turnStartPausedMs = turnStatusEmitter.pausedMs();
         // H1 — `session.usage` is session-LIFETIME (initialised once in
         // newSession, saved across turns). The footer's "this turn" label was
         // misleading — it actually showed cumulative lifetime tokens. Snapshot
@@ -3346,8 +3401,13 @@ export async function runRepl(opts) {
                 pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                 signal: turnAbort.signal,
                 suppressSaveHook: planResume !== null || planContinue !== null,
+                // Task 19 — auto-compact at turn end, except plan resume/continue
+                // turns (their post-turn persist indexes messages from turn start).
+                autoCompact: planResume === null && planContinue === null,
                 // A4 — undefined on every non-plan turn (and when tiering is off).
                 modelOverride: planModelOverride,
+                // Task 9 — a tier-down, never the session role (proxy must not enforce it).
+                modelRole: planModelOverride ? 'audit' : undefined,
                 onPlanManifest: planResumeForHook
                     ? async (assistantText) => {
                         try {
@@ -3579,6 +3639,7 @@ export async function runRepl(opts) {
                 cacheRead: turnStartCostSnapshot.cacheRead,
                 cacheCreate: turnStartCostSnapshot.cacheCreate,
                 startedAt: turnStart,
+                pausedMs: turnStartPausedMs,
             },
             // A4 — price the turn at the model that actually ran it (classic-path
             // mirror of the Ink call site above).

package/dist/session/repin-model.js

@@ -0,0 +1,18 @@
+/**
+ * Task 3 fix round 1 (I1, 2026-09-27) — re-pin a resumed session's model.
+ *
+ * The agent loop sends the session's PINNED `session.model` on every call.
+ * A resumed session carries the id saved at creation (possibly retired, or
+ * an id the served config has since moved away from), so on resume the
+ * model is re-resolved ONCE through the same path new sessions use —
+ * resolveModelRole('session_default', cfg), after the awaited served config —
+ * marked 'predicted', and saved. It then stays pinned for the rest of the
+ * session (managed-mode adoption in the loop may still update it).
+ */
+import { resolveModelRole } from '../models/resolve.js';
+import { saveSession } from './store.js';
+export async function repinResumedSessionModel(session, cfg) {
+    session.model = resolveModelRole('session_default', cfg);
+    session.served_model_source = 'predicted';
+    await saveSession(session);
+}

package/dist/session/store.js

@@ -87,7 +87,8 @@ function validateSchema(parsed) {
         if (!Array.isArray(msg.content))
             continue;
         for (const block of msg.content) {
-            if (block?.type === 'tool_use' && typeof block.partial_json === 'string') {
+            // Task 16 (F6): server_tool_use (tool search) streams input the same way.
+            if ((block?.type === 'tool_use' || block?.type === 'server_tool_use') && typeof block.partial_json === 'string') {
                 if (block.input === undefined) {
                     try {
                         block.input = JSON.parse(block.partial_json);
@@ -108,6 +109,14 @@ function validateSchema(parsed) {
     dropTrailingThinkingOnly(parsed.messages);
     return parsed;
 }
+/**
+ * Task 18 — a reader subagent (tools/subagent/read_agent.ts) saves its own
+ * `reader-*` session file; it is an internal child of a turn, not something
+ * the user resumes.
+ */
+export function isReaderSessionId(id) {
+    return typeof id === 'string' && id.startsWith('reader-');
+}
 /** How many sessions `cspeach --resume` lists — the unfinished count uses the same window. */
 export const RESUME_PICKER_LIMIT = 20;
 /**
@@ -119,7 +128,10 @@ export const RESUME_PICKER_LIMIT = 20;
  * full pass cost ~1.3 s at startup with 4,410 files).
  */
 async function recentSessionFiles(dir, limit) {
-    const files = (await fs.readdir(dir).catch(() => [])).filter((f) => f.endsWith('.json'));
+    // Merge note — Task 18 reader-* child sessions are skipped by NAME here, so a
+    // burst of reader files can never crowd real sessions out of the window.
+    const files = (await fs.readdir(dir).catch(() => []))
+        .filter((f) => f.endsWith('.json') && !f.includes('-reader-'));
     const cap = Math.max(limit * 3, 50);
     if (files.length <= cap)
         return files;
@@ -146,6 +158,8 @@ export async function listSessions(limit = 10, opts = {}) {
         try {
             const raw = await fs.readFile(path.join(dir, f), 'utf-8');
             const parsed = JSON.parse(raw);
+            if (isReaderSessionId(parsed.id))
+                continue; // Task 18 — internal child, never resumed
             const messages = parsed.messages ?? [];
             // First user message that's a plain string (not a tool_result array) — the
             // most recent prompt text that initiated a turn. We pick the LAST such

package/dist/skills/bundled-skills.js

@@ -1,6 +1,6 @@
 // GENERATED FILE — bundled skills for local mode.
 // Source: https://manifest.cspeach.dev/v1.json
-// Generated: 2026-09-28T17:36:32.510Z
+// Generated: 2026-09-28T21:15:10.654Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {

package/dist/skills/preamble.js

@@ -0,0 +1,75 @@
+/**
+ * CLI copy of cspeach-proxy/src/skills/preamble.ts FORGE_PRINCIPLES_PREAMBLE.
+ *
+ * Task 5 (2026-09-27, ruling F3): BYOK, AI-hub and local build the system
+ * prompt client-side, so they need the same preamble the proxy prepends for
+ * managed turns. src/skills/__tests__/preamble-pin.test.ts asserts the two
+ * template literals stay byte-equal — edit both files together.
+ */
+export const FORGE_PRINCIPLES_PREAMBLE = `# CSPeach Principles
+
+You are operating inside CSPeach, an AI-assisted ABAP development tool with
+direct access to the user's SAP system via ADT. Follow these principles on
+every turn. The active skill may specialize your behavior; these principles
+take precedence if a skill's instruction conflicts with them.
+
+## Correctness over speed
+- Read before writing. Use sap_get_source and sap_object_structure to ground
+  your understanding in the real code before proposing changes.
+- Never hallucinate method names, field names, parameter types, or table
+  structures. If you're not sure, look it up.
+- When modifying method logic without changing the class definition
+  (no new/removed methods, no signature changes), use sap_update_method
+  per method. Do NOT rewrite the full class with sap_set_source.
+- Batch independent reads in one response.
+- When a result says it was saved to a file, read the slice you need with
+  tool_output_read(path, offset, limit); do not re-run the command.
+
+## Heavy reading
+- Send more than two source reads, any where-used scan, ATC-finding triage or
+  a package inventory to a reader: call read_agent with a precise brief (what
+  to read, what to report) and work from its report. Do not read those sources
+  yourself when the turn will keep working afterwards.
+- Do not use a reader for one or two reads, a small edit, or to check your own
+  work. Never more than three readers for one task unless the user asks. Send
+  independent readers in one response so they run at the same time.
+
+## Safety gates are mandatory
+- Mutating tools (sap_set_source, sap_update_method, sap_delete_object,
+  sap_activate, sap_create_object, sap_transport_*, sap_message_maintain,
+  sap_number_range_intervals, sap_service_binding_publish) require a valid
+  approval_id from request_approval. You cannot bypass this.
+- Snapshots are taken automatically before every write — do not ask the
+  user to confirm snapshots.
+- After every write, syntax is checked and activation is verified. You
+  will see results as tool_results. Do not activate if syntax errors exist.
+
+## Plan before batch
+- If you will modify more than one object, call request_approval with all
+  changes in a single changes[] array first. The user sees a holistic plan
+  before per-change prompts.
+- If a plan is rejected, ask the user what to change. Do not silently
+  revise and re-submit.
+
+## Transport discipline
+- All writes go into the active session transport. Do not ask the user
+  for a transport number per change.
+- Never use \$TMP unless the user explicitly requests local-only work.
+
+## Escalate, don't fail silently
+- If a tool returns an error you don't know how to recover from, surface
+  the error to the user with a clear explanation and ask how to proceed.
+- If ATC or syntax errors block activation, fix them or ask — never
+  suppress or hide.
+- Stop and ask the user before a 4th attempt on the same operation. Do not keep retrying silently.
+
+## Ask when unsure
+- For ambiguous requests, ask one clarifying question before acting.
+- For destructive operations on production-namespaced objects, confirm
+  intent in text even if approval_id is granted.
+
+## One skill per turn
+- If the user's request is better served by a different skill, call
+  switch_skill with a clear reason. Do not try to do the work of another
+  skill yourself.
+`;

package/dist/skills/source-manifest.js

@@ -2,6 +2,11 @@ import { ManifestClient } from './manifest-client.js';
 export function createManifestSkillSource(manifestUrl) {
     const client = new ManifestClient(manifestUrl);
     let cachedManifest = null;
+    // Task 5 (2026-09-27) — BYOK / AI-hub fetch the skill body on every model
+    // call (the system prompt is built client-side). Cache the sha-verified body
+    // for the source's lifetime, like the manifest, so each tool-loop round does
+    // not hit the network. Failures are not cached.
+    const bodyCache = new Map();
     async function getManifest() {
         if (!cachedManifest)
             cachedManifest = await client.fetchAndVerifyManifest();
@@ -13,7 +18,12 @@ export function createManifestSkillSource(manifestUrl) {
             const entry = m.skills.find(s => s.name === name);
             if (!entry)
                 throw new Error(`skill '${name}' not found in manifest (available: ${m.skills.map(s => s.name).join(', ')})`);
-            return client.fetchSkillBody(name, entry.body_url, { expectedSha256: entry.sha256 });
+            const cached = bodyCache.get(name);
+            if (cached && cached.sha256 === entry.sha256)
+                return cached;
+            const body = await client.fetchSkillBody(name, entry.body_url, { expectedSha256: entry.sha256 });
+            bodyCache.set(name, body);
+            return body;
         },
         async listAvailableSkills() {
             const m = await getManifest();

package/dist/tools/filesystem/file-read.js

@@ -11,6 +11,8 @@
 import { promises as fs } from 'node:fs';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath } from '../_filesystem-shared.js';
+import { spillToolResult, isUnderSpillRoot } from '../result-spill.js';
+import { basename } from 'node:path';
 const MAX_LINES = 2000;
 export async function fileReadHandler(args, ctx) {
     // Validate offset and limit BEFORE clamping
@@ -68,7 +70,15 @@ export async function fileReadHandler(args, ctx) {
     const trailer = truncated
         ? `\n... (truncated, ${allLines.length - (offset + window.length)} more lines — re-read with offset=${offset + window.length})`
         : '';
-    return { content: numbered + trailer };
+    // Task 17 (spec D12) — a window above 8 000 chars is saved to the session
+    // spill file and previewed; today's trailer stays last, byte-identical. A
+    // file already under the spill root is a slice already: never re-spilled.
+    // The spill keeps the FILE's line numbers (a `.n.txt` spill, which
+    // tool_output_read shows unnumbered-again) — one numbering space.
+    const body = isUnderSpillRoot(realAbs)
+        ? numbered
+        : spillToolResult({ content: numbered }, ctx, 'file', { numbered: true, label: basename(realAbs) }).content;
+    return { content: body + trailer };
 }
 registerTool({
     name: 'file_read',