@cspeach/cli 1.1.49 → 1.1.51

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/document-save.js

@@ -1,7 +1,8 @@
 // cspeach-cli/src/projects/document-save.ts
 //
-// The save for the two document skills (2026-10-19, owner decision 2026-10-17).
-// A review or a handover is prose, not an envelope: it goes to
+// The save for the document skills (2026-10-19, owner decision 2026-10-17;
+// widened 2026-10-23, Word copy everywhere — see document-skills.ts).
+// A review, a handover, an explanation, … is prose, not an envelope: it goes to
 // <cwd>/cspeach-out/<date>-<kind>-<OBJECT>.md (the folder the model already
 // writes extra copies to; skipped by the @-picker; exempt from the Rule 8
 // card). Then one question, "Word copy too?", unless `word_copy` decides.
@@ -13,8 +14,9 @@ import { askYesNo, isYes } from './yes-no.js';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
 import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
 import { safeFileStem } from '../register/xlsx.js';
-import { DOCUMENT_SKILLS } from './document-skills.js';
-export { DOCUMENT_SKILLS };
+import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from './document-skills.js';
+import { handoverPathFor } from './handover-md.js';
+export { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE };
 export const OUT_DIR = 'cspeach-out';
 export function documentFilename(kind, object, date) {
     const stem = safeFileStem((object ?? 'document').replace(/\//g, ''));
@@ -44,19 +46,74 @@ export async function offerDocumentSave(p) {
         return {};
     }
     p.emit(`Saved: ${path.resolve(mdPath)}`);
+    const docxPath = await offerWordCopy({
+        // Fix round 1 (m-1): the newer document skills' Word copy leaves out HTML comments
+        // (widget markers); review and handover pass their text exactly as before.
+        nextTo: mdPath, markdown: skill.yieldsToArtifact ? p.markdown.replace(/<!--[\s\S]*?-->\s*/g, '') : p.markdown, meta, headless: p.headless, wordCopy: p.wordCopy, confirm: p.confirm, emit: p.emit,
+    });
+    return docxPath ? { mdPath, docxPath } : { mdPath };
+}
+/**
+ * The Word step, shared by every save of a document (Word copy everywhere,
+ * 2026-10-23). `word_copy` decides: unset → ask "Word copy too?", on →
+ * always, off → never. Headless never asks: the copy is written only when
+ * `word_copy` is on. Never overwrites, never throws: a failure is one line.
+ * Returns the .docx path when one was written.
+ */
+export async function offerWordCopy(p) {
     let wantWord = p.wordCopy === 'always';
     if (p.wordCopy === 'ask' && !p.headless) {
         wantWord = isYes(await askYesNo({ question: 'Word copy too?', confirm: p.confirm }));
     }
     if (!wantWord)
-        return { mdPath };
+        return undefined;
     try {
-        const docxPath = await writeDocxNextTo(mdPath, p.markdown, meta);
+        const docxPath = await writeDocxNextTo(p.nextTo, p.markdown, p.meta);
         p.emit(`Word copy: ${path.resolve(docxPath)}`);
-        return { mdPath, docxPath };
+        return docxPath;
     }
     catch (e) {
         p.emit(`Word copy not written. ${e.message}`);
-        return { mdPath };
+        return undefined;
+    }
+}
+/** Artefact blocks (`<!-- cspeach:…-manifest … -->`, legacy `csforge:` too) are for CSPeach, not for the reader. */
+const ARTIFACT_BLOCK_RE = /<!--\s*(?:csforge|cspeach):[\w-]+\s*\n[\s\S]*?-->\s*/g;
+/** The YAML header at the top of a plan's handover Markdown. */
+const FRONT_MATTER_RE = /^---\r?\n[\s\S]*?\r?\n---\r?\n/;
+/** The text a person reads: no artefact blocks; the YAML header only for a plan handover (final-review m-3). */
+export function readerMarkdown(markdown, frontMatter = true) {
+    return (frontMatter ? markdown.replace(FRONT_MATTER_RE, '') : markdown).replace(ARTIFACT_BLOCK_RE, '').trim() + '\n';
+}
+/**
+ * The Word step after an artefact save ("Save as project file?" said Yes).
+ * The project file is the source of truth and is never touched here; the
+ * .docx is a copy for people and is never read back.
+ * - a plan: the copy is made from the plan's handover Markdown, next to it
+ *   (that file is written by the plan save, exactly as before);
+ * - the others: from the answer, into cspeach-out/<date>-<kind>-<OBJECT>.docx.
+ * Skills not in WORD_AFTER_ARTIFACT_SAVE: nothing.
+ */
+export async function offerWordCopyAfterArtifactSave(p) {
+    const kind = WORD_AFTER_ARTIFACT_SAVE[p.saveSkill];
+    if (!kind)
+        return undefined;
+    const handover = kind === 'plan' ? handoverPathFor(p.savedPath) : null;
+    let source = p.markdown;
+    if (handover) {
+        try {
+            source = await fs.promises.readFile(handover, 'utf8');
+        }
+        catch {
+            return undefined; // the plan save already said the handover was not written
+        }
     }
+    const markdown = readerMarkdown(source, handover !== null);
+    if (markdown.trim().length === 0)
+        return undefined;
+    const meta = metaFromMarkdown(markdown, { date: p.today, kind, ...(p.sapSystem ? { system: p.sapSystem } : {}) });
+    const nextTo = handover ?? path.join(p.cwd, OUT_DIR, documentFilename(kind, meta.object, p.today));
+    return offerWordCopy({
+        nextTo, markdown, meta, headless: p.headless, wordCopy: p.wordCopy, confirm: p.confirm, emit: p.emit,
+    });
 }

package/dist/projects/document-skills.js

@@ -1,9 +1,40 @@
 // cspeach-cli/src/projects/document-skills.ts
 //
-// The two document skills, on their own so the agent loop can check a skill
+// The document skills, on their own so the agent loop can check a skill
 // name without loading document-save.ts (and the docx package behind it) on
 // every turn. Type-only import: nothing heavy loads from here.
+//
+// Word copy everywhere (2026-10-23, owner: "add this word feature everywhere"):
+// - DOCUMENT_SKILLS: skills whose answer is a document a person keeps. After
+//   the turn: "Save this <noun> to a file?" (cspeach-out/<date>-<kind>-<OBJECT>.md),
+//   then the Word step. Review and handover were the first two (2026-10-19);
+//   the others join with `yieldsToArtifact`: when their answer carries a
+//   recognizable artefact block (a plan, a clean-core triage, …) the artefact
+//   save runs instead, exactly as before.
+// - WORD_AFTER_ARTIFACT_SAVE: artefact saves (a .cspeach.json project file)
+//   whose answer is also a document. After "Save as project file?" says Yes,
+//   the same Word step runs. The project file and its save do not change.
 export const DOCUMENT_SKILLS = {
     'abap-review': { kind: 'review', noun: 'review' },
     'abap-handover': { kind: 'handover', noun: 'handover' },
+    'abap-explain': { kind: 'explanation', noun: 'explanation', yieldsToArtifact: true },
+    'abap-impact': { kind: 'impact', noun: 'impact analysis', yieldsToArtifact: true },
+    'abap-preflight': { kind: 'preflight', noun: 'preflight check', yieldsToArtifact: true },
+    'abap-transport-analysis': { kind: 'transport-analysis', noun: 'transport analysis', yieldsToArtifact: true },
+    'abap-migrate': { kind: 'migration', noun: 'migration assessment', yieldsToArtifact: true },
+    'abap-clean-core': { kind: 'clean-core', noun: 'clean-core assessment', yieldsToArtifact: true },
+    'abap-cca': { kind: 'custom-code-analysis', noun: 'custom code analysis', yieldsToArtifact: true },
+};
+/**
+ * Artefact saves that also get the Word step (skill name as saved → kind).
+ * A plan's Word copy is made from its handover Markdown (written next to the
+ * plan file); the others from the answer the person read.
+ */
+export const WORD_AFTER_ARTIFACT_SAVE = {
+    'abap-spec-gap': 'spec-gap',
+    'abap-design': 'design',
+    'abap-estimate': 'estimate',
+    'abap-plan': 'plan',
+    'abap-upgrade-scan': 'upgrade-scan',
+    'abap-upgrade-verify': 'upgrade-report',
 };

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/builtin-commands.js

@@ -33,7 +33,7 @@ export const BUILTIN_ENTRIES = [
     { name: '/cost', get description() { return costCommandDescription(); } },
     { name: '/usage', get description() { return usageCommandDescription(); } },
     { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
-    { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy of a saved file (/export docx <file>.md)' },
+    { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy: of the last answer (/export docx, or /export docx <name>), of the whole conversation (/export docx conversation) or of a Markdown file (/export docx <file>.md)' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
     { name: '/quit', description: 'Exit CSPeach (alias)' },

package/dist/repl/slash-completer.js

@@ -25,6 +25,10 @@ const BUILTIN_COMMANDS = [
     '/usage',
     '/context',
     '/export',
+    // 2026-10-23: Tab after `/export ` offers the subcommands.
+    '/export audit',
+    '/export docx',
+    '/export docx conversation',
     '/exit',
     '/quit',
     '/help',

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';
@@ -206,6 +208,17 @@ import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 import './tools/subagent/read_agent.js';
 import { folderTag, currentFolderKey } from './session/project-match.js';
+import { bindCliCardSession } from './session/cli-record.js';
+/** /export docx conversation (2026-10-23) — the origin of a turn CSPeach started itself. */
+async function cliTurnOrigin(planResume, queuedCmd) {
+    if (planResume) {
+        const { planStepOriginLine } = await import('./commands/plan-continue.js');
+        return { userMessageOrigin: { kind: 'plan-step', line: planStepOriginLine(planResume) } };
+    }
+    if (queuedCmd)
+        return { userMessageOrigin: { kind: 'queued', line: `CSPeach ran the next step: ${queuedCmd.trim()}` } };
+    return {};
+}
 const HISTORY_SIZE = 500;
 // Persistence (read + dedup-guarded append) lives in ./repl/history.ts —
 // the single writer shared with the Ink Footer (Task 8, ux-wave1).
@@ -791,6 +804,8 @@ export async function runRepl(opts) {
     // served config), marks it 'predicted', saves, then stays pinned. Every
     // resume entry (picker, --resume <id>) lands here via session/resume.ts.
     const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg), folderTag(process.cwd()));
+    // /export docx conversation — the plan startup, lane and journey cards are recorded on this session.
+    bindCliCardSession(session);
     // Round 6 item 4c — a resumed session keeps its skill for the first plain prompt.
     let resumeKeepsSkill = Boolean(opts?.resumedSession?.skill);
     // Round 7 item 8c — the footer shows a resumed session's spend at once.
@@ -1155,16 +1170,18 @@ export async function runRepl(opts) {
             // session audit record (who did what, where, under which approval, at
             // what cost) to a markdown file in cwd and print the path.
             if (trimmed === '/export' || trimmed.startsWith('/export ')) {
-                const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
-                const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+                const { parseExportArgs, runExportAuditCommand, EXPORT_REPL_USAGE } = await import('./commands/export-audit.js');
+                const { sub, filename, docxArgs } = parseExportArgs(trimmed.slice('/export'.length));
                 // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+                // 2026-10-23: no file → the last answer; `conversation` → the whole conversation.
+                // The Word package loads only here: /export audit never needs it.
                 if (sub === 'docx') {
-                    const { docxFileFromReplArgs, runExportDocxCommand } = await import('./commands/export-docx.js');
-                    await runExportDocxCommand({ file: docxFileFromReplArgs(trimmed.slice('/export'.length)), docx: true, system: session.sap_system, emit: (l) => chunkEmitter.emit('chunk', l + '\n') });
+                    const { runExportDocxRepl } = await import('./commands/export-conversation.js');
+                    await runExportDocxRepl({ args: docxArgs ?? '', session, ...(signedInAs ? { person: signedInAs } : {}), emit: (l) => chunkEmitter.emit('chunk', l + '\n') });
                     return;
                 }
                 if (sub !== 'audit') {
-                    chunkEmitter.emit('chunk', chalk.dim('\nUsage: /export audit [filename] · /export docx <file>.md\n'));
+                    chunkEmitter.emit('chunk', chalk.dim(`\n${EXPORT_REPL_USAGE}\n`));
                     return;
                 }
                 await runExportAuditCommand({
@@ -1376,7 +1393,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 +1946,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,
@@ -2045,6 +2066,8 @@ export async function runRepl(opts) {
                     // turns (their post-turn persist indexes messages from turn start).
                     autoCompact: planResume === null && planContinue === null,
                     delegateSkill: planPhaseDelegate,
+                    // /export docx conversation — a plan step or a queued step is CSPeach's words, not the person's.
+                    ...(await cliTurnOrigin(planResume, submitOpts?.queued ? line : null)),
                     // A4 — undefined on every non-plan turn (and when tiering is off).
                     modelOverride: planModelOverride,
                     // Task 9 — a tier-down, never the session role (proxy must not enforce it).
@@ -3020,6 +3043,8 @@ export async function runRepl(opts) {
     // Task 13 — classic in-run hop flag: set by the loop-top consumer from planHops.take().
     let classicPlanHop = false;
     let classicLineBy = 'person';
+    /** The command CSPeach queued for this line (null when the person typed it). */
+    let classicQueuedCmd = null;
     while (true) {
         // Re-attach the bare-Esc detector every iteration. Inquirer prompts
         // (slash-picker, approval, ask_question, safety-confirm) remove
@@ -3036,6 +3061,7 @@ export async function runRepl(opts) {
         const classicQueued = pendingDispatchAccessor.take();
         // Task 3 — who started this line: the CSPeach source that queued it, else the person.
         classicLineBy = classicQueued?.origin?.by ?? 'person';
+        classicQueuedCmd = classicQueued?.origin ? classicQueued.cmd : null;
         if (classicQueued) {
             const dispatchedCmd = classicQueued.cmd;
             // No context clear here: beginPlanPhaseContext (plan-boundary.ts,
@@ -3191,16 +3217,18 @@ export async function runRepl(opts) {
         // Task 4 (ux-wave3) — classic-mode /export audit [filename]. Mirrors the
         // Ink handler: build the signable audit record, write it to cwd, print path.
         if (trimmed === '/export' || trimmed.startsWith('/export ')) {
-            const { parseExportArgs, runExportAuditCommand } = await import('./commands/export-audit.js');
-            const { sub, filename } = parseExportArgs(trimmed.slice('/export'.length));
+            const { parseExportArgs, runExportAuditCommand, EXPORT_REPL_USAGE } = await import('./commands/export-audit.js');
+            const { sub, filename, docxArgs } = parseExportArgs(trimmed.slice('/export'.length));
             // Word export (2026-10-19): /export docx <file>.md, same body as `cspeach export`.
+            // 2026-10-23: no file → the last answer; `conversation` → the whole conversation.
+            // The Word package loads only here: /export audit never needs it.
             if (sub === 'docx') {
-                const { docxFileFromReplArgs, runExportDocxCommand } = await import('./commands/export-docx.js');
-                await runExportDocxCommand({ file: docxFileFromReplArgs(trimmed.slice('/export'.length)), docx: true, system: session.sap_system, emit: (l) => console.log(l) });
+                const { runExportDocxRepl } = await import('./commands/export-conversation.js');
+                await runExportDocxRepl({ args: docxArgs ?? '', session, ...(signedInAs ? { person: signedInAs } : {}), emit: (l) => console.log(l) });
                 continue;
             }
             if (sub !== 'audit') {
-                console.log(chalk.dim('Usage: /export audit [filename] · /export docx <file>.md'));
+                console.log(chalk.dim(EXPORT_REPL_USAGE));
                 continue;
             }
             await runExportAuditCommand({
@@ -3397,7 +3425,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 +4022,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,
@@ -4123,6 +4155,8 @@ export async function runRepl(opts) {
                 // turns (their post-turn persist indexes messages from turn start).
                 autoCompact: planResume === null && planContinue === null,
                 delegateSkill: planPhaseDelegate,
+                // /export docx conversation — a plan step or a queued step is CSPeach's words, not the person's.
+                ...(await cliTurnOrigin(planResume, classicQueuedCmd)),
                 // A4 — undefined on every non-plan turn (and when tiering is off).
                 modelOverride: planModelOverride,
                 // Task 9 — a tier-down, never the session role (proxy must not enforce it).

package/dist/session/cli-record.js

@@ -0,0 +1,165 @@
+// cspeach-cli/src/session/cli-record.ts
+//
+// /export docx conversation, fix round 1 (2026-10-23). Two small records kept
+// on the session for the conversation export, NEVER sent to the model:
+//
+// - cli_messages: which user-role messages CSPeach wrote itself (a plan step
+//   prompt, the output-limit continuation, the watchdog note, a /compact or
+//   plan-boundary summary, a queued next step, a mid-turn steer). Each entry is
+//   the sha of the message content, not an index: compaction drops and moves
+//   messages, a content hash still finds the same message. The messages
+//   themselves are untouched, so every model request stays byte-identical.
+// - cli_cards: the CLI's own cards that matter for a change ticket (the plan
+//   gate "Build this now?", the plan startup "Continue", the lane card, the
+//   journey cards), anchored by turn_seq. Never the save or Word cards.
+//
+// Both are optional session fields. A session file is JSON.parse'd and written
+// whole (store.ts), so an older CLI that resumes the file keeps them as they are.
+import crypto from 'node:crypto';
+export const CLI_RECORD_CAP = 500;
+export const CONTINUE_LINE = 'CSPeach asked the model to continue a long answer.';
+export const WATCHDOG_LINE = 'CSPeach asked the model to wrap up a long turn.';
+export const COMPACT_LINE = 'Earlier turns were summarised to keep the session small.';
+export const PLAN_BOUNDARY_LINE = 'CSPeach summarised the earlier plan steps.';
+function shaOf(content) {
+    return crypto.createHash('sha256').update(typeof content === 'string' ? content : JSON.stringify(content ?? null)).digest('hex').slice(0, 32);
+}
+function capped(list) {
+    return list.length > CLI_RECORD_CAP ? list.slice(list.length - CLI_RECORD_CAP) : list;
+}
+/** Note that CSPeach wrote this user-role message. Never throws. */
+export function markCliMessage(session, content, kind, line) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        s.cli_messages = capped([...(s.cli_messages ?? []), { sha: shaOf(content), kind, line }]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/**
+ * Fixed-shape CLI texts, for sessions written before the record existed (or
+ * a mark the cap dropped). Prefixes only; the bodies are CSPeach's own words.
+ */
+const KNOWN_PREFIXES = [
+    { prefix: 'Resume execution of the project plan', kind: 'plan-step', line: 'CSPeach ran the next plan step.' },
+    { prefix: 'Your previous response was cut off at the output-token limit.', kind: 'continue', line: CONTINUE_LINE },
+    { prefix: '[CSPeach watchdog]', kind: 'watchdog', line: WATCHDOG_LINE },
+    { prefix: '[Context summary auto-generated', kind: 'compact', line: COMPACT_LINE },
+    { prefix: '[Summary of the earlier steps of this plan', kind: 'plan-boundary', line: PLAN_BOUNDARY_LINE },
+];
+function prefixMark(message) {
+    const text = typeof message.content === 'string' ? message.content
+        : Array.isArray(message.content) ? message.content.filter((b) => b?.type === 'text').map((b) => String(b.text ?? '')).join('\n') : '';
+    const t = text.trimStart();
+    const known = KNOWN_PREFIXES.find((k) => t.startsWith(k.prefix));
+    return known ? { sha: '', kind: known.kind, line: known.line } : undefined;
+}
+/**
+ * The mark of each message (undefined for the developer's own words), in
+ * message order. Fix round 2 (m-8): each mark is used once, in order — a
+ * message takes the first unused mark at or after the last one used that has
+ * its sha. So a command the developer retypes after CSPeach queued it, or a
+ * typed "continue" equal to an earlier steer, stays the developer's: that mark
+ * is already used. Marks of messages a compaction dropped are simply passed
+ * over. The prefix fallback is only for sessions with no records at all.
+ */
+export function resolveCliMarks(session, messages) {
+    const marks = session?.cli_messages;
+    if (!marks || marks.length === 0)
+        return messages.map((m) => (m.role === 'user' ? prefixMark(m) : undefined));
+    // Final-review fix (I-1): used once, any order. Look from the last mark used
+    // on; when nothing matches there, look again from the start (a file an older
+    // CLI compacted has the summary's mark last). A used mark is never reused.
+    const used = new Set();
+    let next = 0;
+    return messages.map((m) => {
+        if (m.role !== 'user')
+            return undefined;
+        const sha = shaOf(m.content);
+        const at = (from, to) => {
+            for (let j = from; j < to; j++)
+                if (!used.has(j) && marks[j].sha === sha)
+                    return j;
+            return -1;
+        };
+        let j = at(next, marks.length);
+        if (j < 0)
+            j = at(0, Math.min(next, marks.length));
+        if (j < 0)
+            return undefined;
+        used.add(j);
+        next = j + 1;
+        return marks[j];
+    });
+}
+/**
+ * Final-review fix (I-1): after a compaction keeps `kept` (the tail of the old
+ * messages, from index `keepFrom`) behind a new summary message, rebuild the
+ * record in message order: the summary's mark first, then the marks of the
+ * kept messages (recomputed from their content, so a mark found by the prefix
+ * fallback in an older file becomes a real one). Marks of dropped messages go.
+ */
+export function rebuildCliMarksAfterCompact(session, oldMessages, keepFrom, summaryContent, summary) {
+    try {
+        const resolved = resolveCliMarks(session, oldMessages);
+        const kept = [];
+        for (let i = keepFrom; i < oldMessages.length; i++) {
+            const m = resolved[i];
+            if (m)
+                kept.push({ sha: shaOf(oldMessages[i].content), kind: m.kind, line: m.line });
+        }
+        session.cli_messages = capped([{ sha: shaOf(summaryContent), kind: summary.kind, line: summary.line }, ...kept]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/** A turn of its own (the developer's prompt, a plan step, a queued step) vs. a message inside a turn. */
+export function startsTurn(mark) {
+    return !mark || mark.kind === 'plan-step' || mark.kind === 'queued';
+}
+/* ── cards ────────────────────────────────────────────────────────────── */
+let bound = null;
+/** The REPL (and each top-level turn) binds the session the cards belong to. */
+export function bindCliCardSession(session) { bound = session; }
+/**
+ * The card ids the card slot records for the export: plan startup, lane,
+ * journey. Never save or Word cards. "Build this now?" (app-start-build) is
+ * recorded by afterPlanSave itself, which knows the plan file and whether the
+ * object-list approval was installed (fix round 2, N-1).
+ */
+export function isRecordedCard(id) {
+    return id === 'plan-continue' || id === 'app-lane' || id === 'app-lane-runtime' || id.startsWith('journey-');
+}
+/** Record one card on the bound session (or the one given), with the time. Never throws. */
+export function recordCliCard(card, session = bound) {
+    if (!session)
+        return;
+    try {
+        const s = session;
+        const entry = { turn_seq: s.turn_seq ?? 0, at: new Date().toISOString(), ...card };
+        s.cli_cards = capped([...(s.cli_cards ?? []), entry]);
+    }
+    catch { /* the record is best-effort */ }
+}
+/* ── once-per-object document offers ──────────────────────────────────── */
+/**
+ * Per session (in memory): the (skill, object) keys the newer document skills
+ * already offered "Save…?" for. Kept here, beside the records, so /new can
+ * clear it (final-review m-4).
+ */
+const documentOffers = new WeakMap();
+export function documentOffersFor(session) {
+    let s = documentOffers.get(session);
+    if (!s) {
+        s = new Set();
+        documentOffers.set(session, s);
+    }
+    return s;
+}
+/** /new: the once-per-object offers and the records of the cleared conversation go too. */
+export function clearConversationRecords(session) {
+    documentOffers.delete(session);
+    const s = session;
+    delete s.cli_messages;
+    delete s.cli_cards;
+}

package/dist/session/fresh-start.js

@@ -0,0 +1,19 @@
+import { clearConversationRecords } from './cli-record.js';
+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;
+    // Word export (final-review m-4): the once-per-object save offers and the
+    // export records describe the cleared conversation; they go with it.
+    clearConversationRecords(session);
+}
+/** 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';
+}

package/dist/tools/_filesystem-shared.js

@@ -45,6 +45,13 @@ export const BLOCKED_BASENAME_RE = /^\.env(\.|$)/i;
  * (skill detail files) — only the rest of `.cspeach/` is blocked.
  */
 export const DENYLIST_DESCRIPTION = [...BLOCKED_PREFIXES, '.env*'].join(', ');
+/**
+ * The paging trailer of file_read and read_document (also refused in SAP
+ * writes: tools/cut-markers.ts).
+ */
+export function rereadTrailer(more, nextOffset) {
+    return `... (truncated, ${more} more lines — re-read with offset=${nextOffset})`;
+}
 /**
  * Executable / script file extensions the filesystem write tools refuse to
  * create. Defense-in-depth: shell_exec / background_run only run a safelisted