@cspeach/cli 1.1.19 → 1.1.20

package/dist/agent/loop.js

@@ -1,11 +1,15 @@
 import chalk from 'chalk';
 import { basename } from 'node:path';
 import { dispatchTool } from './tool-dispatch.js';
-import { listTools, getTool, toAnthropicTools, isStandalone, toolsForContext } from '../tools/index.js';
+import { listTools, getTool, isStandalone, toolsForContext, toAnthropicTools } from '../tools/index.js';
 import { saveSession } from '../session/store.js';
 import { recordCompletedToolCall } from '../session/pending.js';
 import { loadConfig } from '../config/loader.js';
-import { resolveModelRole } from '../models/resolve.js';
+import { resolveModelRole, resolveEffort, modelAcceptsEffort, resolveAutoCompactThreshold, callModelFor } from '../models/resolve.js';
+import { getCustomerModelConfig, managedProxyServesNewShapes, servedToolLoading } from '../models/server-config.js';
+import { buildToolList, buildSkillToolAddition, placeSystemMessagesInPlace, resolveToolLoading, } from '../tools/tool-loading.js';
+import { settleSessionToolLoading } from './tool-loading-pin.js';
+import { resolveSkillAlias } from '../skill-catalog.js';
 import { retryWithBackoff } from './retry.js';
 import { renderChunk, initialBufferState, render } from '../renderer/pipeline.js';
 import { nextWritingActivity } from '../renderer/fence-state.js';
@@ -23,7 +27,8 @@ import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
 // (progress-chatter import removed 2026-05-01 — superseded by CC-style
 //  two-line dispatch renderer; re-add if a future in-place spinner returns)
 import { buildRetryCapPausePayload, buildSkippedSiblingResults } from './retry-cap.js';
-import { appendCostLine, buildEntry as buildCostEntry } from '../cost/cost-log.js';
+import { appendCostLine, buildEntry as buildCostEntry, summariseInputTransformations } from '../cost/cost-log.js';
+import { modelAcceptsBinding, sessionMaxTokens, clampMaxTokens } from './provider-shape.js';
 import { computeSessionCost } from '../cost/session-cost.js';
 import { refreshCreditsAfterTurn, creditsForCostLog } from '../cost/credits-wire.js';
 import { globalStore } from '../ui/sap-state-store.js';
@@ -43,7 +48,7 @@ import { renderStandaloneContextBlock } from '../sap/standalone-profile.js';
 import { renderStandardsBlock } from '../standards/standards-file.js';
 import { composeSessionContextBlock } from './session-context.js';
 import { objectKeyFromInput } from './retry-key.js';
-import { repairPartialBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError, stripUnsignedThinking, isThinkingOnly, dropTrailingThinkingOnly } from './repair-partial.js';
+import { repairPartialBlocks, stripPreFallbackBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError, stripUnsignedThinking, isThinkingOnly, dropTrailingThinkingOnly } from './repair-partial.js';
 import { drainSteering } from './steering-queue.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
@@ -54,6 +59,10 @@ import { getCurrentTransport } from '../repl/current-transport.js';
 import { collectTurnAssistantText } from './turn-assistant-text.js';
 import { checkAndMark, newGuardState } from './parallel-write-guard.js';
 import { userPromptText } from '../session/user-prompt.js';
+import { CacheKeepalive, snapshotParams, recordLastRequest, isCacheablePrompt, noteCacheTouched } from './cache-keepalive.js';
+import { maybeColdPrune } from './cold-prune.js';
+import { createAdtLock, serializeAdt } from '../tools/subagent/adt-serial.js';
+import { hasReaderReadTools, INTERRUPTED_LINE } from '../tools/subagent/reader-prompt.js';
 /**
  * Author identity for project-file metadata. Reads CSPEACH_AUTHOR_NAME first,
  * then platform USER/USERNAME, then a generic fallback. Role is fixed to
@@ -324,8 +333,61 @@ export async function maybeOfferSave(p) {
         p.emit('\n' + formatAttention({ text: 'Not saved as a project file', fact: String(err?.message ?? err) }).trimEnd());
     }
 }
+/**
+ * Task 12 — sessions that have already shown the "set by your account admin"
+ * line. The REPL rebuilds `params.ctx` every turn but keeps the same
+ * `ctx.session` object, so the flag is keyed on it (session-scoped, never
+ * persisted: a WeakSet, not a session field).
+ */
+const adminModelLineShown = new WeakSet();
+/**
+ * Task 18 — a reader child must not repaint the parent's turn-status row
+ * (several readers run at once; the parent shows one "N readers running…").
+ */
+const SILENT_STATUS = {
+    activity: (_label) => undefined,
+    pause: () => undefined,
+    resume: () => undefined,
+};
+/** Task 18 — at most this many read_agent calls run at the same time. */
+export const MAX_PARALLEL_READERS = 4;
+const READ_AGENT = 'read_agent';
+/**
+ * Task 18 — the read_agent blocks of the run that starts at `start`: every
+ * following tool_use block up to the first one that is not read_agent
+ * (non-tool blocks such as text in between are skipped).
+ */
+function readerRunFrom(content, start) {
+    const out = [];
+    for (let i = start; i < content.length; i++) {
+        const b = content[i];
+        if (b?.type !== 'tool_use')
+            continue;
+        if (b.name !== READ_AGENT)
+            break;
+        out.push(b);
+    }
+    return out;
+}
+/** Drop a trailing -YYYYMMDD date suffix from a model id (for equality checks only). */
+function stripModelDate(model) {
+    return model?.replace(/-\d{8}$/, '');
+}
 export async function runTurn(params) {
-    resetRule8State(); // Rule 8 — fresh batch counter per LLM turn (= per user prompt)
+    // Task 18 — a reader subagent runs INSIDE the parent's turn: it must not
+    // reset the parent's Rule 8 batch counter, drain the parent's steering
+    // queue or repaint the parent's status row.
+    const readerChild = params.ctx.readerMode === true;
+    if (!readerChild)
+        resetRule8State(); // Rule 8 — fresh batch counter per LLM turn (= per user prompt)
+    const status = readerChild ? SILENT_STATUS : turnStatusEmitter;
+    // Task 18 (F24) — reader spend of THIS turn; read by every cost line below.
+    params.ctx.readerSpend = { cost: 0, calls: 0 };
+    // Fix I1 — the turn's abort signal travels on the ctx to reader clones and
+    // into their child turns.
+    params.ctx.signal = params.signal;
+    // Fix M3 — reader calls already carried by a written cost line.
+    let readerCallsLogged = 0;
     // Piece 2 / P2 — fresh "plan changed this turn" flag per TOP-LEVEL turn.
     // Not every path ends in pushPostTurnStatus (the Ink /reroute turn does
     // not), so a mark left by such a turn must not earn the NEXT turn a close
@@ -346,6 +408,26 @@ export async function runTurn(params) {
     const toolRowEmitter = isDeclaredOneShot() ? (params.ctx.chunkEmitter ?? params.chunkEmitter) : params.chunkEmitter;
     const cfg = await loadConfig();
     const session = params.ctx.session;
+    // Task 15 — prompt-cache keepalive while this turn waits (a slow tool, an
+    // approval / ask_question prompt, the save hook). One instance per turn, so
+    // `in_turn_pings` caps the whole turn. Managed and BYOK only (AI-hub and
+    // local have no `keepalive`). `lastRequest` is the SNAPSHOT of the last
+    // request this turn sent (ruling F4), never the live messages array.
+    const keepaliveOn = cfg.keepalive?.enabled !== false && typeof params.provider.keepalive === 'function';
+    const keepalive = new CacheKeepalive({
+        provider: params.provider,
+        maxPings: keepaliveOn ? (cfg.keepalive?.in_turn_pings ?? 11) : 0,
+        // Task 19 — a successful ping keeps the cache warm (read by the cold prune).
+        onPing: (_n, err) => { if (err === undefined)
+            noteCacheTouched(session); },
+    });
+    let lastRequest;
+    // Never ping before a request exists, or when the API cached nothing
+    // (prompt under the minimum cacheable size).
+    const armKeepalive = () => {
+        if (keepaliveOn && lastRequest?.cacheable)
+            keepalive.arm(lastRequest.params, lastRequest.options);
+    };
     // Define `emit` early so the Phase J promote dispatch (below) can stream
     // its prompt + status lines through the same Ink-aware sink the rest of
     // runTurn uses. Originally defined later in the function — hoisted in v0.5
@@ -365,7 +447,10 @@ export async function runTurn(params) {
     let promotedFromForSave = null;
     let userMessageForLLM = params.userMessage;
     let userMessageForSave = params.userMessage;
-    {
+    // Task 18 fix M2 — a reader's brief is plain text from the model: no
+    // --from promotion, no image or @file expansion (lean prefix, and a child
+    // must never open an interactive prompt).
+    if (!readerChild) {
         // Forgiveness: `--from @<document>` (a .docx/.pdf/.txt/.md, not a saved
         // .cspeach.json) means "attach this file", not "chain a result". Rewrite it
         // to a plain @<file> attachment and let Phase D ingest it — never error out
@@ -412,7 +497,9 @@ export async function runTurn(params) {
     // or too many images → the turn is not sent (same early exit as --from).
     // Pasted clipboard images arrive as [Image #N] chips — swap each for its
     // saved file path first, so the step below attaches it like a typed path.
-    const imageExpansion = await expandImageAttachments(expandImageChips(userMessageForLLM), params.ctx.cwd, (line) => emit(chalk.dim(line)));
+    const imageExpansion = readerChild
+        ? { text: userMessageForLLM, images: [] }
+        : await expandImageAttachments(expandImageChips(userMessageForLLM), params.ctx.cwd, (line) => emit(chalk.dim(line)));
     if (imageExpansion.error) {
         emit(chalk.yellow(`
 ${imageExpansion.error}`));
@@ -429,7 +516,9 @@ ${imageExpansion.error}`));
     // The save copy keeps the original `@<filename>` token rather than
     // the expanded body so the saved envelope's source.input stays
     // human-readable; only the LLM sees the inflated prose.
-    userMessageForLLM = await expandTextFileAttachments(userMessageForLLM, params.ctx.cwd, (line) => emit(chalk.dim(line)));
+    if (!readerChild) {
+        userMessageForLLM = await expandTextFileAttachments(userMessageForLLM, params.ctx.cwd, (line) => emit(chalk.dim(line)));
+    }
     // 2026-05-06: alongside the deterministic prompt-fact extraction
     // (package / transport / etc.), inject the connected SAP system's
     // release + platform + ABAP version. One CVERS query the first time
@@ -527,6 +616,90 @@ ${imageExpansion.error}`));
         emit(chalk.dim(`(${droppedImages} older image(s) removed from the conversation to keep it under the size limit)`));
     }
     session.skill = params.skill;
+    // Task 16 (spec D11) — deferred tool loading. The tools array is built ONE
+    // way for the whole session: the core set plus the starters of the skill
+    // pinned on `session.tool_set_skill` are loaded, every other tool is
+    // declared with defer_loading, the tool search tool goes last ('deferred');
+    // or today's full list ('static'). A changed array would break the prompt
+    // cache and the preserved-thinking prefix, so a skill switch APPENDS a
+    // `role: 'system'` tool_addition message instead (after a user message).
+    // Standalone hides the SAP tools (toolsForContext); the agent_run
+    // read-only filter (toolFilter) applies before the split, so a filtered-out
+    // tool is neither loaded nor deferred (cannot be found by search either).
+    session.tool_set_skill ??= params.skill;
+    const toolLoadingMode = resolveToolLoading({
+        providerMode: params.provider.mode,
+        env: process.env,
+        served: servedToolLoading(),
+    });
+    const contextTools = toolsForContext(listTools(), params.ctx);
+    // Task 18 fixes M4 / M5 — no read_agent for an agent_run child, and none
+    // when a reader would have no real read tool (standalone, file tools off).
+    const visibleTools = params.ctx.subagent || !hasReaderReadTools(new Set(contextTools.map((t) => t.name)))
+        ? contextTools.filter((t) => t.name !== READ_AGENT)
+        : contextTools;
+    // Final review C1 (controller ruling) — deferred shapes only for a model on
+    // the probe-proven allow-list, decided by the model actually sent on the
+    // call (a plan-tier sonnet override, a haiku child or claude-opus-4-8 ⇒
+    // static). Integration finding N1 (b): decided ONCE, at turn start — a
+    // model change mid-turn (an adopted served model) never strips deferred
+    // shapes in the middle of a turn (that would edit the prefix the in-flight
+    // thinking is bound to): the turn finishes on its own mode and the
+    // session settles at the next turn start. The proxy converts a deferred
+    // request for a model off its allow-list to static upstream.
+    // Final review I2 (controller ruling) — the mode is pinned on the session
+    // (session.tool_loading) at the first request and kept on resume; a
+    // deferred session that must turn static (kill switch, failed startup
+    // fetch, a model off the allow-list) has its deferred shapes stripped ONCE
+    // (a deliberate rewrite like /compact) and is re-pinned static.
+    const callToolMode = (model) => {
+        const settled = settleSessionToolLoading(session, { resolved: toolLoadingMode, model });
+        if (settled.stripped > 0) {
+            emit(chalk.dim('(this session now sends the full tool list — earlier tool-search steps were removed from the conversation)'));
+        }
+        return settled.mode;
+    };
+    const filteredTools = params.toolFilter ? visibleTools.filter(params.toolFilter) : visibleTools;
+    const builtTools = new Map();
+    const toolsFor = (mode) => {
+        let list = builtTools.get(mode);
+        if (!list) {
+            list = buildToolList(filteredTools, { skill: session.tool_set_skill, mode });
+            builtTools.set(mode, list);
+        }
+        return list;
+    };
+    // Task 18 — a reader's fixed list bypasses buildToolList entirely.
+    const readerTools = params.toolsOverride
+        ? toAnthropicTools(params.toolsOverride
+            .map((n) => visibleTools.find((t) => t.name === n))
+            .filter((t) => t !== undefined))
+        : undefined;
+    // Integration finding N1 (a) — the model each call is SENT with: an
+    // enforced customer model (managed, session role) replaces the pinned one,
+    // so call 0 already takes the static list when enforcement serves a model
+    // off the deferred allow-list.
+    const sentModel = () => callModelFor(params.modelOverride ?? session.model, { providerMode: params.provider.mode, role: params.modelRole });
+    const turnTools = readerTools ?? toolsFor(callToolMode(sentModel()));
+    /**
+     * Append a tool_addition for a skill's starters not yet loaded or surfaced.
+     * N1 (c) — built from the turn's list (the list every request of this turn
+     * carries) and never for a session pinned static.
+     */
+    const surfaceStarters = (skill) => {
+        const msg = buildSkillToolAddition({
+            skill,
+            toolLoading: session.tool_loading,
+            toolList: turnTools,
+            messages: session.messages,
+        });
+        if (msg)
+            session.messages.push(msg);
+    };
+    // A turn on a different skill than the one the array was built for: the
+    // user message was just pushed, so the system message follows it.
+    if (params.skill !== session.tool_set_skill)
+        surfaceStarters(params.skill);
     /**
      * key: `${tool_name}:${object}` — consecutive failures per (tool, target).
      * For object-identifying tools (sap_set_source / sap_activate / etc.) the
@@ -554,6 +727,10 @@ ${imageExpansion.error}`));
     };
     // Turn number for the cost log — count of prior user messages + this one.
     const turnNumber = session.messages.filter((m) => m.role === 'user').length + 1;
+    // Final review I4 — the monotonic per-session turn counter the auto-compact
+    // throttle compares (turnNumber above shrinks after a compaction). An older
+    // session seeds it so it never starts below its stored marker.
+    session.turn_seq = (session.turn_seq ?? Math.max(turnNumber - 1, session.lastAutoCompactTurn ?? 0)) + 1;
     // Snapshot session.messages.length at turn start so the save hook can
     // walk every assistant message added during this turn — not just the
     // final one. Skills like /abap-cca emit their manifest in an early
@@ -579,8 +756,24 @@ ${imageExpansion.error}`));
     // long phase (e.g. /abap-plan c2.behavior) that overruns the output cap
     // mid-response finishes instead of dying with "unexpected stop reason".
     let maxTokenContinuations = 0;
+    // Task 16 (F6) — bounded re-sends on stop_reason 'pause_turn' (a server
+    // tool paused a long turn). Consecutive only: reset by any other round.
+    let pauseTurnContinuations = 0;
+    // Task 3 (2026-09-27) — 0-based index of each model call within this turn,
+    // recorded on the cost line as `call_index`.
+    let roundIndex = 0;
     // (emit was hoisted to the top of the function in v0.5 so the Phase J
     //  promote dispatch could share it. Original location was here.)
+    // Task 19 (owner decision 7) — cold-cache prune, default OFF
+    // (CSPEACH_COLD_PRUNE=on). Once, before the first createStream: when the
+    // cache has expired (> 300 s since the last call / ping) the next call
+    // re-writes the history anyway, so old tool results are elided first.
+    {
+        const pruned = maybeColdPrune(session);
+        if (pruned > 0) {
+            emit(chalk.dim(`(cache was cold — ${pruned} old tool result(s) elided to keep the rewrite small)`));
+        }
+    }
     while (true) {
         // Mid-turn steering (2026-06-08): inject any user corrections typed since the
         // last round so the next createStream sees them. Drains at the top of EVERY
@@ -589,7 +782,7 @@ ${imageExpansion.error}`));
         // Anthropic API concatenates consecutive user messages, so injecting after a
         // tool_result user message is valid.
         {
-            const steers = drainSteering();
+            const steers = readerChild ? [] : drainSteering();
             if (steers.length > 0) {
                 const text = steers.join('\n');
                 session.messages.push({ role: 'user', content: text });
@@ -615,7 +808,7 @@ ${imageExpansion.error}`));
         // routed) covers liveness feedback. Classic mode (no chunkEmitter)
         // keeps the stdout spinner unchanged.
         // Guard: test/unit/ink-cursor-invariant.test.ts.
-        turnStatusEmitter.activity('thinking');
+        status.activity('thinking');
         const thinkingSpinner = startThinkingSpinner({ chunkEmitter: livenessEmitter });
         // v0.6 — guaranteed-visible heartbeat alongside the in-place spinner.
         // The spinner self-disables on non-TTY (Windows PowerShell sometimes
@@ -627,6 +820,9 @@ ${imageExpansion.error}`));
         // being raw-written to stdout (which Ink overdraws on its next
         // render, briefly flashing the line then making it disappear).
         const thinkingHeartbeat = startThinkingHeartbeat({ chunkEmitter: livenessEmitter });
+        // Task 15 — the request actually sent by the attempt that succeeded.
+        let sentParams;
+        let sentHeaders;
         try {
             stream = await retryWithBackoff(() => (async () => {
                 // W2.5 — apply optional tool filter (used by agent_run with
@@ -634,9 +830,11 @@ ${imageExpansion.error}`));
                 // the subagent). Mirrors CC's Tq2() pattern.
                 // Standalone (2026-09-16): hide every SAP-dependent tool from the
                 // model — calling one could only fail. Identity when connected.
-                const allTools = toolsForContext(listTools(), params.ctx);
-                const filteredTools = params.toolFilter ? allTools.filter(params.toolFilter) : allTools;
-                const tools = toAnthropicTools(filteredTools);
+                // Task 16 — built once per mode above (byte-stable per session).
+                // Final review C1/I2 + N1 (b) — the turn's mode, settled at turn
+                // start (any one-time deferred → static strip ran there).
+                const model = sentModel();
+                const tools = turnTools;
                 // Bug 11a (proactive heal, 2026-06-07) — strip any residual
                 // `partial_json` from tool_use blocks on EVERY outgoing request.
                 // `content_block_stop` normally deletes it (see below), but any miss —
@@ -650,10 +848,22 @@ ${imageExpansion.error}`));
                 // the single chokepoint every request passes through, retries included —
                 // makes the 400 categorically impossible. Idempotent and O(messages).
                 healSessionMessagesInPlace(session.messages);
-                // 2026-09-27 — same chokepoint: a thinking block without its
-                // signature (a turn cancelled mid-thinking, saved by an older CLI)
-                // 400s every later request with "Invalid `signature` in `thinking`
-                // block". Drop it; the model simply thinks again.
+                // Task 7 (spec D8) — preserved thinking binds each thinking block to
+                // the exact prefix that produced it, so history must be append-only.
+                // The heals below are no-ops on a history the API accepted (they only
+                // touch blocks the API would have rejected, or drop the LAST assistant
+                // message when it is thinking-only — no later block is bound to a
+                // prefix containing it), so they are not prefix edits. Order (merge
+                // with the UI branch's round-4 heal, cost finding core-I5): tool-mode
+                // settle (turn start) → partial_json → unsigned thinking →
+                // trailing thinking-only → orphan tool results → system placement
+                // LAST, because the earlier heals may remove the last assistant
+                // message and so change the tail placeSystemMessagesInPlace works on.
+                //
+                // 2026-09-27 — a thinking block without its signature (a turn
+                // cancelled mid-thinking, saved by an older CLI) 400s every later
+                // request with "Invalid `signature` in `thinking` block". Drop it;
+                // the model simply thinks again.
                 stripUnsignedThinking(session.messages);
                 dropTrailingThinkingOnly(session.messages);
                 // 2026-09-24 — same chokepoint: a tool call cut off before its
@@ -661,37 +871,87 @@ ${imageExpansion.error}`));
                 // `continue` could never succeed). Give each orphan an error result
                 // so the model sees the call did not complete and redoes it.
                 const healedOrphans = healOrphanToolUses(session.messages);
+                // Task 16 (probe D2) — a system tool_addition must precede an
+                // assistant message or end the array ([system, user] is a 400).
+                // Same chokepoint: covers steering, the watchdog nudge and a turn
+                // that ended before the model answered the tool_addition.
+                placeSystemMessagesInPlace(session.messages);
                 if (healedOrphans > 0) {
                     emit(chalk.dim(`(repaired ${healedOrphans} tool call(s) cut off by an interruption — the model will redo them)`));
                 }
+                // Task 4 — effort only from an explicit act (ruling F2); never to a
+                // model that rejects it (probe P1: claude-haiku-4-5* ⇒ 400).
+                const effort = params.effortOverride ?? resolveEffort(cfg);
+                const sendEffort = effort !== undefined && modelAcceptsEffort(model);
                 const streamParams = {
                     // A4 — per-turn override (plan model tiering) wins over the
-                    // configured default; absent on every non-plan turn. model-governance
-                    // step 2d — the session-default model now resolves env > local >
-                    // server > built-in (byte-identical to cfg.default_model when nothing set).
-                    model: params.modelOverride ?? resolveModelRole('session_default', cfg),
+                    // session model; absent on every non-plan turn. Task 3 (2026-09-27)
+                    // — the session's PINNED model, resolved once at newSession
+                    // (env > local > server > built-in) after the served config was
+                    // awaited. A per-call resolve let call 0 run on the built-in and
+                    // call 1 on the late-landing served model: a full cache rewrite.
+                    model,
                     // v0.3.1 — was 8192. Bumped because code-gen skills (abap-generate
                     // etc.) kept running out of budget mid-turn: adaptive thinking +
                     // multiple tool-result prompts + TL;DR mandate + summary prose
                     // + the final question widget didn't fit in 8K. Symptom: stream
                     // ended with stop_reason='length' right before the widget, and
                     // the user saw the skill "stuck" after the intro prose.
-                    // 32768 is Opus 4.7's recommended ceiling for agentic turns and
-                    // gives comfortable headroom for the investigate-first pattern.
-                    max_tokens: params.maxTokensOverride ?? 32768,
+                    // Task 8 (2026-09-27, ruling F5) — thinking counts toward
+                    // max_tokens. 32768 truncated a turn once in the 2026-09 profile,
+                    // and Opus 5.x thinks more per turn, so claude-opus-5* session
+                    // turns get 65536 (the guide's starting point for long agentic
+                    // turns; probe P2 accepted it on claude-opus-5 and
+                    // claude-opus-5-5). Every other model keeps 32768: its output
+                    // limit is not verified here. Changing max_tokens breaks neither
+                    // the prompt cache nor the thinking block binding. Follows the
+                    // model actually sent (plan-tier sonnet turns stay at 32768);
+                    // maxTokensOverride (subagents) still wins below the ceiling.
+                    // I1 (2026-09-28) — clamped to the sent model's output ceiling:
+                    // an agent_run child asks for 100000, which an enforced
+                    // sonnet/haiku model rejects with a 400.
+                    max_tokens: clampMaxTokens(model, params.maxTokensOverride ?? sessionMaxTokens(model)),
                     messages: session.messages,
                     tools,
-                    thinking: { type: 'adaptive', display: 'summarized' },
+                    // Task 7 — preserved thinking. Opus 5.5 binds each thinking block
+                    // to the exact prefix that produced it; `drop_block` makes the API
+                    // drop a block whose prefix changed (reported on message_start's
+                    // input_transformations) instead of rejecting the request. Only to
+                    // the families probe P4 proved (allow-list, dated ids stripped).
+                    // Task 21 fix round (controller ruling) — on the managed path only
+                    // when the proxy serves tool_loading (an old proxy adds no binding
+                    // beta); BYOK adds its own beta; AI-hub/local strip the field.
+                    thinking: modelAcceptsBinding(model) && (params.provider.mode !== 'managed' || managedProxyServesNewShapes())
+                        ? { type: 'adaptive', display: 'summarized', block_binding: { prefix_mismatch_behavior: 'drop_block' } }
+                        : { type: 'adaptive', display: 'summarized' },
+                    ...(sendEffort ? { output_config: { effort } } : {}),
                 };
                 // Skill travels as a header per coordination doc §1.
                 // Do NOT add `skill` to streamParams — it is not part of the Anthropic SDK body schema.
                 // v0.6 — forward the per-turn abort signal so Esc / SIGINT-during-turn
                 // tears down the in-flight stream cleanly.
+                const headers = { 'X-CSForge-Skill': params.skill, 'X-CSPeach-Model-Role': params.modelRole ?? 'session_default' };
+                sentParams = streamParams;
+                sentHeaders = headers;
                 return params.provider.createStream(streamParams, {
-                    headers: { 'X-CSForge-Skill': params.skill },
+                    // Task 9 — the role header tells the proxy which pipeline role
+                    // this call runs under (body unchanged).
+                    headers,
                     signal: params.signal,
                 });
             })());
+            // Task 15 (F14) — stamp every successful createStream; Task 19 reads it.
+            session.last_request_at = new Date().toISOString();
+            // Task 15 (F4) — snapshot NOW, before the loop pushes this round's
+            // assistant message: the snapshot ends on a user message. Also left on
+            // the session (WeakMap, never persisted) for the REPL's idle keepalive.
+            if (keepaliveOn && sentParams) {
+                lastRequest = recordLastRequest(session, {
+                    params: snapshotParams(sentParams),
+                    options: { headers: { ...(sentHeaders ?? {}) } },
+                    cacheable: false, // set from message_start usage below
+                });
+            }
         }
         catch (err) {
             // Stop the thinking spinner before printing any error — leaving
@@ -734,12 +994,26 @@ ${imageExpansion.error}`));
             throw err;
         }
         let currentAssistantContent = [];
+        // Task 3 — this call's index within the turn, and the model the server
+        // reported in `message_start` (may differ from the requested id).
+        const callIndex = roundIndex++;
+        let lastServedModel;
         // 2026-09-27 — blocks whose content_block_stop arrived. A thinking block
         // not in here was cut mid-stream and must never be persisted.
         const completedBlocks = new WeakSet();
         let sawEndTurn = false;
         let sawToolUse = false;
         let sawMaxTokens = false;
+        let sawPauseTurn = false;
+        // Task 6 — a safety classifier declined the request (HTTP 200,
+        // stop_reason 'refusal'). Branch on stop_reason only; stop_details is
+        // captured for the cost log (its category), never shown to the user.
+        let sawRefusal = false;
+        let refusalCategory;
+        // Task 7 — thinking blocks the API dropped (prefix binding mismatch), from
+        // message_start.message.input_transformations. Cost line only; the user
+        // sees nothing.
+        let inputTransformations;
         // M10 — ensure session.usage is present (shipped session schema may omit it
         // for older saved sessions; we default to zero on first turn).
         if (!session.usage) {
@@ -782,7 +1056,7 @@ ${imageExpansion.error}`));
                     // content. Long emissions (a 4k-token plan manifest) can look
                     // silent if the renderer buffers the block — the row keeps
                     // ticking "writing response · 90s" regardless.
-                    turnStatusEmitter.activity('writing response');
+                    status.activity('writing response');
                     writingCode = false;
                     const block = event.content_block;
                     currentAssistantContent.push(block);
@@ -803,7 +1077,7 @@ ${imageExpansion.error}`));
                         const wa = nextWritingActivity(writingCode, buffer.pending);
                         writingCode = wa.writingCode;
                         if (wa.label)
-                            turnStatusEmitter.activity(wa.label);
+                            status.activity(wa.label);
                         if (output) {
                             if (params.chunkEmitter)
                                 params.chunkEmitter.emit('chunk', output);
@@ -838,7 +1112,10 @@ ${imageExpansion.error}`));
                     const last = currentAssistantContent[currentAssistantContent.length - 1];
                     if (last && typeof last === 'object')
                         completedBlocks.add(last);
-                    if (last?.type === 'tool_use' && last.partial_json) {
+                    // Task 16 (F6) — the tool search tool's server_tool_use streams its
+                    // input as input_json_delta too (probe P6); parse and strip it the
+                    // same way, or the next request 400s on partial_json.
+                    if ((last?.type === 'tool_use' || last?.type === 'server_tool_use') && last.partial_json) {
                         try {
                             last.input = JSON.parse(last.partial_json);
                         }
@@ -849,9 +1126,26 @@ ${imageExpansion.error}`));
                     }
                 }
                 else if (type === 'message_start') {
+                    // Task 3 — the model the server actually ran (adopted after the
+                    // stream in managed mode only; see below).
+                    const servedModel = event.message?.model;
+                    if (typeof servedModel === 'string' && servedModel)
+                        lastServedModel = servedModel;
+                    // Task 7 — present only when the binding beta was sent; [] when
+                    // nothing was dropped (summarised to undefined ⇒ no cost-line key).
+                    inputTransformations = summariseInputTransformations(event.message?.input_transformations);
                     // message_start carries the prompt usage (input tokens + any cache reads).
                     const msgUsage = event.message?.usage;
+                    // Task 15 — ping only a prompt the API actually cached.
+                    if (lastRequest && isCacheablePrompt(msgUsage))
+                        lastRequest.cacheable = true;
                     if (msgUsage) {
+                        // Task 19 (F12) — this call's full prompt size, read by the
+                        // end-of-turn auto-compact gate (the last call of the turn wins).
+                        session.last_context_tokens =
+                            (msgUsage.input_tokens ?? 0)
+                                + (msgUsage.cache_read_input_tokens ?? 0)
+                                + (msgUsage.cache_creation_input_tokens ?? 0);
                         session.usage.input_tokens += msgUsage.input_tokens ?? 0;
                         session.usage.cache_read_input_tokens += msgUsage.cache_read_input_tokens ?? 0;
                         // Phase 1 cost tracking — cache writes are billed at 1.25× input.
@@ -877,6 +1171,13 @@ ${imageExpansion.error}`));
                         sawToolUse = true;
                     if (stop_reason === 'max_tokens' || stop_reason === 'length')
                         sawMaxTokens = true;
+                    if (stop_reason === 'pause_turn')
+                        sawPauseTurn = true;
+                    if (stop_reason === 'refusal') {
+                        sawRefusal = true;
+                        const category = event.delta?.stop_details?.category;
+                        refusalCategory = typeof category === 'string' && category ? category : 'unknown';
+                    }
                     // H2 — `deltaUsage.output_tokens` is the cumulative running total for
                     // THIS message, NOT a per-event delta. Compute the increment vs the
                     // last-seen cumulative and add only that. Guard against `null` /
@@ -924,11 +1225,57 @@ ${imageExpansion.error}`));
         // only DROPS a block when its `input` is undefined — which never happens on
         // a clean round (content_block_stop always sets `input`), so this is a
         // no-op-except-strip on the happy path. See ./repair-partial.ts.
-        currentAssistantContent = repairPartialBlocks(currentAssistantContent, { completed: completedBlocks });
-        // Review M2 — a cut right after the thinking block leaves a thinking-only
-        // turn: nothing the user can read, and nothing the next request needs.
+        // Task 6 — after a server-side fallback, the first model's thinking /
+        // tool_use blocks before the last `fallback` block must not be echoed back.
+        // The `fallback` block itself stays (the adoption guard below reads it).
+        currentAssistantContent = stripPreFallbackBlocks(repairPartialBlocks(currentAssistantContent, { completed: completedBlocks }));
+        // Review M2 (UI branch) — a cut right after the thinking block leaves a
+        // thinking-only turn: nothing the user can read, and nothing the next
+        // request needs.
+        // Integration M1 — a `fallback` block is neutral to that test, so
+        // [fallback, thinking] is dropped too; remember the fallback first so
+        // the adoption guard below still refuses to pin the fallback model.
+        const carriedFallback = currentAssistantContent.some((b) => b?.type === 'fallback');
         if (isThinkingOnly(currentAssistantContent))
             currentAssistantContent = [];
+        // Task 3 (F10) — adopt the served model. Managed mode only: BYOK / AI-hub
+        // / local streams report a local alias, which would leave the session
+        // unpriced. Never on a per-turn override, and never on a message carrying
+        // a `fallback` block (a refusal fallback must not pin the fallback model
+        // for the rest of the session). Otherwise the served id is only logged.
+        if (params.provider.mode === 'managed'
+            && !params.modelOverride
+            && typeof lastServedModel === 'string'
+            && lastServedModel
+            && !carriedFallback
+            // Task 6 — a refused message is discarded, so it proves nothing about
+            // the model (and may have been served by a fallback).
+            && !sawRefusal
+            // Probe ruling C1 — served ids can carry a -YYYYMMDD suffix (haiku-4-5
+            // is served as claude-haiku-4-5-20251001): a dated id equal to the
+            // pinned id is not a model switch.
+            && stripModelDate(session.model) !== stripModelDate(lastServedModel)) {
+            session.model = lastServedModel;
+            session.served_model_source = 'served';
+            // Task 12 — explain the switch, once per session, only when the proxy
+            // enforces the account admin's choice (/v1/me/model-config enforced)
+            // AND the served model IS that choice (dated suffix ignored) — any
+            // other switch (e.g. a version-gate downgrade) is not the admin's doing.
+            const customer = getCustomerModelConfig();
+            if (customer?.enforced === true
+                && typeof customer.model === 'string'
+                && stripModelDate(customer.model) === stripModelDate(lastServedModel)
+                && !adminModelLineShown.has(session)) {
+                adminModelLineShown.add(session);
+                emit(chalk.dim(`Using ${lastServedModel} (set by your account admin)`));
+            }
+        }
+        // Task 6 — a refusal (before any output or mid-stream) is not an answer:
+        // discard whatever partial content streamed so nothing is persisted as a
+        // complete assistant message. The cost line below is still written.
+        if (sawRefusal) {
+            currentAssistantContent = [];
+        }
         // Persist the assistant message — even if it's partial. Empty content
         // arrays are skipped so we don't push a meaningless empty assistant
         // message that would confuse the next round.
@@ -976,7 +1323,11 @@ ${imageExpansion.error}`));
             // the cost line so the JSONL records what the LEDGER charged alongside
             // our COGS, and so the status footer the REPL prints next reads a fresh
             // figure. No-op + no request outside credits mode; capped at 2.5 s.
-            await refreshCreditsAfterTurn();
+            // Task 18 — a reader child never samples the balance: its charge then
+            // lands in the parent's next credits delta, and parallel readers never
+            // race on the shared sample.
+            if (!readerChild)
+                await refreshCreditsAfterTurn();
             const turnTokens = {
                 input: (session.usage?.input_tokens ?? 0) - turnStartTokens.input,
                 output: (session.usage?.output_tokens ?? 0) - turnStartTokens.output,
@@ -994,8 +1345,23 @@ ${imageExpansion.error}`));
                 duration_ms: turnDurationMs,
                 // Additive: present only in credits mode (undefined in USD mode, so
                 // the emitted line is byte-identical to a pre-credits one).
-                credits: creditsForCostLog(),
+                credits: readerChild ? undefined : creditsForCostLog(),
+                // Task 3 — what the server reported, which call of the turn, and
+                // the call kind. served_model is omitted when the stream had none.
+                served_model: lastServedModel ?? undefined,
+                call_index: callIndex,
+                // Task 18 — a reader child's lines (its own reader-*-cost.jsonl) say so.
+                kind: readerChild ? 'reader' : 'main',
+                // Task 6 — present only on a refusal ('unknown' when stop_details
+                // carried no category). Never the explanation text.
+                refusal_category: sawRefusal ? refusalCategory : undefined,
+                // Task 7 — present only when the API dropped thinking blocks.
+                input_transformations: inputTransformations,
+                // Task 18 (F24) — running reader totals of this turn (absent until a
+                // reader has run).
+                reader: params.ctx.readerSpend,
             });
+            readerCallsLogged = params.ctx.readerSpend?.calls ?? 0;
             void appendCostLine(session.id, entry);
         }
         // Close the stream-to-disk mirror with a footer (lightweight diagnostics).
@@ -1008,6 +1374,18 @@ ${imageExpansion.error}`));
         // graceful error UX with full session-id + log-path context.
         if (interruptedError !== null)
             throw interruptedError;
+        // Task 6 — the model declined. One plain line (no vendor name, no
+        // category, no policy text), then end the turn. Nothing was persisted.
+        if (sawRefusal) {
+            emit('\n' + formatAttention({
+                text: 'The model declined this request',
+                fact: 'a safety filter stopped it',
+                next: 'rephrase it, or split it into smaller steps',
+            }).trimEnd());
+            session.awaitingSkillAnswer = false;
+            await saveSession(session);
+            return;
+        }
         if (sawEndTurn) {
             emit('');
             // v0.6 Layer 3 — stream-end watchdog warning. The between-rounds
@@ -1052,7 +1430,7 @@ ${imageExpansion.error}`));
             // their manifest in an early message before a closing ask_question
             // widget; the final wrap-up message ends the turn but doesn't
             // carry the manifest. See ./turn-assistant-text.ts for details.
-            turnStatusEmitter.activity('finishing up');
+            status.activity('finishing up');
             const assistantText = collectTurnAssistantText(session.messages, turnStartMessageCount);
             // 2026-09-17 — the save hook below asks the user things (save y/N,
             // blocker pickers). Those are not tool dispatches, so nothing paused
@@ -1060,9 +1438,11 @@ ${imageExpansion.error}`));
             // while the user was the one being waited on (Laeeq's dry run). Pause
             // for the whole hook — the row hides while paused — and resume after,
             // so any real work that follows (auto-compact) shows again.
-            turnStatusEmitter.pause();
+            status.pause();
             try {
                 if (!params.suppressSaveHook) {
+                    // Task 15 — the save prompt waits on the user; keep the cache warm.
+                    armKeepalive();
                     await maybeOfferSave({
                         skill: params.skill,
                         assistantText,
@@ -1078,7 +1458,8 @@ ${imageExpansion.error}`));
                 }
             }
             finally {
-                turnStatusEmitter.resume();
+                keepalive.disarm();
+                status.resume();
             }
             // Phase 2 #9 (2026-05-16) — auto-compact end-of-turn hook.
             // Runs only on the success path (after maybeOfferSave) so an interrupted
@@ -1086,30 +1467,68 @@ ${imageExpansion.error}`));
             // helper internally swallows non-fatal errors and emits a yellow note so
             // a Haiku blip never regresses a turn that just succeeded. Threshold and
             // throttle live in config.compact — see config/loader.ts:CompactConfig.
-            try {
-                const { maybeAutoCompact } = await import('../commands/auto-compact.js');
-                const { buildSummarisationPrompt, serialiseForSummariser } = await import('../commands/compact.js');
-                const { summariseViaProvider } = await import('./summarise-via-provider.js');
-                await maybeAutoCompact({
-                    session,
-                    config: cfg.compact,
-                    turnNumber,
-                    emit,
-                    summarise: async (toSummarise) => summariseViaProvider(params.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' } }),
-                });
-            }
-            catch (err) {
-                // Belt-and-braces — maybeAutoCompact already swallows internally,
-                // but if its own dynamic-import or wiring blows up we still must
-                // not regress the success path.
-                emit(chalk.gray(`[auto-compact] skipped: ${err instanceof Error ? err.message : String(err)}`));
+            // Task 19 — top-level REPL turns only (never one-shot, subagents or
+            // readers); the gate reads session.last_context_tokens against the
+            // resolved threshold (file > served auto_compact_tokens > 150 000).
+            if (params.autoCompact === true) {
+                try {
+                    const { maybeAutoCompact } = await import('../commands/auto-compact.js');
+                    const { buildSummarisationPrompt, serialiseForSummariser } = await import('../commands/compact.js');
+                    const { summariseViaProvider } = await import('./summarise-via-provider.js');
+                    await maybeAutoCompact({
+                        session,
+                        config: { ...cfg.compact, auto_threshold_tokens: resolveAutoCompactThreshold(cfg) },
+                        turnNumber: session.turn_seq,
+                        emit,
+                        summarise: async (toSummarise) => summariseViaProvider(params.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', 'X-CSPeach-Model-Role': 'compact' } }),
+                    });
+                }
+                catch (err) {
+                    // Belt-and-braces — maybeAutoCompact already swallows internally,
+                    // but if its own dynamic-import or wiring blows up we still must
+                    // not regress the success path.
+                    emit(chalk.gray(`[auto-compact] skipped: ${err instanceof Error ? err.message : String(err)}`));
+                }
             }
             return;
         }
-        if (!sawToolUse) {
+        // Task 6 fix round 1 — stop_reason 'tool_use' but no tool_use block left
+        // (e.g. the only one preceded a `fallback` block and was stripped). There
+        // is nothing to dispatch; looping would re-send the same history. End the
+        // turn (the message is already persisted).
+        if (sawToolUse && !currentAssistantContent.some((b) => b?.type === 'tool_use')) {
+            emit(chalk.yellow('\n[the model stopped for a tool call but sent none — ending turn]'));
+            session.awaitingSkillAnswer = false;
+            await saveSession(session);
+            return;
+        }
+        if (!sawPauseTurn)
+            pauseTurnContinuations = 0;
+        // Task 16 review — a paused message that already carries a client
+        // tool_use is dispatched like a tool_use stop (its result is the next
+        // user message), not re-sent blind.
+        const pausedWithToolUse = sawPauseTurn && currentAssistantContent.some((b) => b?.type === 'tool_use');
+        if (pausedWithToolUse)
+            pauseTurnContinuations = 0;
+        if (!sawToolUse && !pausedWithToolUse) {
+            // Task 16 (F6) — 'pause_turn': a server tool (tool search) paused the
+            // turn. The paused assistant message is already persisted; re-send
+            // with it last and NO new user message, so the model resumes. At most
+            // 3 in a row (never observed in probe P6, handled anyway).
+            const MAX_PAUSE_CONTINUATIONS = 3;
+            if (sawPauseTurn) {
+                if (pauseTurnContinuations < MAX_PAUSE_CONTINUATIONS) {
+                    pauseTurnContinuations += 1;
+                    continue;
+                }
+                emit(chalk.yellow(`\n[the model paused ${MAX_PAUSE_CONTINUATIONS + 1} times in a row — stopping. Type "continue" to resume.]`));
+                session.awaitingSkillAnswer = false;
+                await saveSession(session);
+                return;
+            }
             // The response was cut off at the output-token cap (stop_reason
             // 'max_tokens'/'length') mid-generation — NOT a real end of turn. The
             // truncated assistant message is already persisted (line ~733), so
@@ -1146,102 +1565,186 @@ ${imageExpansion.error}`));
         // continue to run normally. See ./parallel-write-guard.ts.
         const writeGuard = newGuardState();
         const toolResults = [];
+        // Task 18 (spec D18, rulings F21, F27) — concurrent reader group. The
+        // ⏺ lines print first, then one spinner / heartbeat / status label
+        // ("N readers running…"). At most MAX_PARALLEL_READERS run at once; each
+        // gets a shallow ctx clone with its own toolUseId (the shared slot is
+        // never used) and an adt whose calls go through ONE lock (one ADT request
+        // at a time). The keepalive is armed once for the group.
+        const readerResults = new Map();
+        const runReaderGroup = async (group) => {
+            const label = `${group.length} reader${group.length === 1 ? '' : 's'} running…`;
+            for (const b of group) {
+                renderToolCallTop({ name: b.name, args: (b.input ?? {}), chunkEmitter: toolRowEmitter });
+            }
+            const groupSpinner = startToolSpinner({ chunkEmitter: livenessEmitter, label });
+            status.activity(label);
+            const groupHeartbeat = startThinkingHeartbeat({ chunkEmitter: livenessEmitter, label });
+            const adtLock = createAdtLock();
+            armKeepalive();
+            try {
+                for (let i = 0; i < group.length; i += MAX_PARALLEL_READERS) {
+                    // Fix I1 — Esc / Ctrl+C: no further chunk starts; every reader not
+                    // started gets an interrupted result so each tool_use stays paired.
+                    if (params.signal?.aborted) {
+                        for (const b of group.slice(i)) {
+                            readerResults.set(b.id, { result: { content: INTERRUPTED_LINE, is_error: true }, durationMs: 0 });
+                        }
+                        break;
+                    }
+                    await Promise.all(group.slice(i, i + MAX_PARALLEL_READERS).map(async (b) => {
+                        const started = Date.now();
+                        const clone = {
+                            ...params.ctx,
+                            toolUseId: b.id,
+                            adt: params.ctx.adt ? serializeAdt(params.ctx.adt, adtLock) : params.ctx.adt,
+                        };
+                        let r;
+                        try {
+                            r = await dispatchTool(b.name, b.input, clone);
+                        }
+                        catch (err) {
+                            r = { content: JSON.stringify({ error: String(err) }), is_error: true };
+                        }
+                        readerResults.set(b.id, { result: r, durationMs: Date.now() - started });
+                    }));
+                }
+            }
+            finally {
+                keepalive.disarm();
+                groupHeartbeat.stop();
+                groupSpinner.stop();
+            }
+            // Fix M3 — an interrupted turn writes no further model-call line, so
+            // the readers' spend is recorded now on a zero-token rollup line.
+            const spend = params.ctx.readerSpend;
+            if (params.signal?.aborted && spend && spend.calls > readerCallsLogged) {
+                void appendCostLine(session.id, buildCostEntry({
+                    turn: turnNumber,
+                    model: params.modelOverride ?? session.model,
+                    tokens: { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 },
+                    kind: 'reader_rollup',
+                    reader: spend,
+                }));
+                readerCallsLogged = spend.calls;
+            }
+        };
         for (const block of currentAssistantContent) {
             if (block.type === 'tool_use') {
-                // Phase 1: print the dispatch line (CC-style: ⏺ name(args)).
-                // No-op for widget-suppressed tools (ask_question) — the form/modal
-                // is the visible representation; see tool-widget.ts.
-                renderToolCallTop({
-                    name: block.name,
-                    args: (block.input ?? {}),
-                    chunkEmitter: toolRowEmitter,
-                });
-                // Phase 2a: start the peach-themed spinner. No-op outside TTY / Ink
-                // / CI — the result line still prints, just without the in-place
-                // animation. Spinner is purely a "still working" cue, not
-                // load-bearing for output. Skipped entirely for widget-suppressed
-                // tools (ask_question): with the ⏺ line gone the spinner would
-                // orphan on its own row above the form.
-                const spinner = isWidgetSuppressedTool(block.name)
-                    ? { stop: () => undefined }
-                    : startToolSpinner({ chunkEmitter: livenessEmitter, label: toolActivityText(block.name, (block.input ?? {})) });
-                // 2026-06-06 (turn-liveness, B5 smoke feedback) — the in-place tool
-                // spinner self-disables under Ink (phantom cursor #25), which left
-                // slow tool calls (SAP over VPN: 10-60s) as DEAD AIR between the ⏺
-                // dispatch line and the ⎿ result line. Labelled heartbeat prints
-                // fresh "<tool> running… (10s)" lines at thresholds — visible on
-                // every terminal, Ink included.
-                // Interactive tools wait on the USER, not the system — ticking
-                // "ask_question running… (30s)" while they think is noise.
-                // CRITICAL race fix (2026-06-13) — a mutating tool that will trip the
-                // Rule 8 batch gate (2nd+ write of the turn) ALSO blocks on the user:
-                // presentSafetyConfirmation opens an Ink modal from inside dispatchTool
-                // BEFORE the op runs. file_write / shell_exec are otherwise classified
-                // non-interactive, so without this the loop would start the per-second
-                // heartbeat + keep the turn-status row ticking UNDER the modal — the
-                // observed live bug (doubled card, lost Enter, history-replay leak,
-                // ~10-min wedge with the tool spinner ticking under the modal). Detect
-                // the gate the SAME way tool-dispatch does (tool.isMutating &&
-                // shouldGateRule8) and treat it as user-blocking: pause the status row,
-                // skip the heartbeat. The gate's own clearActiveSpinner +
-                // turnStatusEmitter.pause (safety-confirm.ts) is the inner belt; this
-                // is the outer one — together no live render source contends with the
-                // modal for the Ink frame or raw-mode stdin.
-                const willTripBatchGate = (() => {
-                    const t = getTool(block.name);
-                    return !!t?.isMutating && shouldGateRule8();
-                })();
-                const isInteractiveTool = block.name === 'ask_question' ||
-                    block.name === 'request_approval' ||
-                    willTripBatchGate;
-                // Interactive tools block on the USER. PAUSE the turn-status row (don't
-                // just relabel it): a live 250ms tick repaints the dynamic frame and
-                // overdraws the inquirer approval picker / churns the Ink ask_question
-                // modal — the hidden-question + stacked-border + lost-Enter bug
-                // (2026-06-07). resume() in the finally brings it back the moment the
-                // user answers. Non-interactive tools keep the ticking label + heartbeat.
-                if (isInteractiveTool)
-                    turnStatusEmitter.pause();
-                else
-                    turnStatusEmitter.activity(toolActivityText(block.name, (block.input ?? {})));
-                const toolHeartbeat = isInteractiveTool
-                    ? { stop: () => undefined }
-                    : startThinkingHeartbeat({
-                        chunkEmitter: livenessEmitter,
-                        label: toolHeartbeatLabel(block.name, (block.input ?? {})),
-                    });
-                // Phase 2b: dispatch (may take 100ms–several seconds for write tools).
-                const dispatchStart = Date.now();
-                // D19 (2026-06-11) — expose the LLM tool_use id to the handler so the
-                // write-tool WAL (appendPending/finalizeToolCall) is keyed by the SAME
-                // id the loop records below. Dispatch is sequential, so a single slot
-                // on the shared ctx is safe.
-                params.ctx.toolUseId = block.id;
-                // Bug 8 — short-circuit for 2nd+ write-class tool in the same round.
-                const guardDecision = checkAndMark(block.name, writeGuard);
+                // Task 18 (spec D18) — a run of consecutive read_agent blocks runs as
+                // ONE concurrent group the first time the loop reaches it; each block
+                // then takes its stored result below. Every other tool keeps today's
+                // sequential dispatch.
+                if (block.name === READ_AGENT && !readerResults.has(block.id)) {
+                    await runReaderGroup(readerRunFrom(currentAssistantContent, currentAssistantContent.indexOf(block)));
+                }
+                const ranInGroup = readerResults.get(block.id);
                 let result;
-                try {
-                    result = guardDecision.allow
-                        ? await dispatchTool(block.name, block.input, params.ctx)
-                        : { content: guardDecision.errorContent, is_error: true };
+                let durationMs;
+                if (ranInGroup) {
+                    result = ranInGroup.result;
+                    durationMs = ranInGroup.durationMs;
                 }
-                finally {
-                    // D19: clear the slot so a future non-loop invocation on this ctx
-                    // can't inherit a stale block id.
-                    params.ctx.toolUseId = undefined;
-                    // Stop on the error path too — the interval is unref'd but would
-                    // otherwise keep printing "<tool> running…" into the NEXT prompt
-                    // after a dispatch throw.
-                    toolHeartbeat.stop();
-                    // Resume the turn-status row now that the user has answered (or the
-                    // interactive dispatch threw). No-op for non-interactive tools.
+                else {
+                    // Phase 1: print the dispatch line (CC-style: ⏺ name(args)).
+                    // No-op for widget-suppressed tools (ask_question) — the form/modal
+                    // is the visible representation; see tool-widget.ts.
+                    renderToolCallTop({
+                        name: block.name,
+                        args: (block.input ?? {}),
+                        chunkEmitter: toolRowEmitter,
+                    });
+                    // Phase 2a: start the peach-themed spinner. No-op outside TTY / Ink
+                    // / CI — the result line still prints, just without the in-place
+                    // animation. Spinner is purely a "still working" cue, not
+                    // load-bearing for output. Skipped entirely for widget-suppressed
+                    // tools (ask_question): with the ⏺ line gone the spinner would
+                    // orphan on its own row above the form.
+                    const spinner = isWidgetSuppressedTool(block.name)
+                        ? { stop: () => undefined }
+                        : startToolSpinner({ chunkEmitter: livenessEmitter, label: toolActivityText(block.name, (block.input ?? {})) });
+                    // 2026-06-06 (turn-liveness, B5 smoke feedback) — the in-place tool
+                    // spinner self-disables under Ink (phantom cursor #25), which left
+                    // slow tool calls (SAP over VPN: 10-60s) as DEAD AIR between the ⏺
+                    // dispatch line and the ⎿ result line. Labelled heartbeat prints
+                    // fresh "<tool> running… (10s)" lines at thresholds — visible on
+                    // every terminal, Ink included.
+                    // Interactive tools wait on the USER, not the system — ticking
+                    // "ask_question running… (30s)" while they think is noise.
+                    // CRITICAL race fix (2026-06-13) — a mutating tool that will trip the
+                    // Rule 8 batch gate (2nd+ write of the turn) ALSO blocks on the user:
+                    // presentSafetyConfirmation opens an Ink modal from inside dispatchTool
+                    // BEFORE the op runs. file_write / shell_exec are otherwise classified
+                    // non-interactive, so without this the loop would start the per-second
+                    // heartbeat + keep the turn-status row ticking UNDER the modal — the
+                    // observed live bug (doubled card, lost Enter, history-replay leak,
+                    // ~10-min wedge with the tool spinner ticking under the modal). Detect
+                    // the gate the SAME way tool-dispatch does (tool.isMutating &&
+                    // shouldGateRule8) and treat it as user-blocking: pause the status row,
+                    // skip the heartbeat. The gate's own clearActiveSpinner +
+                    // turnStatusEmitter.pause (safety-confirm.ts) is the inner belt; this
+                    // is the outer one — together no live render source contends with the
+                    // modal for the Ink frame or raw-mode stdin.
+                    const willTripBatchGate = (() => {
+                        const t = getTool(block.name);
+                        return !!t?.isMutating && shouldGateRule8();
+                    })();
+                    const isInteractiveTool = block.name === 'ask_question' ||
+                        block.name === 'request_approval' ||
+                        willTripBatchGate;
+                    // Interactive tools block on the USER. PAUSE the turn-status row (don't
+                    // just relabel it): a live 250ms tick repaints the dynamic frame and
+                    // overdraws the inquirer approval picker / churns the Ink ask_question
+                    // modal — the hidden-question + stacked-border + lost-Enter bug
+                    // (2026-06-07). resume() in the finally brings it back the moment the
+                    // user answers. Non-interactive tools keep the ticking label + heartbeat.
                     if (isInteractiveTool)
-                        turnStatusEmitter.resume();
+                        status.pause();
+                    else
+                        status.activity(toolActivityText(block.name, (block.input ?? {})));
+                    const toolHeartbeat = isInteractiveTool
+                        ? { stop: () => undefined }
+                        : startThinkingHeartbeat({
+                            chunkEmitter: livenessEmitter,
+                            label: toolHeartbeatLabel(block.name, (block.input ?? {})),
+                        });
+                    // Phase 2b: dispatch (may take 100ms–several seconds for write tools).
+                    const dispatchStart = Date.now();
+                    // D19 (2026-06-11) — expose the LLM tool_use id to the handler so the
+                    // write-tool WAL (appendPending/finalizeToolCall) is keyed by the SAME
+                    // id the loop records below. Dispatch is sequential, so a single slot
+                    // on the shared ctx is safe.
+                    params.ctx.toolUseId = block.id;
+                    // Bug 8 — short-circuit for 2nd+ write-class tool in the same round.
+                    const guardDecision = checkAndMark(block.name, writeGuard);
+                    // Task 15 — keep the prompt cache warm while the tool (or the user
+                    // answering its prompt) takes time; disarmed in the finally.
+                    if (guardDecision.allow)
+                        armKeepalive();
+                    try {
+                        result = guardDecision.allow
+                            ? await dispatchTool(block.name, block.input, params.ctx)
+                            : { content: guardDecision.errorContent, is_error: true };
+                    }
+                    finally {
+                        keepalive.disarm();
+                        // D19: clear the slot so a future non-loop invocation on this ctx
+                        // can't inherit a stale block id.
+                        params.ctx.toolUseId = undefined;
+                        // Stop on the error path too — the interval is unref'd but would
+                        // otherwise keep printing "<tool> running…" into the NEXT prompt
+                        // after a dispatch throw.
+                        toolHeartbeat.stop();
+                        // Resume the turn-status row now that the user has answered (or the
+                        // interactive dispatch threw). No-op for non-interactive tools.
+                        if (isInteractiveTool)
+                            status.resume();
+                    }
+                    durationMs = Date.now() - dispatchStart;
+                    // Phase 2c: stop the spinner, which erases its line so the result
+                    // row paints in place of it (no scrollback artifacts).
+                    spinner.stop();
                 }
-                const durationMs = Date.now() - dispatchStart;
-                // Phase 2c: stop the spinner, which erases its line so the result
-                // row paints in place of it (no scrollback artifacts).
-                spinner.stop();
                 // Phase 3: print result line (  ⎿ ✓ summary · timing).
                 // 2026-05-15 (bug 1): the old `slice(0, 80)` clipped to the JSON
                 // preamble (e.g. `{"error":"write_failed","detail":"HTTP 409: <?xml v…`)
@@ -1367,6 +1870,11 @@ ${imageExpansion.error}`));
             }
         }
         session.messages.push({ role: 'user', content: toolResults });
+        // Task 16 — a successful dispatch_skill in this round moves the session
+        // to another skill: surface that skill's starters now, right after the
+        // tool-result user message (append-only; tools[] is unchanged).
+        for (const skill of dispatchedSkills(currentAssistantContent, toolResults))
+            surfaceStarters(skill);
         await saveSession(session);
         // v0.6 Layer 3 — between-rounds watchdog check. If the turn has been
         // running too long (wall-clock or token budget), inject a synthetic
@@ -1390,3 +1898,22 @@ ${imageExpansion.error}`));
         // Loop continues → next messages.create with the tool results.
     }
 }
+/**
+ * Task 16 — skills a successful `dispatch_skill` call in this round queued
+ * (`/abap-fiori-build --from @x` ⇒ `abap-fiori-build`, aliases resolved).
+ */
+function dispatchedSkills(assistantContent, toolResults) {
+    const out = [];
+    for (const b of assistantContent) {
+        if (b?.type !== 'tool_use' || b.name !== 'dispatch_skill')
+            continue;
+        const r = toolResults.find((t) => t?.tool_use_id === b.id);
+        if (!r || r.is_error)
+            continue;
+        const command = typeof b.input?.command === 'string' ? b.input.command.trim() : '';
+        const head = command.startsWith('/') ? command.slice(1).split(/\s+/)[0] : '';
+        if (head)
+            out.push(resolveSkillAlias(head));
+    }
+    return out;
+}