@cspeach/cli 1.1.49 → 1.1.50

package/dist/agent/cold-prune.js

@@ -35,7 +35,7 @@ function elidedMarker(chars) {
     return `[result elided at cold start — ${chars} chars]`;
 }
 /** Characters a tool_result's content carries (text, else its JSON). */
-function contentChars(content) {
+export function contentChars(content) {
     if (typeof content === 'string')
         return content.length;
     if (!Array.isArray(content))

package/dist/agent/conversation-prompt.js

@@ -0,0 +1,52 @@
+/**
+ * Conversation architecture (review 2026-10-21 §5 stage 2 item 1) — the one
+ * system prompt for a session in assistant.skills = inline mode, where
+ * playbooks load into the conversation as <skill> blocks instead of
+ * replacing the system prompt.
+ *
+ * DORMANT (stage 0): nothing imports this until stage 2 adds the inline
+ * setting. First draft — stage 2's eval set may change the words; move the
+ * pin with them.
+ *
+ * The proxy holds the same text as a literal
+ * (cspeach-proxy/src/skills/conversation-prompt.ts);
+ * src/agent/__tests__/conversation-prompt-pin.test.ts keeps them byte-equal
+ * and checks that no module imports either copy yet. Keep the literal free of
+ * backslashes, backticks and ${ so the raw literal is the runtime text.
+ */
+export const CONVERSATION_SYSTEM_PROMPT = `You are CSPeach, an AI coding agent for SAP development. You are the developer's senior colleague: years of ABAP, S/4HANA, FI/CO, MM, SD, RAP, CDS and Fiori, and the person the team asks when something doesn't add up.
+
+How you talk
+- Answer what was asked, at the size it was asked. A quick question gets a short answer; "walk me through it" gets a walk-through.
+- Lead with the answer or what you found. Then why. Then what you'd do next, if anything.
+- Plain words, short sentences. Use headings, tables or lists only when they make the answer easier to read.
+- Have a view. If something is a bad idea, say so and say why. If you're not sure, say what you'd check.
+- No flattery. Apologise only when you got something wrong.
+
+How you work
+- Look before you answer. When the question is about this developer's system or project, read the real thing with your tools instead of guessing. Say in a few words what you're checking.
+- Ground what you say in what you read: object names, line numbers, field names, counts. Never invent objects, fields, results or tool output. If a tool fails or no SAP system is connected, say so plainly and carry on with what you can do.
+- Batch independent reads in one response. When a result says it was saved to a file, read the slice you need with tool_output_read; do not re-run the command.
+- Send more than two source reads, any where-used scan, ATC-finding triage or a package inventory to a reader: call read_agent with a precise brief and work from its report. Do not read those sources yourself when the turn will keep working afterwards. Send independent readers in one response so they run at the same time. Do not use a reader for one or two reads, a small edit, or to check your own work. Never more than three readers for one task unless the person asks.
+
+Playbooks
+- Without a loaded playbook you read and explain, and you never change SAP. When the conversation turns into a change, or the person asks for a deliverable a workflow produces, say briefly what you'd do and call hand_off with the right workflow and a clear request.
+- When a playbook is loaded (a <skill> block below), it is in charge. Follow its steps, its plan-then-wait, and its one request_approval for all changes. The Safety and Ground rules below still hold when a playbook says otherwise.
+- The most recently loaded playbook wins over any earlier one.
+- Load another playbook when the person's request needs it: call hand_off, or dispatch_skill after the person has picked the command. Do not do another playbook's work yourself.
+
+Safety
+- Every change in SAP needs a valid approval_id from request_approval. You cannot bypass this. If you will change more than one object, put all the changes in one request_approval first.
+- If a plan is rejected, ask what to change. Do not quietly revise and re-submit.
+- Snapshots are taken before every write, and syntax and activation are checked after it. Do not ask the person to confirm snapshots. Do not activate when there are syntax errors.
+- If ATC or syntax errors block activation, fix them or ask. Never suppress or hide them.
+- To change logic inside existing methods without changing the class definition, use sap_update_method per method, not sap_set_source.
+- All writes go into the active session transport. Do not ask for a transport number per change. Never use $TMP unless the person asks for local-only work.
+- If a tool error blocks you and you don't know how to recover, say so clearly and ask how to proceed. Stop and ask before a fourth attempt at the same operation.
+- For an unclear request, ask one question before acting.
+- Before you delete or overwrite an object in a production namespace, confirm in text that the person means it, even when you have an approval_id.
+
+Ground rules
+- Follow the team's development standards when they are given in <development_standards>; they win over your own preferences.
+- Use the SAP system and profile given in <session_context>; never assume a different system.
+- Never ask for, print or store passwords or keys.`;

package/dist/agent/loop.js

@@ -13,6 +13,7 @@ import { buildToolList, buildSkillToolAddition, placeSystemMessagesInPlace, reso
 import { settleSessionToolLoading } from './tool-loading-pin.js';
 import { resolveSkillAlias } from '../skill-catalog.js';
 import { retryWithBackoff } from './retry.js';
+import { capToolResultContent, isPromptTooLongError, promptTooLongNotice, promptTooLongRetryLine, safeHistoryChars, trimOversizedToolResults } from './oversized-results.js';
 import { renderChunk, initialBufferState, render } from '../renderer/pipeline.js';
 import { filterMachineBlocks, flushMachineBlocks, initialMachineBlockState } from '../renderer/machine-blocks.js';
 import { nextWritingActivity } from '../renderer/fence-state.js';
@@ -32,6 +33,7 @@ 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 { sessionMaxTokens, clampMaxTokens, sendsBlockBinding } from './provider-shape.js';
 import { profileOf, sendsEffortFor } from './connection-profile.js';
 import { computeSessionCost } from '../cost/session-cost.js';
@@ -654,6 +656,40 @@ export async function runTurn(params) {
         else
             console.log(line);
     }
+    // 2026-10-22 customer bug — an oversized tool result stayed in the history
+    // and every later message got "prompt is too long". Remove the largest tool
+    // results (user and assistant text stay) and save. Owner decision
+    // 2026-10-22: when something was removed, the SAME request goes out again
+    // once, in this turn (the user message is already in the history — never
+    // appended twice). No retry when the person stopped the turn, when nothing
+    // could be removed, or when this turn already retried once.
+    let promptTooLongRetried = false;
+    async function trimForPromptTooLong(err) {
+        const trimmed = trimOversizedToolResults(session.messages, safeHistoryChars(session.messages, err));
+        if (trimmed.removed > 0)
+            delete session.last_context_tokens;
+        session.turnInterrupted = false;
+        session.turnInterruptedReason = undefined;
+        await saveSession(session);
+        return trimmed;
+    }
+    /**
+     * Trim the history; when something was removed and a retry is allowed, show
+     * the info line and return true (the caller runs the same request again).
+     * Otherwise show the card (unless `card: false`) and return false.
+     */
+    async function recoverFromPromptTooLong(err, opts = {}) {
+        const mayRetry = !promptTooLongRetried && !params.signal?.aborted;
+        const trimmed = await trimForPromptTooLong(err);
+        if (mayRetry && trimmed.removed > 0) {
+            promptTooLongRetried = true;
+            emit('\n' + promptTooLongRetryLine(trimmed).trimEnd());
+            return true;
+        }
+        if (opts.card !== false)
+            emit('\n' + promptTooLongNotice(trimmed).trimEnd());
+        return false;
+    }
     // Guided clean-core journey (Task 3) — the journey survives only its own
     // queued step (or a plain reply inside it); any other turn ends the chain
     // with one line. No journey → nothing happens here.
@@ -1409,6 +1445,14 @@ ${imageExpansion.error}`));
                 }).trimEnd());
                 return;
             }
+            // 2026-10-22 — the provider says the prompt is too long: remove the
+            // 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))
+                    continue;
+                return;
+            }
             // Proxy returns 409 upgrade_required when CLI is older than skill's min_cli_version.
             const status = err?.status ?? err?.response?.status;
             const bodyRaw = err?.error ?? err?.response?.data ?? err?.body;
@@ -1659,6 +1703,15 @@ ${imageExpansion.error}`));
             if (callIndex === 0 && currentAssistantContent.length === 0 && isChatUnavailable(err)) {
                 withdrawChatTurn((err?.status ?? err?.response?.status));
             }
+            // 2026-10-22 — "prompt is too long" on the stream, before anything
+            // streamed: the same recovery as at create time. A retry runs the same
+            // request again right here (nothing of this round is persisted). No
+            // 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 }))
+                    continue;
+            }
         }
         // Final flush: emit any pending partial line after the stream ends.
         // Runs on both clean completion and mid-stream interruption.
@@ -1805,6 +1858,18 @@ ${imageExpansion.error}`));
             const callTokens = perCallTokens(nowTokens, lastLoggedTokens);
             lastLoggedTokens = nowTokens;
             const turnDurationMs = Date.now() - turnStartedAt;
+            // Task 0.2 (conversation Stage 0) — main calls only: the skill header
+            // 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;
+            const systemBlock = mainLine
+                ? noteSystemBlock(session, systemBlockKey({
+                    skill: params.skill,
+                    delegateSkill: params.delegateSkill,
+                    style: getAssistantStyle(),
+                    level: getAssistantLevel(),
+                }))
+                : undefined;
             const entry = buildCostEntry({
                 turn: turnNumber,
                 // A4 — when a per-turn override ran the stream on a different model
@@ -1831,6 +1896,8 @@ ${imageExpansion.error}`));
                 // Task 18 (F24) — running reader totals of this turn (absent until a
                 // reader has run).
                 reader: params.ctx.readerSpend,
+                skill: mainLine ? params.skill : undefined,
+                system_block: systemBlock,
             });
             readerCallsLogged = params.ctx.readerSpend?.calls ?? 0;
             void appendCostLine(session.id, entry);
@@ -1870,13 +1937,25 @@ ${imageExpansion.error}`));
         await turnStreamWriter.close(interruptedError !== null
             ? `_interrupted: ${session.turnInterruptedReason ?? 'unknown'}_`
             : undefined);
+        // 2026-10-22 — "prompt is too long" can also arrive on the stream: the
+        // same recovery as at create time, instead of a "type continue" that
+        // could only fail again.
+        const recoverTooLong = interruptedError !== null && !readerChild && !params.ctx.subagent
+            && !params.signal?.aborted && isPromptTooLongError(interruptedError);
         // Guided clean-core journey (Task 3, fix round 1) — the queued step was
         // interrupted: pause the journey so "carry on" resumes it on the first try.
+        // On a recovery the card is the one next step: the journey is paused, but
+        // its "Paused … carry on" line is not printed.
         if (interruptedError !== null && !readerChild && !params.ctx.subagent) {
             const journeyLine = pauseJourneyForInterruptedTurn(session);
-            if (journeyLine && !isHeadless())
+            if (journeyLine && !isHeadless() && !recoverTooLong)
                 emit(journeyLine);
         }
+        if (recoverTooLong) {
+            promptTooLongRetried = true; // after the persist block: never a retry from here
+            await recoverFromPromptTooLong(interruptedError);
+            return;
+        }
         // Re-throw AFTER persistence so the outer REPL catch can render the
         // graceful error UX with full session-id + log-path context.
         if (interruptedError !== null)
@@ -2434,10 +2513,12 @@ ${imageExpansion.error}`));
                 }
                 // Normal path falls through: the existing `toolResults.push(...)` block
                 // 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).
                 toolResults.push({
                     type: 'tool_result',
                     tool_use_id: block.id,
-                    content: result.content,
+                    content: capToolResultContent(result.content),
                     is_error: result.is_error,
                 });
             }

package/dist/agent/oversized-results.js

@@ -0,0 +1,204 @@
+/**
+ * Oversized tool results (2026-10-22 customer bug).
+ *
+ * A Word spec whose pictures came back as base64 gave one tool result of
+ * ~2.3M tokens. The provider answered "prompt is too long", and because the
+ * result stayed in session.messages every later message failed the same way.
+ *
+ *  - capToolResultContent: the loop's general guard. Any tool result over
+ *    TOOL_RESULT_MAX_CHARS is cut with a note; anything under it is returned
+ *    as the same value, so those requests stay byte-identical.
+ *  - isPromptTooLongError + trimOversizedToolResults + promptTooLongNotice:
+ *    the recovery when the provider still says the prompt is too long. Only
+ *    tool_result content changes (largest first); the block, its tool_use_id
+ *    pairing and every user and assistant text stay. Thinking blocks after
+ *    the first changed result are dropped, as the cold-start prune does: they
+ *    are bound to the old prefix.
+ */
+import { contentChars } from './cold-prune.js';
+import { stripThinking } from '../commands/compact.js';
+import { formatAttention, formatFailure, formatInfo } from '../renderer/notice-shape.js';
+/** Largest tool result text the loop sends (≈100–130k tokens). */
+export const TOOL_RESULT_MAX_CHARS = 400_000;
+/** A tool result smaller than this is never removed by the recovery. */
+export const TRIM_MIN_CHARS = 10_000;
+/** History budget when the provider's error names no token counts. */
+export const DEFAULT_SAFE_HISTORY_CHARS = 600_000;
+/** Head-room under the provider's named limit (char→token ratios vary). */
+const BUDGET_MARGIN = 0.7;
+function cutNote(more) {
+    return `\n… [result cut: ${more} more chars. It was too large to send in one piece. Read it in smaller parts, for example with offset and limit.]`;
+}
+/**
+ * Cap a tool result's text at `max` chars. A string or text blocks under the
+ * cap come back as the same value (no copy); image and other blocks are left
+ * alone. Never mutates its input.
+ */
+export function capToolResultContent(content, max = TOOL_RESULT_MAX_CHARS) {
+    if (typeof content === 'string') {
+        if (content.length <= max)
+            return content;
+        return (content.slice(0, max) + cutNote(content.length - max));
+    }
+    if (!Array.isArray(content))
+        return content;
+    let left = max;
+    let changed = false;
+    const out = content.map((b) => {
+        const block = b;
+        if (block?.type !== 'text' || typeof block.text !== 'string')
+            return b;
+        if (block.text.length <= left) {
+            left -= block.text.length;
+            return b;
+        }
+        changed = true;
+        const keep = left;
+        left = 0;
+        return { ...block, text: block.text.slice(0, keep) + cutNote(block.text.length - keep) };
+    });
+    return (changed ? out : content);
+}
+// The API's "prompt is too long" 400 and its 413 request_too_large; the
+// local / OpenAI-shaped context-length error.
+const PROMPT_TOO_LONG_RE = /prompt is too long|request_too_large|context_length_exceeded|maximum context length/i;
+function errorTexts(err) {
+    if (err == null)
+        return [];
+    const e = err;
+    const out = [];
+    out.push(err instanceof Error ? err.message : typeof e.message === 'string' ? e.message : String(err));
+    if (e.error != null) {
+        try {
+            out.push(typeof e.error === 'string' ? e.error : JSON.stringify(e.error));
+        }
+        catch { /* unserialisable body */ }
+    }
+    return out;
+}
+/**
+ * True for the provider's "prompt is too long" refusal — the same words come
+ * back from a direct provider and through our proxy (message text or the
+ * SDK's parsed `.error` body) — and for the same condition in its other
+ * shapes: the API's 413 request_too_large and the local / OpenAI-shaped
+ * context-length error.
+ */
+export function isPromptTooLongError(err) {
+    return errorTexts(err).some((t) => PROMPT_TOO_LONG_RE.test(t));
+}
+/**
+ * The history size (JSON chars) to trim down to. When the error names the
+ * counts ("2357619 tokens > 1000000 maximum") the history is scaled to that
+ * limit with head-room; otherwise DEFAULT_SAFE_HISTORY_CHARS.
+ */
+export function safeHistoryChars(messages, err) {
+    for (const t of errorTexts(err)) {
+        const m = /(\d+)\s*tokens?\s*>\s*(\d+)/i.exec(t);
+        if (!m)
+            continue;
+        const sent = Number(m[1]);
+        const limit = Number(m[2]);
+        if (sent > 0 && limit > 0 && limit < sent) {
+            return Math.floor(JSON.stringify(messages).length * (limit / sent) * BUDGET_MARGIN);
+        }
+    }
+    return DEFAULT_SAFE_HISTORY_CHARS;
+}
+function removedNote(chars) {
+    return `[removed: this result was too large to send — ${chars} chars. Read it in smaller parts.]`;
+}
+/** Recognises a result this recovery already removed. */
+export const REMOVED_RESULT_RE = /^\[removed: this result was too large to send — \d+ chars\. Read it in smaller parts\.\]$/;
+/**
+ * Replace the content of the largest tool results (each over TRIM_MIN_CHARS)
+ * with a short note until the history's JSON is under `budgetChars`. At least
+ * the largest one goes even when the count already looks under budget (the
+ * provider said it is too long). Mutates `messages` in place.
+ */
+export function trimOversizedToolResults(messages, budgetChars) {
+    const candidates = [];
+    messages.forEach((m, i) => {
+        if (m.role !== 'user' || !Array.isArray(m.content))
+            return;
+        for (const block of m.content) {
+            if (block?.type !== 'tool_result')
+                continue;
+            if (typeof block.content === 'string' && REMOVED_RESULT_RE.test(block.content))
+                continue;
+            const chars = contentChars(block.content);
+            if (chars >= TRIM_MIN_CHARS)
+                candidates.push({ msg: i, block, chars });
+        }
+    });
+    if (candidates.length === 0)
+        return { removed: 0, removedChars: 0 };
+    candidates.sort((a, b) => b.chars - a.chars);
+    let total = JSON.stringify(messages).length;
+    let removed = 0;
+    let removedChars = 0;
+    let firstChanged = Infinity;
+    for (const c of candidates) {
+        if (removed > 0 && total <= budgetChars)
+            break;
+        const before = JSON.stringify(c.block.content ?? null).length;
+        const note = removedNote(c.chars);
+        c.block.content = note;
+        total -= before - JSON.stringify(note).length;
+        removed++;
+        removedChars += c.chars;
+        firstChanged = Math.min(firstChanged, c.msg);
+    }
+    // Round 2+ of a tool loop: the history ends in tool_results answering the
+    // last assistant message. That message keeps its thinking (the API wants
+    // the open tool loop's assistant turn to start with it); the cold-prune
+    // rule applies to the messages before it.
+    const openLoopAssistant = openToolLoopAssistant(messages);
+    for (let i = firstChanged + 1; i < messages.length; i++) {
+        if (i === openLoopAssistant)
+            continue;
+        messages[i] = stripThinking(messages[i]);
+    }
+    return { removed, removedChars };
+}
+/**
+ * Index of the assistant message whose tool_use the history's final
+ * tool_results answer, or -1 when the history does not end that way.
+ */
+function openToolLoopAssistant(messages) {
+    const last = messages[messages.length - 1];
+    const prev = messages[messages.length - 2];
+    if (!last || !prev || last.role !== 'user' || prev.role !== 'assistant')
+        return -1;
+    if (!Array.isArray(last.content) || !Array.isArray(prev.content))
+        return -1;
+    const answered = new Set(last.content
+        .filter((b) => b?.type === 'tool_result')
+        .map((b) => b.tool_use_id));
+    const asks = prev.content.some((b) => b?.type === 'tool_use' && answered.has(b.id));
+    return asks ? messages.length - 2 : -1;
+}
+/** The card shown after the recovery ran (never "type continue"). */
+export function promptTooLongNotice(r) {
+    if (r.removed === 0) {
+        return formatFailure({
+            what: 'This conversation is too large to send',
+            detail: ['There is nothing large left that we can remove from it.'],
+            next: 'type /new to start a fresh conversation',
+        });
+    }
+    const what = r.removed === 1 ? 'one large tool result' : `${r.removed} large tool results`;
+    return formatAttention({
+        text: 'This conversation got too large to send',
+        fact: `we removed ${what} (${r.removedChars.toLocaleString('en-US')} characters) and saved the session · your messages and our replies are kept`,
+        next: 'send your message again',
+    });
+}
+/**
+ * The one info line before the automatic retry (owner decision 2026-10-22):
+ * the history was trimmed and the same request goes out again, so there is
+ * no "Next:" step for the person.
+ */
+export function promptTooLongRetryLine(r) {
+    const what = r.removed === 1 ? 'one large tool result' : `${r.removed} large tool results`;
+    return formatInfo(`We removed ${what} (${r.removedChars.toLocaleString('en-US')} characters) to keep this conversation within its limit. Your messages and our replies are kept.`);
+}

package/dist/agent/turn-error-ux.js

@@ -23,6 +23,7 @@ import * as path from 'node:path';
 import { TurnStreamWriter } from './turn-stream.js';
 import { azureSignInTurnLine } from '../connection/azure-turn-error.js';
 import { azureErrorNotice, azureErrorContext } from '../connection/azure-errors.js';
+import { isPromptTooLongError } from './oversized-results.js';
 export function logsRoot() {
     return path.join(os.homedir(), '.cspeach', 'logs');
 }
@@ -226,6 +227,19 @@ export async function renderTurnError(input) {
         print('');
         return;
     }
+    // 2026-10-22 — "prompt is too long": the loop recovers the main turn
+    // (agent/oversized-results.ts). Anything that still reaches here must not
+    // say "type continue" — that re-sends the same history and fails again.
+    if (isPromptTooLongError(input.err)) {
+        await writeErrorLog(id, input.err);
+        printBlock(print, formatFailure({
+            what: 'This conversation is too large to send',
+            detail: [describeError(input.err), `Session: ${id}`],
+            next: 'type /new to start a fresh conversation',
+        }));
+        print('');
+        return;
+    }
     const reason = describeError(input.err);
     const logPath = await writeErrorLog(id, input.err);
     const detail = [reason, `Session: ${id}`];

package/dist/commands/plan-continue-gate.js

@@ -0,0 +1,11 @@
+/**
+ * The marker a turn continues from, or null: only an /abap-plan turn that is
+ * not already a plan resume, with a plan step in flight. /new clears the
+ * marker (session/fresh-start.ts), so "continue" after /new never takes this
+ * path.
+ */
+export function planContinuationMarker(session, skill, planResume) {
+    if (skill !== 'abap-plan' || planResume !== null)
+        return null;
+    return session.plan_in_flight ?? null;
+}

package/dist/cost/cost-log.js

@@ -83,6 +83,10 @@ export function buildEntry(opts) {
             entry.reader_cost_usd = Math.round(opts.reader.cost * 10000) / 10000;
         entry.reader_calls = opts.reader.calls;
     }
+    if (opts.skill !== undefined)
+        entry.skill = opts.skill;
+    if (opts.system_block !== undefined)
+        entry.system_block = opts.system_block;
     return entry;
 }
 /**

package/dist/cost/system-block.js

@@ -0,0 +1,25 @@
+/**
+ * Conversation Stage 0, Task 0.2 — did this main call send the same system
+ * block as the session's previous one?
+ *
+ * The system block is decided by four inputs, on the proxy (skill body,
+ * delegate skill, style text, level text; the preamble is constant per CLI
+ * version) and on direct providers alike. The key joins them; the note
+ * compares it with the session's last key. Observability only: the result is
+ * written to the cost log and never changes a request.
+ *
+ * Kept in a module WeakMap, never in the session file (no schema change). A
+ * resumed session therefore starts at 'first' again.
+ */
+export function systemBlockKey(p) {
+    return `${p.skill}|${p.delegateSkill ?? ''}|${p.style}|${p.level}`;
+}
+const lastKeyBySession = new WeakMap();
+/** Records `key` as the session's latest and says how it compares with the previous one. */
+export function noteSystemBlock(session, key) {
+    const prev = lastKeyBySession.get(session);
+    lastKeyBySession.set(session, key);
+    if (prev === undefined)
+        return 'first';
+    return prev === key ? 'same' : 'changed';
+}

package/dist/models/server-config.js

@@ -105,12 +105,14 @@ function coerceDocument(body, fetchedAt) {
         return null;
     const toolLoading = coerceToolLoading(b.tool_loading);
     const autoCompactTokens = coerceAutoCompactTokens(b.auto_compact_tokens);
+    const inlineSkills = typeof b.inline_skills === 'boolean' ? b.inline_skills : undefined;
     return {
         roles,
         pricing: coercePricing(b.pricing),
         effort: coerceEffort(b.effort),
         ...(toolLoading ? { tool_loading: toolLoading } : {}),
         ...(autoCompactTokens !== undefined ? { auto_compact_tokens: autoCompactTokens } : {}),
+        ...(inlineSkills !== undefined ? { inline_skills: inlineSkills } : {}),
         fetchedAt: typeof fetchedAt === 'string' && fetchedAt.length > 0 ? fetchedAt : new Date().toISOString(),
     };
 }
@@ -277,6 +279,17 @@ export function servedToolLoading() {
 export function managedProxyServesNewShapes() {
     return snapshot?.tool_loading !== undefined;
 }
+/**
+ * Conversation stage 0 (Task 0.5) — does the managed proxy serve the
+ * conversation prompt? True only when its served config says
+ * `inline_skills: true`; false with no snapshot or an older proxy. Managed
+ * snapshot only: BYOK builds its own system prompt and never needs it.
+ * Dormant — nothing calls it until stage 2 (pinned by
+ * __tests__/served-inline-skills-pin.test.ts). Pure sync read.
+ */
+export function servedInlineSkills() {
+    return snapshot?.inline_skills === true;
+}
 // 2026-10-02 (BYOK local routing) — BYOK now classifies prompts on the laptop
 // (direct to the model, the customer's key) instead of POSTing them to our
 // /v1/classify. It uses the router model CSPeach serves, `roles.router`, kept

package/dist/projects/workspace.js

@@ -606,6 +606,8 @@ function shortHint(filename) {
  * char boundary because we slice the decoded string, not the bytes.
  */
 const MAX_TEXT_FILE_CHARS = 64 * 1024;
+/** The note after a cut attachment (also refused in SAP writes: tools/cut-markers.ts). */
+export const ATTACHMENT_TRUNCATED_NOTE = '... [truncated, file exceeds 64 KB]';
 /**
  * Scan `userMessage` for `@<token>` references that resolve to .txt /
  * .md files in the workspace, read their content, and substitute the
@@ -690,9 +692,10 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
             try {
                 const buf = readFileSync(path);
                 const ext = path.toLowerCase().endsWith('.pdf') ? '.pdf' : '.docx';
-                const { extractDocument } = await import('../tools/filesystem/extract-document.js');
+                const { extractDocument, splitLongLines, DOC_MAX_LINE_CHARS } = await import('../tools/filesystem/extract-document.js');
                 const res = await extractDocument(buf, ext, { maxPages: 150 });
-                content = res.text;
+                // 2026-10-22 — long lines split as in read_document; the 64 KB cap below is the total.
+                content = splitLongLines(res.text, DOC_MAX_LINE_CHARS);
                 if (log)
                     for (const w of res.warnings)
                         log(`(${filename}: ${w})`);
@@ -714,7 +717,7 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
             }
         }
         if (content.length > MAX_TEXT_FILE_CHARS) {
-            content = content.slice(0, MAX_TEXT_FILE_CHARS) + '\n... [truncated, file exceeds 64 KB]';
+            content = content.slice(0, MAX_TEXT_FILE_CHARS) + '\n' + ATTACHMENT_TRUNCATED_NOTE;
         }
         const replacement = `<attached file="${filename}">\n${content}\n</attached>`;
         substitutions.push({ index, matchLen: match.length, replacement });

package/dist/repl.js

@@ -51,6 +51,8 @@ import { getConnection } from './sap/connection-manager.js';
 import { unreachableCode, unreachableMessage } from './sap/unreachable.js';
 import { AdtClient, snapshots } from '@cspeach/sap-client';
 import { makeSessionId, saveSession, sessionSaved } from './session/store.js';
+import { startFreshConversation, freshStartText } from './session/fresh-start.js';
+import { planContinuationMarker } from './commands/plan-continue-gate.js';
 import { newSession } from './session/schema.js';
 import { resolveModelRole } from './models/resolve.js';
 import { familyOf, planTierModelFor, getActiveDeployments } from './models/model-identity.js';
@@ -1376,7 +1378,11 @@ export async function runRepl(opts) {
                 todoEmitter.emit('update', []);
                 clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
                 clearJourneyFlow(session); // Task 3 — and a clean-core journey
-                chunkEmitter.emit('chunk', '\n' + (laneSetting === 'chat' ? formatInfo('Fresh start.') : formatInfo('Fresh start · the next prompt picks a skill again')));
+                // 2026-10-22 — and the conversation history: the next prompt sends none of it.
+                startFreshConversation(session);
+                idleKeepalive.disarm(); // no idle cache ping for the old history
+                await saveSession(session);
+                chunkEmitter.emit('chunk', '\n' + formatInfo(freshStartText(laneSetting)));
                 return;
             }
             // /chat [on|off] (spec 2026-10-17 D6, owner amendment) — leave a workflow,
@@ -1925,8 +1931,8 @@ export async function runRepl(opts) {
             // prompt is NOT replaced and the context is NOT reset — "continue"
             // needs the accumulated transcript.
             let planContinue = null;
-            if (skill === 'abap-plan' && planResume === null && session.plan_in_flight) {
-                const marker = session.plan_in_flight;
+            const marker = planContinuationMarker(session, skill, planResume);
+            if (marker) {
                 const { preparePlanContinuation } = await import('./commands/plan-continue.js');
                 const r = await preparePlanContinuation({
                     marker,
@@ -3397,7 +3403,11 @@ export async function runRepl(opts) {
             session.todos = []; // P2 — /new clears the plan (spec §4)
             clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
             clearJourneyFlow(session); // Task 3 — and a clean-core journey
-            console.log((laneSetting === 'chat' ? formatInfo('Fresh start.') : formatInfo('Fresh start · the next prompt picks a skill again')).trimEnd());
+            // 2026-10-22 — and the conversation history: the next prompt sends none of it.
+            startFreshConversation(session);
+            idleKeepalive.disarm(); // no idle cache ping for the old history
+            await saveSession(session);
+            console.log(formatInfo(freshStartText(laneSetting)).trimEnd());
             continue;
         }
         // /chat [on|off] — classic mirror of the Ink handler above.
@@ -3990,8 +4000,8 @@ export async function runRepl(opts) {
         // of the Ink branch; see there for the full design note: mutually
         // exclusive with --resume, prompt NOT replaced, context NOT reset).
         let planContinue = null;
-        if (skill === 'abap-plan' && planResume === null && session.plan_in_flight) {
-            const marker = session.plan_in_flight;
+        const marker = planContinuationMarker(session, skill, planResume);
+        if (marker) {
             const { preparePlanContinuation } = await import('./commands/plan-continue.js');
             const r = await preparePlanContinuation({
                 marker,

package/dist/session/fresh-start.js

@@ -0,0 +1,15 @@
+export function startFreshConversation(session) {
+    session.messages = [];
+    session.turnInterrupted = false;
+    session.turnInterruptedReason = undefined;
+    delete session.last_context_tokens;
+    delete session.lastAutoCompactTurn;
+    // An open plan step does not survive: "continue" must not resume it.
+    session.plan_in_flight = null;
+}
+/** The one line /new prints. */
+export function freshStartText(lane) {
+    return lane === 'chat'
+        ? 'Fresh start · the conversation is cleared.'
+        : 'Fresh start · the conversation is cleared · the next prompt picks a skill again';
+}