@cspeach/cli 1.1.48 → 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/level.js

@@ -26,7 +26,7 @@ export function parseLevel(raw) {
 export const LEVEL_INVARIANT = `The level changes how much you explain, never what you found: findings, numbers, object names, warnings, risks, approvals, plan and safety prompts stay exact. It does not change what this person is allowed to do in SAP.`;
 export const LEVEL_SENTENCES = Object.freeze({
     learning: 'You\'re talking to a developer who is still building experience. Explain the why, not just the what. The first time a technical term comes up, say in a few words what it means. When you show a fix, point out the pattern behind it so they can use it again. Stay encouraging and concrete; never talk down. Just before you ask them to approve anything or answer a yes/no question, say in one or two plain sentences what will happen, what could go wrong and how it can be undone, then ask. Keep it short; don\'t lecture.',
-    functional: 'You\'re talking to someone who knows SAP and the business process well but is not a developer. Start with what it means for the business: which documents, amounts, users or reports are affected. Avoid code and technical terms unless they are needed; when one is needed, explain it in plain words. Show code only when they ask for it. When a code change is needed, don\'t hand it to a workflow: write a developer request to the project folder as cspeach-out/developer-request-<object-or-topic>.md (if that name is taken, add -2, -3 and so on) with the sections Summary, What we found, Proposed change, How to test and Open questions, written so a developer can act on it without asking anything; then tell them where it is and that a developer can open it in CSPeach and continue from it. Hand off to a workflow only if they clearly ask to make the change themselves. Just before you ask them to approve anything or answer a yes/no question, say in one or two plain sentences what will happen, what could go wrong and how it can be undone, then ask. Keep it short; don\'t lecture.',
+    functional: 'You\'re talking to a developer who wants the business view first. Start with what it means for the business: which documents, amounts, users or reports are affected. Avoid technical terms unless they are needed; when one is needed, explain it in plain words. Show code only when they ask for it. If they ask you to write it up for a developer, write cspeach-out/developer-request-<object-or-topic>.md (if that name is taken, add -2, -3 and so on) with the sections Summary, What we found, Proposed change, How to test and Open questions. Just before you ask them to approve anything or answer a yes/no question, say in one or two plain sentences what will happen, what could go wrong and how it can be undone, then ask. Keep it short; don\'t lecture.',
 });
 // ---- pinned: level text composition ----
 /** The text appended under a "Who you're talking to" heading; null for developer (today's behaviour). */

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';
@@ -72,6 +74,7 @@ import { loadWatchdogConfig, evaluateWatchdog } from './turn-watchdog.js';
 import { maybeBuildProjectContext } from './maybe-build-project-context.js';
 import { buildSapConnectionContext } from './sap-connection-adapter.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
+import { projectTransport } from '../register/project-transport.js';
 import { collectTurnAssistantText } from './turn-assistant-text.js';
 import { checkAndMark, newGuardState } from './parallel-write-guard.js';
 import { userPromptText } from '../session/user-prompt.js';
@@ -116,12 +119,10 @@ const SAVE_HOOK_SKILLS = new Set([
     'abap-upgrade-fix',
     'abap-upgrade-verify',
     'abap-upgrade-merge',
-    // 2026-05-09: CCA pipeline manifest envelopes. /abap-cca-merge produces
-    // a consolidated cca-assessment from N parallel consultant slices.
     // 2026-10-06: the thin /abap-cca (1.1.31) reads the estate inventory and
     // writes no envelope, so it is no longer a save-hook skill. An old
     // cca-manifest in a turn is still offered through detectArtifactSkill.
-    'abap-cca-merge',
+    // 2026-10-20: /abap-cca-merge cut (drift spec §3.6); its name aliases to abap-cca.
     // 2026-05-10: v0.7 trio chain. /abap-modernize emits modernize-result;
     // /abap-test emits test-coverage. Both accept cca-assessment via --from
     // and can fan out into further chains after their own envelope saves.
@@ -408,7 +409,7 @@ export async function maybeOfferSave(p) {
     // the output carried a complete csforge:plan-manifest block. The label
     // stays the primary trigger — it is authoritative for prose-extracted
     // artefacts with no inline marker (spec-gap / design / estimate) and keeps
-    // merge-skill provenance exact (abap-cca-merge saves as abap-cca-merge).
+    // merge-skill provenance exact (abap-upgrade-merge saves as abap-upgrade-merge).
     // When the label would NOT fire, a recognizable manifest block in the
     // output resolves the registry skill instead (detectArtifactSkill), so a
     // misroute can no longer silently lose the artifact.
@@ -655,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.
@@ -925,6 +960,8 @@ ${imageExpansion.error}`));
         const sapConnection = params.ctx.sapAlias
             ? buildSapConnectionContext(params.ctx.sapAlias, sapSystemInfo, {
                 currentTransport: getCurrentTransport() ?? null,
+                // Task 6 (project view): the project request of this folder; null outside a project.
+                projectTransport: projectTransport(params.ctx.cwd),
             })
             : null;
         projectContextBlock = await maybeBuildProjectContext({
@@ -1106,7 +1143,7 @@ ${imageExpansion.error}`));
     session.turn_seq = (session.turn_seq ?? Math.max(turnNumber - 1, session.lastAutoCompactTurn ?? 0)) + 1;
     // Snapshot session.messages.length at turn start so the save hook can
     // walk every assistant message added during this turn — not just the
-    // final one. Skills like /abap-cca-merge emit their manifest in an early
+    // final one. Skills like /abap-upgrade-merge emit their manifest in an early
     // message before a closing ask_question widget; the final wrap-up
     // message ends the turn but doesn't carry the manifest. See
     // ./turn-assistant-text.ts for the full rationale.
@@ -1408,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;
@@ -1658,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.
@@ -1804,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
@@ -1830,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);
@@ -1869,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)
@@ -1932,7 +2012,7 @@ ${imageExpansion.error}`));
             // a background block on the next REPL prompt.
             //
             // 2026-05-12: collect text from ALL assistant messages added during
-            // this turn, not just the final one. Skills like /abap-cca-merge emit
+            // this turn, not just the final one. Skills like /abap-upgrade-merge emit
             // their manifest in an early message before a closing ask_question
             // widget; the final wrap-up message ends the turn but doesn't
             // carry the manifest. See ./turn-assistant-text.ts for details.
@@ -2433,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/sap-connection-adapter.js

@@ -34,6 +34,8 @@ export function buildSapConnectionContext(alias, systemInfo, state = {}) {
         alias,
         system: toSummary(systemInfo),
         currentTransport: state.currentTransport ?? null,
+        // Only in a project folder: a context without one stays as it was, key for key.
+        ...(state.projectTransport ? { projectTransport: state.projectTransport } : {}),
         activeScope: toActiveScope(state),
         recentObjects: state.recentObjects ?? [],
     };

package/dist/agent/system-prompt.js

@@ -47,7 +47,7 @@ export function buildReaderSystemPrompt(opts) {
  * Chat lane (spec 2026-10-17 D3) — one block, the pinned chat prompt, as the
  * proxy sends it for the `_chat` skill header. The coding-workflow preamble is
  * NOT sent on chat turns. A non-professional style is appended to that block;
- * a non-developer level (§10 D14) follows the style text.
+ * a non-default level (§10 D14) follows the style text.
  */
 export function buildChatSystemPrompt(opts, style = DEFAULT_STYLE, level = DEFAULT_LEVEL) {
     const marker = opts.cacheMarkers ? { cache_control: { type: 'ephemeral' } } : {};
@@ -62,7 +62,7 @@ export function buildChatSystemPrompt(opts, style = DEFAULT_STYLE, level = DEFAU
  * has no SKILL.md, so it never reaches the skill source (a lookup would fail);
  * nor does the built-in `_chat` (D3). A non-professional `style` (D9) is
  * appended to the END of the last block — professional changes nothing, and a
- * reader (which reports facts) never gets style. A non-developer `level`
+ * reader (which reports facts) never gets style. A non-default `level`
  * (§10 D14) follows the style text; developer changes nothing; a reader never
  * gets it.
  */

package/dist/agent/tool-dispatch.js

@@ -21,17 +21,24 @@ export const CHAT_UNIT_TEST_REASON = 'This chat reads but never runs code on SAP
 export const CHAT_DISPATCH_SKILL_REASON = 'In this chat, dispatch_skill is not available. To start a guided workflow, call hand_off with the workflow name and a clear request.';
 /** A call carrying an approval_id in chat — approvals belong to workflows, never to chat. */
 export const CHAT_APPROVAL_ID_REASON = 'This chat never uses an approval. To make this change, call hand_off with the right workflow and a clear request — the workflow asks before it writes.';
+/**
+ * team_lane_move in chat (Task 4, 2026-10-20) — listed like every tool, refused
+ * here. Moving packages between people is a lead's decision with its own card;
+ * in chat the lead is given the command instead.
+ */
+export const CHAT_LANE_MOVE_REASON = 'In this chat, packages are not moved between people. The lead runs: cspeach team lane move --packages <names> --to <name> --reason "<why>"';
 /**
  * Tools refused in chat beyond the generic rule: the two smokes write SAP
  * data over OData although requiresSap is false; sap_run_unit_test runs code
  * that can COMMIT; dispatch_skill could queue any slash command (hand_off is
- * chat's switch, D5).
+ * chat's switch, D5); team_lane_move writes the team project's lanes (Task 4).
  */
 const CHAT_EXTRA_REFUSED = new Map([
     ['fiori_draft_smoke', CHAT_READ_ONLY_REASON],
     ['cap_link_smoke', CHAT_READ_ONLY_REASON],
     ['sap_run_unit_test', CHAT_UNIT_TEST_REASON],
     ['dispatch_skill', CHAT_DISPATCH_SKILL_REASON],
+    ['team_lane_move', CHAT_LANE_MOVE_REASON],
 ]);
 /**
  * Chat lane refusal set (D-F): WRITE_TOOLS ∪ {request_approval} ∪ every tool
@@ -256,6 +263,11 @@ function declined(r) {
 export function isLocalProjectWork(tool, args) {
     if (tool.category === 'filesystem')
         return true;
+    // Task 4 (2026-10-20) — every project tool writes project files behind its
+    // own card (team_lane_move) or reads only: a second lane move in one turn
+    // never gets a batch card on top of its own card. No project tool reaches SAP.
+    if (tool.category === 'project')
+        return true;
     // 2026-10-02 — fiori_deploy mode "test" (the default) writes nothing to SAP:
     // the backend validates the upload and keeps nothing. Not a batch write, so
     // a deploy phase shows ONE approval (the real deploy's request_approval),

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}`];