@cspeach/cli 1.1.51 → 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';
@@ -69,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';
@@ -84,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';
@@ -135,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
@@ -614,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;
@@ -946,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
@@ -1012,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
@@ -1027,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
@@ -1060,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
@@ -1184,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,
@@ -1193,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.
@@ -1254,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.
@@ -1288,15 +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();
@@ -1332,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);
         };
@@ -1371,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
@@ -1494,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;
@@ -1547,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.
@@ -1584,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;
@@ -1642,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;
@@ -1664,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
@@ -1807,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.
@@ -1820,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
@@ -1960,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(),
                 }))
@@ -1996,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
@@ -2084,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,
@@ -2617,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,
                 });
             }
@@ -2640,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,
@@ -2674,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];

package/dist/agent/providers/ai-hub-provider.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import keychain from '../../auth/keychain.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, requireSkillName, toLegacyShape, withoutRoleHeader } from '../provider-shape.js';
+import { delegateSkillName, requireSkillName, skillInlineFromHeaders, toLegacyShape, withoutRoleHeader } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -28,7 +28,7 @@ export function createAiHubProvider(cfg, getBearer = defaultBearer) {
             const skillName = requireSkillName(options, 'AI Hub');
             const token = await getToken();
             // Task 18 — the `_reader` header uses the pinned reader prompt, no lookup.
-            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: AI_HUB_PROFILE.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: AI_HUB_PROFILE.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
             const request = {
                 ...toLegacyShape(params),
                 system,

package/dist/agent/providers/azure-provider.js

@@ -15,7 +15,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import { sendsEffortFor } from '../connection-profile.js';
 import { AZURE_PROFILE } from '../azure-profile.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, headersForProfile, requireSkillName, withoutToolChanges, withSkillPrompt } from '../provider-shape.js';
+import { delegateSkillName, headersForProfile, requireSkillName, skillInlineFromHeaders, withoutToolChanges, withSkillPrompt } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -66,7 +66,7 @@ export function createAzureProvider(cfg, getBearer = defaultBearer, deps = {}) {
             throw new AzureConnectionRefusedError(v.message);
         const conn = cached.connection;
         const skillName = requireSkillName(options, 'Azure');
-        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: profile.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: profile.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
         const base = profile.toolChanges ? params : withoutToolChanges(params);
         const family = familyFromTable(params.model, conn.deployments);
         const body = withAzureEffort(shapeForAzure(withSkillPrompt(base, system, { cacheMarkers: profile.cacheMarkers }), profile), profile, roleOf(options.headers), family);

package/dist/agent/providers/byok-provider.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import keychain from '../../auth/keychain.js';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, modelAcceptsFallbacks, requiredBetas, requireSkillName, withoutInternalHeaders, withSkillPrompt } from '../provider-shape.js';
+import { delegateSkillName, skillInlineFromHeaders, modelAcceptsFallbacks, requiredBetas, requireSkillName, withoutInternalHeaders, withSkillPrompt } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -21,7 +21,7 @@ export function createByokProvider(cfg, getBearer = defaultBearer) {
         const skillName = requireSkillName(options, 'BYOK');
         const key = await getKey();
         // Task 18 — the `_reader` header uses the pinned reader prompt, no lookup.
-        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: BYOK_PROFILE.cacheMarkers }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+        const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: BYOK_PROFILE.cacheMarkers, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
         // Task 6 — opt into server-side fallback, only for the families probe
         // P3 proved (allow-list); requiredBetas adds its beta.
         const prompted = withSkillPrompt(params, system, { cacheMarkers: BYOK_PROFILE.cacheMarkers });

package/dist/agent/providers/local-provider.js

@@ -2,7 +2,7 @@
 const loadOpenAI = async () => (await import('openai')).default;
 import crypto from 'node:crypto';
 import { createAuthedSkillSource, defaultBearer } from '../../skills/source-authed.js';
-import { delegateSkillName, requireSkillName } from '../provider-shape.js';
+import { delegateSkillName, requireSkillName, skillInlineFromHeaders } from '../provider-shape.js';
 import { systemPromptForSkill } from '../system-prompt.js';
 import { styleFromHeaders } from '../style.js';
 import { levelFromHeaders } from '../level.js';
@@ -29,7 +29,7 @@ export function createLocalProvider(cfg, getBearer = defaultBearer) {
             // message (no cache markers). anthropicParamsToOpenAI copies only
             // max_tokens / messages / system, so newer fields never reach the endpoint.
             const skillName = requireSkillName(options, 'Local');
-            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: false }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
+            const system = await systemPromptForSkill(skillName, skillSource, { cacheMarkers: false, inline: skillInlineFromHeaders(options) }, delegateSkillName(options), styleFromHeaders(options.headers), levelFromHeaders(options.headers));
             const OpenAI = await loadOpenAI();
             const sdk = new OpenAI({ apiKey: 'local-ignored', baseURL });
             const openAiParams = anthropicParamsToOpenAI({ ...params, system }, model);

package/dist/agent/repair-partial.js

@@ -204,6 +204,18 @@ export function isPartialJsonApiError(err) {
 /** Result text for a tool call whose real result was lost to an interruption. */
 export const INTERRUPTED_TOOL_RESULT = 'This tool call did not complete — the turn was interrupted before its result was recorded. ' +
     'Its effect is unknown: check before relying on it, and re-run it if needed.';
+/**
+ * LT-15 D6 — result text for a tool call stopped (Esc / Ctrl+C) at a point
+ * where the tool KNOWS nothing ran yet: before its card, its WAL entry and any
+ * SAP change. Same shape and flags as INTERRUPTED_TOOL_RESULT (is_error: true).
+ */
+export const STOPPED_BEFORE_START_RESULT = 'This tool call was stopped before anything ran — no change was made in SAP. Ask again if it is still needed.';
+/**
+ * LT-15 D6 (review M5) — the same, for the write pipeline's second guard: by
+ * then the approval was spent and SAP was read (a local snapshot may exist),
+ * but the change itself was not made. Same shape and flags.
+ */
+export const STOPPED_BEFORE_WRITE_RESULT = 'This tool call was stopped before the change was made — nothing was written to SAP. Ask again if it is still needed.';
 /**
  * 2026-09-24 — heal tool_use blocks that have no tool_result after them.
  *