@cspeach/cli 1.1.50 → 1.1.52

package/dist/agent/loop.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';
@@ -45,7 +47,9 @@ 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 { planLaneBlockForTurn } from '../projects/plan-lane.js';
-import { DOCUMENT_SKILLS } from '../projects/document-skills.js';
+import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from '../projects/document-skills.js';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { bindCliCardSession, documentOffersFor, markCliMessage, CONTINUE_LINE, WATCHDOG_LINE } from '../session/cli-record.js';
 import { clearAppFlow, getAppFlow, setGapConfirmed, startAppFlow } from '../lane/app-flow.js';
 import { getLatestSkeletonDecision } from '../rap/skeleton-session.js';
 import { afterRebuildTurn } from '../journey/rebuild.js';
@@ -67,7 +71,8 @@ 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 { 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';
@@ -82,6 +87,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';
@@ -133,6 +139,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
@@ -373,6 +385,69 @@ export async function inkAwareChoose(a) {
     emitTrace(formatAnswerTrace(header, shown, uiWidth()));
     return { kind: 'picked', answer };
 }
+/**
+ * Word copy everywhere (2026-10-23) — a newer document skill offers the save
+ * only when its answer is shaped like a document: at least one Markdown
+ * heading. A short answer to a quick question ("what is clean core?") is
+ * not offered. Review/handover do not use this check (unchanged).
+ */
+function looksLikeDocument(text) {
+    return /^#{1,6}\s+\S/m.test(text);
+}
+const OBJECT_TOKEN_RE = /(?<![\w/])((?:\/[A-Za-z0-9]+\/)?[ZYzy][A-Za-z0-9_]{2,39})\b/g;
+/**
+ * The first Z/Y object name in the prompt (final-review m-2): a name with an
+ * underscore (zcl_order, ZFI_DUP_INVOICE_CHECK), or one typed in capitals with
+ * at least 4 characters (ZTEST). Ordinary words never count: you, yes, YES, YOU.
+ */
+export function promptObjectName(prompt) {
+    for (const m of prompt.matchAll(OBJECT_TOKEN_RE)) {
+        const t = m[1];
+        if (t.includes('_') || (t.length >= 4 && t === t.toUpperCase()))
+            return t.toUpperCase();
+    }
+    return undefined;
+}
+/**
+ * Note this turn's (skill, object). `fresh` is false only when the key was
+ * already offered in this session (final-review I-3: a clarifying question
+ * before the document no longer uses up the offer). Without a session: always
+ * fresh (no rule). The offers are cleared by /new (session/cli-record.ts).
+ */
+function noteDocumentTurn(p) {
+    if (!p.session)
+        return { fresh: true, markOffered: () => { } };
+    const object = metaFromMarkdown(p.assistantText, { date: '' }).object ?? promptObjectName(p.userMessage) ?? '';
+    const key = `${p.skill}|${object}`;
+    const offered = documentOffersFor(p.session);
+    return { fresh: !offered.has(key), markOffered: () => { offered.add(key); } };
+}
+/** Today's local date, YYYY-MM-DD (the document file names use it). */
+function localToday() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+/**
+ * The Word step after an artefact save. document-save.ts (and the docx
+ * package) loads only here, inside the catch: a broken docx install costs
+ * one line after the save and never the save itself.
+ */
+async function offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm) {
+    try {
+        const { offerWordCopyAfterArtifactSave } = await import('../projects/document-save.js');
+        const { isHeadless } = await import('../renderer/tty.js');
+        const { loadConfig, resolveWordCopy } = await import('../config/loader.js');
+        await offerWordCopyAfterArtifactSave({
+            saveSkill, savedPath, markdown: p.assistantText, cwd: process.cwd(), sapSystem: p.sapSystem ?? null,
+            // Inside a guided flow the Word step never asks: same rule as headless.
+            today: localToday(), headless: isHeadless() || p.guided === true, wordCopy: resolveWordCopy(await loadConfig()),
+            confirm, emit: p.emit,
+        });
+    }
+    catch (e) {
+        p.emit(formatInfo(`Word copy not written: ${e.message}`).trimEnd());
+    }
+}
 export async function maybeOfferSave(p) {
     if (p.assistantText.trim().length === 0)
         return;
@@ -383,7 +458,26 @@ export async function maybeOfferSave(p) {
     // The skill check reads a tiny constant module; document-save.ts (and the
     // docx package) loads only for these two skills, inside the catch, so a
     // broken docx install costs one line on a review save and nothing else.
-    if (DOCUMENT_SKILLS[p.skill]) {
+    // Word copy everywhere (2026-10-23): the newer document skills (explain,
+    // impact, preflight, …) yield to the artefact save when their answer
+    // carries an artefact block, and offer nothing when the turn ended on a
+    // question. Review and handover take this branch exactly as before.
+    const confirm = p.confirm ?? inkAwareConfirm;
+    const doc = DOCUMENT_SKILLS[p.skill];
+    // Fix round 1 (I-3): which skill and object this turn was about (every turn,
+    // so a follow-up of the same skill on the same object is known).
+    const docTurn = noteDocumentTurn(p);
+    let offerDoc = doc !== undefined;
+    if (doc?.yieldsToArtifact) {
+        // Headless runs of the newer document skills write no file (scripts and CI
+        // keep today's behaviour). Review and handover keep theirs.
+        // A sub-agent turn never saves, so it never uses up the offer (final-review m-1).
+        offerDoc = !p.subagent && docTurn.fresh && !(await import('../renderer/tty.js')).isHeadless() && !p.awaitingAnswer && !p.guided
+            && looksLikeDocument(p.assistantText) && !detectArtifactSkill(p.assistantText);
+        if (offerDoc)
+            docTurn.markOffered();
+    }
+    if (doc && offerDoc) {
         if (p.subagent)
             return;
         const d = new Date();
@@ -395,7 +489,7 @@ export async function maybeOfferSave(p) {
             await offerDocumentSave({
                 skill: p.skill, markdown: p.assistantText, cwd: process.cwd(), sapSystem: p.sapSystem ?? null,
                 today, headless: isHeadless(), wordCopy: resolveWordCopy(await loadConfig()),
-                confirm: inkAwareConfirm, emit: p.emit,
+                confirm, emit: p.emit,
             });
         }
         catch (e) {
@@ -471,6 +565,13 @@ export async function maybeOfferSave(p) {
             // Never headless: a headless journey queues nothing.
             ...(p.journey && !isHeadless() && p.skill === saveSkill ? { journey: p.journey } : {}),
         });
+        // Word copy everywhere (2026-10-23) — a saved project file whose answer
+        // is a document (spec gaps, design, estimate, plan, upgrade scan/report)
+        // gets the same Word step as a review: `word_copy` decides, headless
+        // never asks. The project file itself is untouched. Sub-agent turns: no.
+        if (savedPath && !p.subagent && WORD_AFTER_ARTIFACT_SAVE[saveSkill]) {
+            await offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm);
+        }
         // After a spec-gap file is saved, let a developer answer the open BLOCKER
         // questions inline (recorded as `answered` items in the SAME file) — the
         // business questions stay open for a consultant to answer in the viewer.
@@ -523,6 +624,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;
@@ -855,6 +957,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
@@ -921,7 +1032,43 @@ ${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);
+    }
+    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote, 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
@@ -936,8 +1083,10 @@ ${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, 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);
     // Phase 2 of Track B — opt-in project-context enrichment, gated by
@@ -969,9 +1118,14 @@ ${imageExpansion.error}`));
             sapConnection,
         });
     }
-    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
@@ -988,6 +1142,12 @@ ${imageExpansion.error}`));
     // Images (if any) ride as blocks ahead of the text; with none this is the
     // same plain string as before.
     session.messages.push({ role: 'user', content: buildUserContent(finalUserContent, imageExpansion.images) });
+    if (params.userMessageOrigin) {
+        markCliMessage(session, session.messages[session.messages.length - 1].content, params.userMessageOrigin.kind, params.userMessageOrigin.line);
+    }
+    // The CLI cards answered during this turn (plan gate, lane, journey) belong to this session.
+    if (!params.ctx.subagent && !readerChild)
+        bindCliCardSession(session);
     // Round 6 review I4 / final batch 1 — the switch note is dropped only once
     // it is in a pushed user message.
     if (switchNoteUsed)
@@ -1087,6 +1247,13 @@ ${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 surfaceStarters = (skill) => {
         const msg = buildSkillToolAddition({
             skill,
@@ -1096,6 +1263,12 @@ ${imageExpansion.error}`));
         });
         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 });
+            }
+        }
     };
     // 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.
@@ -1157,7 +1330,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.
@@ -1191,14 +1391,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();
@@ -1234,10 +1448,14 @@ ${imageExpansion.error}`));
             session.turn_seq = preTurnState.turn_seq;
             // 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);
         };
@@ -1273,6 +1491,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
@@ -1396,6 +1617,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;
@@ -1449,8 +1673,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.
@@ -1486,6 +1713,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;
@@ -1544,13 +1775,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;
@@ -1566,12 +1794,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
@@ -1709,8 +1933,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.
@@ -1722,22 +1949,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
@@ -1862,10 +2090,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(),
                 }))
@@ -1898,7 +2129,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
@@ -1986,6 +2225,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,
@@ -2042,6 +2282,9 @@ ${imageExpansion.error}`));
                         emit,
                         sapSystem: session.sap_system,
                         ...(params.ctx.subagent ? { subagent: true } : {}),
+                        ...(session.awaitingSkillAnswer === true ? { awaitingAnswer: true } : {}),
+                        ...(getJourneyFlow(session) || getAppFlow(session) ? { guided: true } : {}),
+                        session,
                         promotedFrom: promotedFromForSave,
                         ...(promotedFromPathForSave ? { promotedFromPath: promotedFromPathForSave } : {}),
                         ...(() => {
@@ -2195,6 +2438,7 @@ ${imageExpansion.error}`));
                         + 'If you were mid-way through a tool call, or (for /abap-plan) had not yet emitted the closing cspeach:plan-manifest block, complete it now. '
                         + 'Keep narration brief to stay within the limit.',
                 });
+                markCliMessage(session, session.messages[session.messages.length - 1].content, 'continue', CONTINUE_LINE);
                 continue;
             }
             if (sawMaxTokens) {
@@ -2515,10 +2759,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,
                 });
             }
@@ -2538,6 +2789,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,
@@ -2546,6 +2798,7 @@ ${imageExpansion.error}`));
                 watchdogWarned = true;
                 emit(chalk.yellow(`\n[watchdog] ${decision.reason}. Asking the model to wrap up.`));
                 session.messages.push({ role: 'user', content: decision.message });
+                markCliMessage(session, decision.message, 'watchdog', WATCHDOG_LINE);
                 await saveSession(session);
             }
         }
@@ -2571,3 +2824,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;

package/dist/agent/provider-shape.js

@@ -1,5 +1,5 @@
 import { TOOL_CHANGES_BETA, isToolSearchEntry } from '../tools/tool-loading.js';
-import { DELEGATE_SKILL_HEADER } from './system-prompt.js';
+import { DELEGATE_SKILL_HEADER, SKILL_INLINE_HEADER } from './system-prompt.js';
 import { STYLE_HEADER } from './style.js';
 import { LEVEL_HEADER } from './level.js';
 /** Betas the proxy sends on every managed turn (messages.ts `betas: [...]`). */
@@ -270,14 +270,14 @@ export function withoutInternalHeaders(headers) {
 /**
  * Task 9 — the role header is new proxy plumbing; AI-hub keeps today's header
  * set, so X-CSPeach-Model-Role (and, 2026-10-04, the delegate header; and,
- * 2026-10-17, the talking-style and level headers — applied locally) are
- * removed.
+ * 2026-10-17, the talking-style and level headers — applied locally; and,
+ * Stage 1A, the inline header — applied locally) are removed.
  */
 export function withoutRoleHeader(headers) {
     const out = {};
     for (const [k, v] of Object.entries(headers ?? {})) {
         const lk = k.toLowerCase();
-        if (lk === 'x-cspeach-model-role' || lk === DELEGATE_SKILL_HEADER.toLowerCase() || lk === STYLE_HEADER.toLowerCase() || lk === LEVEL_HEADER.toLowerCase())
+        if (lk === 'x-cspeach-model-role' || lk === DELEGATE_SKILL_HEADER.toLowerCase() || lk === STYLE_HEADER.toLowerCase() || lk === LEVEL_HEADER.toLowerCase() || lk === SKILL_INLINE_HEADER.toLowerCase())
             continue;
         out[k] = v;
     }
@@ -291,6 +291,10 @@ export function headersForProfile(profile, headers) {
         case 'none': return { ...(headers ?? {}) };
     }
 }
+/** Stage 1A — true when the loop sent X-CSPeach-Skill-Inline: '1' (a direct provider then builds the one block locally). */
+export function skillInlineFromHeaders(options) {
+    return options.headers?.[SKILL_INLINE_HEADER] === '1';
+}
 /** 2026-10-04 — the plan phase's delegate skill, when the loop sent one. */
 export function delegateSkillName(options) {
     const v = options.headers?.[DELEGATE_SKILL_HEADER];