@cspeach/cli 1.1.51 → 1.1.53

package/dist/agent/loop.js

@@ -9,7 +9,7 @@ import { loadConfig } from '../config/loader.js';
 import { resolveModelRole, resolveEffort, modelAcceptsEffort, resolveAutoCompactThreshold, callModelFor } from '../models/resolve.js';
 import { getCustomerModelConfig, managedProxyServesNewShapes, servedToolLoading } from '../models/server-config.js';
 import { familyOf, familyAcceptsEffort } from '../models/model-identity.js';
-import { buildToolList, buildSkillToolAddition, placeSystemMessagesInPlace, resolveToolLoading, } from '../tools/tool-loading.js';
+import { buildToolList, buildSkillToolAddition, buildToolAdditionMessage, deferredNames, surfacedToolNames, 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';
@@ -33,7 +33,9 @@ import { turnStatusEmitter } from '../ui/turn-status-emitter.js';
 import { buildRetryCapPausePayload, buildSkippedSiblingResults } from './retry-cap.js';
 import { reportCallUsage } from '../usage/usage-reporter.js';
 import { appendCostLine, buildEntry as buildCostEntry, perCallTokens, summariseInputTransformations } from '../cost/cost-log.js';
-import { noteSystemBlock, systemBlockKey } from '../cost/system-block.js';
+import { INLINE_SYSTEM_BLOCK_SKILL, noteSystemBlock, systemBlockKey } from '../cost/system-block.js';
+import { escapeInjectedTags, historyHoldsInline, neutraliseForgedSkillTags, planInlineTurn, playbookLineSystem, playbookLineSystemChat, } from './inline-skill-block.js';
+import { SKILL_INLINE_HEADER } from './system-prompt.js';
 import { sessionMaxTokens, clampMaxTokens, sendsBlockBinding } from './provider-shape.js';
 import { profileOf, sendsEffortFor } from './connection-profile.js';
 import { computeSessionCost } from '../cost/session-cost.js';
@@ -44,6 +46,7 @@ import { enrichUserMessage } from '../router/intent-extractor.js';
 import { resetRule8State, shouldGateRule8 } from '../repl/rule8-detector.js';
 import { consumeTodoSetThisTurn } from '../ui/todo-emitter.js';
 import { runSaveCommand, runPromoteCommand, detectArtifactSkill, offerAnswerBlockers } from '../projects/index.js';
+import { blockerAnswersNote, SPEC_ANSWERS_RECORD_TOOL } from '../projects/blocker-answers-note.js';
 import { planLaneBlockForTurn } from '../projects/plan-lane.js';
 import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from '../projects/document-skills.js';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
@@ -68,8 +71,9 @@ 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, stripPreFallbackBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError, stripUnsignedThinking, isThinkingOnly, dropTrailingThinkingOnly } from './repair-partial.js';
-import { drainSteering, enqueueSteering } from './steering-queue.js';
+import { repairPartialBlocks, stripPreFallbackBlocks, healSessionMessagesInPlace, healOrphanToolUses, isPartialJsonApiError, stripUnsignedThinking, isThinkingOnly, dropTrailingThinkingOnly, closedOffStepsLine } from './repair-partial.js';
+import { drainSteeringEntries, enqueueSteering } from './steering-queue.js';
+import { steeringReadLine } from '../renderer/steering-echo.js';
 import { TurnStreamWriter } from './turn-stream.js';
 import { applyToolResultCheckpoint } from './skill-checkpoint.js';
 import { loadWatchdogConfig, evaluateWatchdog } from './turn-watchdog.js';
@@ -84,6 +88,7 @@ import { CacheKeepalive, snapshotParams, recordLastRequest, isCacheablePrompt, n
 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';
+import { settleHandOffNote } from '../tools/hand-off.js';
 import { openStatusPage } from '../util/open-in-browser.js';
 import { isChatSkill } from './chat-prompt.js';
 import { getAssistantStyle } from './style-state.js';
@@ -135,6 +140,12 @@ const SAVE_HOOK_SKILLS = new Set([
     // revision path in commands/plan-resume.ts persists instead.
     'abap-plan',
 ]);
+/** Stage 1A — the inline branch's debug channel (CSPEACH_DEBUG=1 → stderr). Never user output. */
+function inlineDebug(line) {
+    if (process.env['CSPEACH_DEBUG'] !== '1')
+        return;
+    process.stderr.write(`[inline] ${line}\n`);
+}
 /**
  * True when any user message in the session already carries the rendered
  * <project_context> block. Phase 2 uses this to inject the block exactly
@@ -438,9 +449,51 @@ async function offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm) {
         p.emit(formatInfo(`Word copy not written: ${e.message}`).trimEnd());
     }
 }
+/**
+ * Change options (2026-10-23) — an answer carrying the change-options marker
+ * pair gets its marked part saved (every complete pair, in order: a level
+ * picked in session adds the decided document), whatever the skill and even when the turn
+ * ends on the level question. Never on a sub-agent turn or inside a guided
+ * flow. Returns true when the marker check handled the turn (the question was
+ * asked or the document saved), so maybeOfferSave runs nothing else. An answer
+ * with no complete marker pair returns false and takes today's path unchanged.
+ */
+async function maybeOfferChangeOptions(p, confirm) {
+    if (p.subagent || p.guided || p.assistantText.includes('<!-- guided-run:'))
+        return false;
+    if (!p.assistantText.includes('csforge:change-options'))
+        return false;
+    const { extractChangeOptions } = await import('../projects/change-options.js');
+    // Every complete pair, in order: a level picked in session shows the
+    // document again with the decision, and that one is saved too (last).
+    const docs = extractChangeOptions(p.assistantText).filter((d) => d.markdown.trim().length > 0);
+    if (docs.length === 0)
+        return false;
+    // Set before the save question, so a declined save still routes the level reply.
+    if (p.session && !p.subagent)
+        p.session.lastChangeOptions = { object: docs[docs.length - 1].object, skill: p.skill };
+    try {
+        const { offerChangeOptionsSave } = await import('../projects/document-save.js');
+        const { loadConfig, resolveWordCopy } = await import('../config/loader.js');
+        await offerChangeOptionsSave({
+            docs: docs.map((d) => ({ object: d.object, markdown: d.markdown })), cwd: process.cwd(), today: localToday(),
+            sapSystem: p.sapSystem ?? null,
+            ...(p.sessionId ? { sessionId: p.sessionId } : {}),
+            ...(p.operator ? { operator: p.operator } : {}),
+            headless: isHeadless(), wordCopy: resolveWordCopy(await loadConfig()), confirm, emit: p.emit,
+        });
+    }
+    catch (e) {
+        p.emit(formatInfo(`Not saved. ${e.message}`).trimEnd());
+    }
+    return true;
+}
 export async function maybeOfferSave(p) {
     if (p.assistantText.trim().length === 0)
         return;
+    // Change options (2026-10-23): the marker check runs first, for every skill.
+    if (await maybeOfferChangeOptions(p, p.confirm ?? inkAwareConfirm))
+        return;
     // Word export (2026-10-19): reviews and handovers are prose documents, not
     // envelopes. They get a Markdown save under cspeach-out and the Word
     // question (projects/document-save.ts). Nothing below this branch changes
@@ -567,7 +620,12 @@ export async function maybeOfferSave(p) {
         // business questions stay open for a consultant to answer in the viewer.
         // Uses inkAwarePrompt directly (NOT the save hook's blanket-'y' headless
         // prompt): in headless it returns '' → declined, so nothing is written.
+        // Task 16 (F-M): what the form recorded reaches the model as one note on
+        // its next call (session.blockerAnswersNote, sent by runTurn). Main turns
+        // with a session only; declined / not offered / not saved → no note.
         if (savedPath && saveSkill === 'abap-spec-gap') {
+            const noteSession = p.session && !p.subagent ? p.session : undefined;
+            let outcomes;
             await offerAnswerBlockers({
                 path: savedPath,
                 identity: getAuthorIdentity(),
@@ -575,7 +633,14 @@ export async function maybeOfferSave(p) {
                 confirm: inkAwareConfirm,
                 choose: inkAwareChoose,
                 log: (...lines) => lines.forEach((l) => p.emit(l)),
+                ...(noteSession ? { onOutcomes: (o) => { outcomes = o; } } : {}),
             });
+            if (noteSession && outcomes) {
+                // The path is shown against the read tool's base (ctx.cwd), so the model opens it with file_read.
+                const note = blockerAnswersNote({ path: savedPath, cwd: p.readCwd ?? process.cwd(), outcomes });
+                if (note)
+                    noteSession.blockerAnswersNote = note;
+            }
         }
         // App lane routing (Task 7) — the harness-owned /abap-app chain. Built
         // from the exact saved path, never from model text. Outside an app flow
@@ -614,6 +679,7 @@ const SILENT_STATUS = {
     activity: (_label) => undefined,
     pause: () => undefined,
     resume: () => undefined,
+    pausedMs: () => 0,
 };
 /** Task 18 — at most this many read_agent calls run at the same time. */
 export const MAX_PARALLEL_READERS = 4;
@@ -946,6 +1012,15 @@ ${imageExpansion.error}`));
     if (!readerChild) {
         userMessageForLLM = await expandTextFileAttachments(userMessageForLLM, params.ctx.cwd, (line) => emit(chalk.dim(line)));
     }
+    // Stage 1A, Task 1A.2 (S5) — an interactive chat-lane process neutralises
+    // <skill, <playbook and <session_context in what the person sends (typed
+    // text and @file expansions), so no text of theirs can open a block the
+    // CLI writes. A caller-enriched message keeps its leading <session_context>.
+    // Absent flag (skills lane, piped, one-shot, children) ⇒ the text as it is.
+    if (params.ctx.chatLaneProcess === true && !readerChild && !params.ctx.subagent) {
+        const lead = userMessageForLLM.startsWith('<session_context>') ? '<session_context>' : '';
+        userMessageForLLM = lead + escapeInjectedTags(userMessageForLLM.slice(lead.length));
+    }
     // App lane routing (Task 6) — the /abap-plan creation turn inside an app
     // flow gets the confirmed <lane_decision> block (read with the app-flow sha;
     // a changed file is refused with a plain line). '' on every other turn, so
@@ -1012,7 +1087,48 @@ ${imageExpansion.error}`));
     const switchNote = session.systemSwitchNote
         ? `<system_switch>${session.systemSwitchNote}</system_switch>`
         : '';
-    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote]);
+    // Stage 1A, Task 1A.2 — inline skills (only when the REPL decided so for
+    // this turn; never a reader or agent_run child). The playbook rides in the
+    // conversation as a <skill> block, once per body per history ("loaded" is
+    // read from the history by content hash, inline-skill-block.ts), and a
+    // code-driven <playbook> line says which block is in charge. The main
+    // playbook failing to load ⇒ this turn runs in system mode (S2). A
+    // system-mode turn whose history holds inline blocks gets the
+    // source="system" line (S-B); in a process that never ran inline the scan
+    // finds nothing and nothing changes.
+    const mainTurn = !readerChild && !params.ctx.subagent;
+    let inlineTurn = false;
+    let playbookLine = '';
+    let inlineBlocks = [];
+    if (mainTurn && params.ctx.inlineSkills === true) {
+        const neutralised = neutraliseForgedSkillTags(session.messages);
+        if (neutralised > 0)
+            inlineDebug(`neutralised a <skill> tag that is not a loaded playbook in ${neutralised} earlier message(s)`);
+        const plan = await planInlineTurn({
+            skill: params.skill,
+            delegateSkill: params.delegateSkill,
+            messages: session.messages,
+            source: params.ctx.skillSource ?? params.provider.skillSource,
+            debug: inlineDebug,
+        });
+        if (plan.inline) {
+            inlineTurn = true;
+            playbookLine = plan.line;
+            inlineBlocks = plan.blocks;
+        }
+        else {
+            inlineDebug(`playbook ${params.skill} could not be loaded, this turn runs in system mode: ${plan.reason}`);
+        }
+    }
+    if (mainTurn && !inlineTurn && historyHoldsInline(session.messages)) {
+        playbookLine = isChatSkill(params.skill) ? playbookLineSystemChat() : playbookLineSystem(params.skill);
+    }
+    // Task 16 (F-M) — what the blocker form recorded after the last turn: once,
+    // on the next main turn (never a sub-agent or reader child), then dropped.
+    const blockerNote = mainTurn && session.blockerAnswersNote
+        ? `<blocker_answers>\n${session.blockerAnswersNote}\n</blocker_answers>`
+        : '';
+    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote, blockerNote, playbookLine]);
     // Deterministically extract structured facts from the user's prompt
     // (package, transport, object names, environment hint, create intent)
     // and prepend them as an XML `<session_context>` block. The model reads
@@ -1027,10 +1143,13 @@ ${imageExpansion.error}`));
     // when extraction yields nothing (enrichUserMessage returns original).
     // Final batch 1 — a caller-enriched message still gets the switch note,
     // inside its own <session_context> block.
+    // Stage 1A — the <playbook> line rides the same way ('' ⇒ unchanged).
+    const callerNotes = composeSessionContextBlock([switchNote, blockerNote, playbookLine]);
     const enriched = userMessageForLLM.startsWith('<session_context>')
-        ? (switchNote ? userMessageForLLM.replace('<session_context>', `<session_context>\n  ${switchNote}`) : userMessageForLLM)
+        ? (callerNotes ? userMessageForLLM.replace('<session_context>', `<session_context>\n  ${callerNotes}`) : userMessageForLLM)
         : enrichUserMessage(userMessageForLLM, sessionContextBlock);
     const switchNoteUsed = switchNote !== '' && enriched.includes(switchNote);
+    const blockerNoteUsed = blockerNote !== '' && enriched.includes(blockerNote);
     // Phase 2 of Track B — opt-in project-context enrichment, gated by
     // CSPEACH_PROJECT_CONTEXT=on. Default OFF: production behavior is
     // identical to today. When on, the rendered <project_context> block
@@ -1058,11 +1177,17 @@ ${imageExpansion.error}`));
         projectContextBlock = await maybeBuildProjectContext({
             cwd: params.ctx.cwd,
             sapConnection,
+            emit: (line) => emit(chalk.dim(line)),
         });
     }
-    const finalUserContent = projectContextBlock
+    const contextualContent = projectContextBlock
         ? `${projectContextBlock}\n\n${enriched}`
         : enriched;
+    // Stage 1A — the bodies the history lacks end the user message, each as
+    // `\n\n<skill …>\n<body>\n</skill>` (none on most turns ⇒ unchanged).
+    const finalUserContent = inlineBlocks.length > 0
+        ? `${contextualContent}${inlineBlocks.map((b) => `\n\n${b.text}`).join('')}`
+        : contextualContent;
     // Chat lane (D11) — what a withdrawn `_chat` turn restores: the whole
     // pre-turn message array (placeSystemMessagesInPlace may re-sort the tail
     // after the last assistant message, so a length-based splice is not
@@ -1074,6 +1199,9 @@ ${imageExpansion.error}`));
         lane: session.lane,
         tool_set_skill: session.tool_set_skill,
         turn_seq: session.turn_seq,
+        // Task 16 fix round 1 (I-1, R17): the one-time notes this turn consumes.
+        systemSwitchNote: session.systemSwitchNote,
+        blockerAnswersNote: session.blockerAnswersNote,
     };
     let round0Steers = [];
     // Images (if any) ride as blocks ahead of the text; with none this is the
@@ -1089,6 +1217,8 @@ ${imageExpansion.error}`));
     // it is in a pushed user message.
     if (switchNoteUsed)
         delete session.systemSwitchNote;
+    if (blockerNoteUsed)
+        delete session.blockerAnswersNote;
     if (imageExpansion.images.length > 0 && params.provider.name === 'local-openai-compat') {
         // The local (OpenAI-compatible) provider keeps text blocks only.
         emit(chalk.dim('(local model: the image is not sent — the model gets the text only)'));
@@ -1133,9 +1263,14 @@ ${imageExpansion.error}`));
     const contextTools = withoutTools(toolsForContext(listTools(), params.ctx), hiddenSapTools);
     // 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)))
+    const readerVisible = params.ctx.subagent || !hasReaderReadTools(new Set(contextTools.map((t) => t.name)))
         ? contextTools.filter((t) => t.name !== READ_AGENT)
         : contextTools;
+    // Task 18 fix round 1 (item 5) — an agent_run child never records spec
+    // answers: it could race the blocker form on the same file.
+    const visibleTools = params.ctx.subagent
+        ? readerVisible.filter((t) => t.name !== SPEC_ANSWERS_RECORD_TOOL)
+        : readerVisible;
     // 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 ⇒
@@ -1184,20 +1319,41 @@ ${imageExpansion.error}`));
      * N1 (c) — built from the turn's list (the list every request of this turn
      * carries) and never for a session pinned static.
      */
+    // Stage 1A (rev 6 M-5) — on an inline turn, what each tool_addition
+    // surfaced and the size of its definition in this turn's list, for the
+    // cost line of the call that carries it. Never filled in system mode.
+    let pendingSurfaced = [];
+    // Stage 1A — skill_appended goes on the turn's first cost line (a call
+    // retried after a prompt-too-long recovery logs no line of its own).
+    let skillAppendedLogged = false;
+    const pushToolAddition = (msg) => {
+        if (msg)
+            session.messages.push(msg);
+        if (msg && inlineTurn) {
+            for (const b of msg.content) {
+                const def = turnTools.find((t) => t?.name === b.tool.name);
+                pendingSurfaced.push({ name: b.tool.name, chars: JSON.stringify(def ?? null).length });
+            }
+        }
+    };
     const surfaceStarters = (skill) => {
-        const msg = buildSkillToolAddition({
+        pushToolAddition(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);
+    // Task 18 fix round 1 (item 7) — the blocker note names spec_answers_record:
+    // on the turn that carries it, surface the tool when this list defers it
+    // (loaded already, static, or surfaced before: nothing is added).
+    if (blockerNoteUsed && session.tool_loading !== 'static' && !surfacedToolNames(session.messages).has(SPEC_ANSWERS_RECORD_TOOL)) {
+        pushToolAddition(buildToolAdditionMessage([SPEC_ANSWERS_RECORD_TOOL], deferredNames(turnTools)));
+    }
     /**
      * key: `${tool_name}:${object}` — consecutive failures per (tool, target).
      * For object-identifying tools (sap_set_source / sap_activate / etc.) the
@@ -1254,7 +1410,34 @@ ${imageExpansion.error}`));
     // rounds so it doesn't spam the model. See agent/turn-watchdog.ts.
     const watchdogConfig = loadWatchdogConfig();
     const turnStartedAt = Date.now();
+    // Card-wait time already paused on the status emitter before this turn; the
+    // watchdog counts only what this turn adds on top of it as "not working".
+    const turnPausedBase = status.pausedMs();
     let watchdogWarned = false;
+    // LT-3 (live re-check 2026-10-26) — set after a successful hand_off in a
+    // turn that already said its line. The next round's text is HELD: shown at
+    // once if the round calls a tool, shown at the end unless the round is only
+    // a short closing line that ends the turn (the second announcement). Kept
+    // in the session either way.
+    let muteHandOffEcho = false;
+    let heldEcho = null;
+    const showText = (out) => {
+        if (heldEcho) {
+            heldEcho.push(out);
+            return;
+        }
+        if (params.chunkEmitter)
+            params.chunkEmitter.emit('chunk', out);
+        else
+            writeStdout(out);
+    };
+    const releaseHeldEcho = () => {
+        const held = heldEcho;
+        heldEcho = null;
+        if (held)
+            for (const out of held)
+                showText(out);
+    };
     // 2026-06-08 — manifest-on-interrupt: track the last plan-manifest block we
     // already handed to onPlanManifest, so we fire once per DISTINCT manifest
     // (a continue-in-session run emits one per phase) and not once per round.
@@ -1288,15 +1471,28 @@ ${imageExpansion.error}`));
         // during round N lands at the start of round N+1 (between rounds). The
         // Anthropic API concatenates consecutive user messages, so injecting after a
         // tool_result user message is valid.
+        // LT-15 F1 — only the main turn reads the queue: a reader or an agent_run
+        // child (ctx.subagent) never takes the parent's messages.
+        // LT-15 F2 — no drain when the turn is already stopped: this round can
+        // never run, so the message stays queued for a later turn.
         {
-            const steers = readerChild ? [] : drainSteering();
-            if (steers.length > 0) {
-                const text = steers.join('\n');
+            const entries = mainTurn && !params.signal?.aborted ? drainSteeringEntries() : [];
+            if (entries.length > 0) {
+                const steers = entries.map((e) => e.text);
+                // Stage 1A fix round 1 (I-1) — a steer is typed text: in an
+                // interactive chat-lane process it gets the same tag escape.
+                const joined = steers.join('\n');
+                const text = params.ctx.chatLaneProcess === true ? escapeInjectedTags(joined) : joined;
                 session.messages.push({ role: 'user', content: text });
                 markCliMessage(session, text, 'steer', '');
                 if (roundIndex === 0)
                     round0Steers = steers;
-                emit(chalk.cyan(`↳ steering: ${steers.join(' / ')}`));
+                // LT-15 Feature 1 (D5, F7) — one dim, clipped, sanitised line per message.
+                // LT-15 Task 4 — not again for a message the D11 fallback put back
+                // after its line was already shown.
+                for (const e of entries)
+                    if (!e.alreadyRead)
+                        emit(steeringReadLine(e.text));
             }
         }
         let buffer = initialBufferState();
@@ -1330,12 +1526,21 @@ ${imageExpansion.error}`));
             session.lane = preTurnState.lane;
             session.tool_set_skill = preTurnState.tool_set_skill;
             session.turn_seq = preTurnState.turn_seq;
+            // The re-run turn still gets the one-time notes (they were dropped on push).
+            if (preTurnState.systemSwitchNote !== undefined)
+                session.systemSwitchNote = preTurnState.systemSwitchNote;
+            if (preTurnState.blockerAnswersNote !== undefined)
+                session.blockerAnswersNote = preTurnState.blockerAnswersNote;
             // Steering drained in round 0 goes back to the queue, ahead of any
             // typed since, so the re-run turn still sees it.
+            // LT-15 Task 4 — the round-0 ones were shown as "↳ read": marked, so the
+            // re-run prints no second line; the later ones keep their own mark.
             if (round0Steers.length > 0) {
-                const later = drainSteering();
-                for (const t of [...round0Steers, ...later])
-                    enqueueSteering(t);
+                const later = drainSteeringEntries();
+                for (const t of round0Steers)
+                    enqueueSteering(t, { alreadyRead: true });
+                for (const e of later)
+                    enqueueSteering(e.text, { alreadyRead: e.alreadyRead });
             }
             throw new ChatUnavailableError(st);
         };
@@ -1371,6 +1576,9 @@ ${imageExpansion.error}`));
         // Task 15 — the request actually sent by the attempt that succeeded.
         let sentParams;
         let sentHeaders;
+        // Stage 1A — the tool_additions this call carries (inline turns only).
+        const callSurfaced = pendingSurfaced;
+        pendingSurfaced = [];
         try {
             stream = await retryWithBackoff(() => (async () => {
                 // W2.5 — apply optional tool filter (used by agent_run with
@@ -1428,7 +1636,7 @@ ${imageExpansion.error}`));
                 // 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)`));
+                    emit(chalk.dim(closedOffStepsLine(healedOrphans)));
                 }
                 // Task 4 — effort only from an explicit act (ruling F2); never to a
                 // model that rejects it (probe P1: claude-haiku-4-5* ⇒ 400).
@@ -1494,6 +1702,9 @@ ${imageExpansion.error}`));
                     ...styleHeader(getAssistantStyle()),
                     // §10 D14 — developer sends nothing (byte-identical requests).
                     ...levelHeader(getAssistantLevel()),
+                    // Stage 1A — an inline turn asks for the one constant system
+                    // block; every other call sends nothing (byte-identical requests).
+                    ...(inlineTurn ? { [SKILL_INLINE_HEADER]: '1' } : {}),
                 };
                 sentParams = streamParams;
                 sentHeaders = headers;
@@ -1547,8 +1758,11 @@ ${imageExpansion.error}`));
             // largest tool results, save, and run the same request once more (or
             // show the card). The main turn only.
             if (!readerChild && !params.ctx.subagent && isPromptTooLongError(err)) {
-                if (await recoverFromPromptTooLong(err))
+                if (await recoverFromPromptTooLong(err)) {
+                    // Stage 1A — the retried call carries the same tool_additions.
+                    pendingSurfaced = [...callSurfaced, ...pendingSurfaced];
                     continue;
+                }
                 return;
             }
             // Proxy returns 409 upgrade_required when CLI is older than skill's min_cli_version.
@@ -1584,6 +1798,10 @@ ${imageExpansion.error}`));
         // not in here was cut mid-stream and must never be persisted.
         const completedBlocks = new WeakSet();
         let sawEndTurn = false;
+        if (muteHandOffEcho) {
+            heldEcho = [];
+            muteHandOffEcho = false;
+        } // LT-3 — hold this round's text
         let sawToolUse = false;
         let sawMaxTokens = false;
         let sawPauseTurn = false;
@@ -1642,13 +1860,10 @@ ${imageExpansion.error}`));
                     writingCode = false;
                     const block = event.content_block;
                     currentAssistantContent.push(block);
-                    if (block.type === 'text') {
-                        const sep = chalk.gray('\n');
-                        if (params.chunkEmitter)
-                            params.chunkEmitter.emit('chunk', sep);
-                        else
-                            writeStdout(sep);
-                    }
+                    if (block.type === 'tool_use')
+                        releaseHeldEcho(); // LT-3 — the round does more than restate
+                    if (block.type === 'text')
+                        showText(chalk.gray('\n'));
                 }
                 else if (type === 'content_block_delta') {
                     const delta = event.delta;
@@ -1664,12 +1879,8 @@ ${imageExpansion.error}`));
                         writingCode = wa.writingCode;
                         if (wa.label)
                             status.activity(wa.label);
-                        if (output) {
-                            if (params.chunkEmitter)
-                                params.chunkEmitter.emit('chunk', output);
-                            else
-                                writeStdout(output);
-                        }
+                        if (output)
+                            showText(output);
                         if (last?.type === 'text')
                             last.text = (last.text ?? '') + delta.text;
                         // v0.6 — also write the raw model text to disk so the user can
@@ -1807,8 +2018,11 @@ ${imageExpansion.error}`));
             // retry: the catch only decides; the card and the final save (with
             // turnInterrupted cleared) come from the recovery after the persist block.
             if (!readerChild && !params.ctx.subagent && !params.signal?.aborted && currentAssistantContent.length === 0 && isPromptTooLongError(err)) {
-                if (await recoverFromPromptTooLong(err, { card: false }))
+                if (await recoverFromPromptTooLong(err, { card: false })) {
+                    // Stage 1A — the retried call carries the same tool_additions.
+                    pendingSurfaced = [...callSurfaced, ...pendingSurfaced];
                     continue;
+                }
             }
         }
         // Final flush: emit any pending partial line after the stream ends.
@@ -1820,22 +2034,23 @@ ${imageExpansion.error}`));
         if (heldProse) {
             const { output, state } = renderChunk(heldProse, buffer);
             buffer = state;
-            if (output) {
-                if (params.chunkEmitter)
-                    params.chunkEmitter.emit('chunk', output);
-                else
-                    writeStdout(output);
-            }
+            if (output)
+                showText(output);
         }
         if (buffer.pending.length > 0) {
-            const flushed = render(buffer.pending);
-            if (params.chunkEmitter)
-                params.chunkEmitter.emit('chunk', flushed);
-            else
-                writeStdout(flushed);
+            showText(render(buffer.pending));
             buffer = initialBufferState();
             writingCode = false;
         }
+        if (heldEcho) {
+            // LT-3 — drop only a short text-only reply that ends the turn.
+            const said = currentAssistantContent.filter((b) => b?.type === 'text').map((b) => String(b.text ?? '')).join('').trim();
+            const restatement = sawEndTurn && !currentAssistantContent.some((b) => b?.type === 'tool_use') && said.length <= HAND_OFF_ECHO_MAX;
+            if (restatement)
+                heldEcho = null;
+            else
+                releaseHeldEcho();
+        }
         // Repair partial blocks before persistence. ALWAYS run, not just on
         // interruption: on a clean tool-use round the model's tool_use blocks can
         // still carry a leftover `partial_json` field, and persisting that poisons
@@ -1960,10 +2175,13 @@ ${imageExpansion.error}`));
             // this call sent and whether its system block matched the session's
             // previous main call (same four inputs as the headers above).
             const mainLine = !readerChild;
+            // Stage 1A (M2) — an inline call's system block is the one constant
+            // block whatever the skill or delegate: the key says so, so a switch is
+            // 'same' and a 'changed' line in an inline session is a real change.
             const systemBlock = mainLine
                 ? noteSystemBlock(session, systemBlockKey({
-                    skill: params.skill,
-                    delegateSkill: params.delegateSkill,
+                    skill: inlineTurn ? INLINE_SYSTEM_BLOCK_SKILL : params.skill,
+                    delegateSkill: inlineTurn ? undefined : params.delegateSkill,
                     style: getAssistantStyle(),
                     level: getAssistantLevel(),
                 }))
@@ -1996,7 +2214,15 @@ ${imageExpansion.error}`));
                 reader: params.ctx.readerSpend,
                 skill: mainLine ? params.skill : undefined,
                 system_block: systemBlock,
+                // Stage 1A (S8, S-C, M-5) — inline lines only; absent otherwise.
+                system_mode: mainLine && inlineTurn ? 'inline' : undefined,
+                skill_appended: mainLine && inlineTurn && !skillAppendedLogged
+                    ? inlineBlocks.map((b) => ({ name: b.name, sha256: b.sha256, chars: b.text.length }))
+                    : undefined,
+                tools_surfaced: mainLine && inlineTurn ? callSurfaced : undefined,
             });
+            if (mainLine)
+                skillAppendedLogged = true;
             readerCallsLogged = params.ctx.readerSpend?.calls ?? 0;
             void appendCostLine(session.id, entry);
             // Security batch item 3 — usage counts for byok / ai-hub / local (the
@@ -2084,6 +2310,7 @@ ${imageExpansion.error}`));
                 const outputTokensThisTurn = Math.max(0, (session.usage?.output_tokens ?? 0) - turnStartOutputTokens);
                 const decision = evaluateWatchdog({
                     startedAt: turnStartedAt,
+                    pausedMs: status.pausedMs() - turnPausedBase,
                     outputTokensThisTurn,
                     config: watchdogConfig,
                     alreadyWarned: false,
@@ -2139,10 +2366,13 @@ ${imageExpansion.error}`));
                         model: params.modelOverride ?? resolveModelRole('session_default', cfg) ?? session.model ?? 'unknown',
                         emit,
                         sapSystem: session.sap_system,
+                        ...(params.operator ? { operator: params.operator } : {}),
+                        sessionId: session.id,
                         ...(params.ctx.subagent ? { subagent: true } : {}),
                         ...(session.awaitingSkillAnswer === true ? { awaitingAnswer: true } : {}),
                         ...(getJourneyFlow(session) || getAppFlow(session) ? { guided: true } : {}),
                         session,
+                        readCwd: params.ctx.cwd,
                         promotedFrom: promotedFromForSave,
                         ...(promotedFromPathForSave ? { promotedFromPath: promotedFromPathForSave } : {}),
                         ...(() => {
@@ -2617,10 +2847,17 @@ ${imageExpansion.error}`));
                 // immediately below handles both success and the not-yet-capped failure case.
                 // 2026-10-22 — the general guard: a result over TOOL_RESULT_MAX_CHARS
                 // is cut with a note; a result under it is the same value (byte-identical).
+                // LT-3 (live check 2026-10-26) — text already went out in this turn:
+                // the hand_off result tells the model plainly to add nothing more.
+                const saidBefore = block.name === 'hand_off' && !result.is_error
+                    && textBeforeInTurn(session.messages.slice(turnStartMessageCount), currentAssistantContent, block);
+                const resultContent = saidBefore ? settleHandOffNote(result.content, true) : result.content;
+                if (saidBefore && resultContent !== result.content)
+                    muteHandOffEcho = true;
                 toolResults.push({
                     type: 'tool_result',
                     tool_use_id: block.id,
-                    content: capToolResultContent(result.content),
+                    content: capToolResultContent(resultContent),
                     is_error: result.is_error,
                 });
             }
@@ -2640,6 +2877,7 @@ ${imageExpansion.error}`));
             const outputTokensThisTurn = Math.max(0, (session.usage?.output_tokens ?? 0) - turnStartOutputTokens);
             const decision = evaluateWatchdog({
                 startedAt: turnStartedAt,
+                pausedMs: status.pausedMs() - turnPausedBase,
                 outputTokensThisTurn,
                 config: watchdogConfig,
                 alreadyWarned: watchdogWarned,
@@ -2674,3 +2912,20 @@ function dispatchedSkills(assistantContent, toolResults) {
     }
     return out;
 }
+/**
+ * LT-3 — did the model already write text in this turn before `block`? Earlier
+ * rounds' assistant messages, then this round's blocks ahead of the call.
+ */
+function textBeforeInTurn(turnMessages, roundContent, block) {
+    const said = (b) => b?.type === 'text' && typeof b.text === 'string' && b.text.trim() !== '';
+    for (const m of turnMessages) {
+        if (m?.role !== 'assistant' || m.content === roundContent || !Array.isArray(m.content))
+            continue;
+        if (m.content.some(said))
+            return true;
+    }
+    const at = roundContent.indexOf(block);
+    return roundContent.slice(0, at < 0 ? roundContent.length : at).some(said);
+}
+/** LT-3 — the longest text-only closing reply after a hand-off that is treated as a second announcement. */
+const HAND_OFF_ECHO_MAX = 320;