@cspeach/cli 1.1.49 → 1.1.51

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';
@@ -43,7 +45,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';
@@ -371,6 +375,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;
@@ -381,7 +448,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();
@@ -393,7 +479,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) {
@@ -469,6 +555,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.
@@ -654,6 +747,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.
@@ -952,6 +1079,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)
@@ -1160,6 +1293,7 @@ ${imageExpansion.error}`));
             if (steers.length > 0) {
                 const text = steers.join('\n');
                 session.messages.push({ role: 'user', content: text });
+                markCliMessage(session, text, 'steer', '');
                 if (roundIndex === 0)
                     round0Steers = steers;
                 emit(chalk.cyan(`↳ steering: ${steers.join(' / ')}`));
@@ -1409,6 +1543,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 +1801,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 +1956,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 +1994,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 +2035,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)
@@ -1963,6 +2140,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 } : {}),
                         ...(() => {
@@ -2116,6 +2296,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) {
@@ -2434,10 +2615,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,
                 });
             }
@@ -2465,6 +2648,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);
             }
         }

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/cli.js

@@ -308,7 +308,7 @@ Usage:
   cspeach                           Start interactive REPL
   cspeach "<prompt>"                One-shot — runs one turn and exits
   cspeach --one-shot "<prompt>"     Same as above, explicit flag
-  cspeach export <file>.md --docx   Write a Word copy next to a saved review or handover
+  cspeach export <file>.md --docx   Write a Word copy next to a Markdown file
   cspeach --sap-alias <name>        Use a specific SAP alias (overrides default)
   cspeach --no-sap                  Start without a SAP system (paste-mode skills only)
   cspeach --continue, -c            Continue the latest session in this folder

package/dist/commands/compact.js

@@ -33,6 +33,7 @@ import { paint } from '../renderer/theme.js';
 import { getGlyphs } from '../renderer/glyphs.js';
 import { saveSession } from '../session/store.js';
 import { isUserPrompt } from '../session/user-prompt.js';
+import { rebuildCliMarksAfterCompact, COMPACT_LINE } from '../session/cli-record.js';
 import { getActiveDeployments } from '../models/model-identity.js';
 /** Keep this many recent user-prompt anchored turns verbatim. */
 export const KEEP_RECENT_TURNS = 5;
@@ -305,7 +306,12 @@ export async function runCompact(opts) {
     // that produced it). The summary changed them, so the kept tail goes out
     // without thinking; text and tool calls stay. The backup above keeps all.
     const kept = plan.toKeep.map(stripThinking);
+    const oldMessages = session.messages;
     session.messages = [summaryMsg, ...kept];
+    // /export docx conversation: the summary is CSPeach's, not the developer's
+    // (one plain line there). The record is rebuilt in message order so the kept
+    // plan steps, continuations and steers keep their marks (final-review I-1).
+    rebuildCliMarksAfterCompact(session, oldMessages, plan.cutAt, summaryMsg.content, { kind: 'compact', line: COMPACT_LINE });
     // Task 19 — the recorded context size described the old history; the next
     // call records the new one. Clearing it keeps the auto-compact gate honest.
     delete session.last_context_tokens;