@cspeach/cli 1.1.49 → 1.1.51

package/dist/commands/config-set.js

@@ -616,7 +616,7 @@ export async function runConfigSet(args) {
             if (b === null)
                 err(`${key} must be on/off (also accepts true/false, 1/0).`);
             cfg.word_copy = b;
-            console.log(chalk.dim(b ? '  → a Word copy is written with every saved review or handover.' : '  → CSPeach will not ask about Word copies.'));
+            console.log(chalk.dim(b ? '  → a Word copy is written with every document CSPeach saves.' : '  → CSPeach will not ask about Word copies.'));
             break;
         }
         case 'write_mode':

package/dist/commands/export-audit.js

@@ -17,10 +17,33 @@ import path from 'node:path';
 import { buildAuditReport } from '../session/audit-export.js';
 import { globalCredits } from '../cost/credits.js';
 import { readCostLog } from '../cost/cost-log.js';
-/** Parse the text after `/export` into a subcommand + optional filename. */
+/**
+ * The /export usage line (2026-10-23). Here, in the light audit module both
+ * REPL handlers already load, so `/export audit` and a mistyped `/export`
+ * never load the Word package (final-review I-2).
+ */
+export const EXPORT_REPL_USAGE = 'Usage: /export docx (the last answer to Word) · /export docx <name> · /export docx conversation · /export audit [file]';
+/**
+ * Parse the text after `/export` into a subcommand + optional filename.
+ *
+ * 2026-10-23 (a customer's screenshot): the Word forms people actually type
+ * all mean "Word": `/export docx x.docx`, `/export x.md --docx`,
+ * `/export x.docx`, `/export conversation`, `/export word`. A `--docx` or
+ * `--word` flag anywhere is dropped. For sub 'docx', `docxArgs` is the line
+ * to hand to runExportDocxRepl (" docx <rest>").
+ */
 export function parseExportArgs(rest) {
-    const parts = rest.trim().split(/\s+/).filter(Boolean);
-    return { sub: (parts[0] ?? '').toLowerCase(), filename: parts[1] };
+    let flag = false;
+    const cleaned = rest.replace(/(^|\s)--(?:docx|word)(?=\s|$)/gi, () => { flag = true; return ' '; }).trim();
+    const parts = cleaned.split(/\s+/).filter(Boolean);
+    const first = (parts[0] ?? '').toLowerCase();
+    if (first === 'docx' || first === 'word') {
+        return { sub: 'docx', docxArgs: ` docx ${cleaned.slice(parts[0].length).trim()}`.trimEnd() };
+    }
+    if (first !== 'audit' && (flag || first === 'conversation' || /\.(?:md|docx)["']?$/i.test(cleaned))) {
+        return { sub: 'docx', docxArgs: ` docx ${cleaned}`.trimEnd() };
+    }
+    return { sub: first, filename: parts[1] };
 }
 /** Deterministic default filename: date from session data, not now(). */
 export function defaultAuditFilename(session) {

package/dist/commands/export-conversation.js

@@ -0,0 +1,343 @@
+// cspeach-cli/src/commands/export-conversation.ts
+//
+// /export docx (2026-10-23, from a customer's own words): turn what he sees in
+// the terminal into a Word document at any point, to attach to the change
+// ticket.
+//
+//   /export docx               the last answer CSPeach gave
+//   /export docx conversation  the whole conversation so far: the developer's
+//                              messages, CSPeach's answers, and every question
+//                              CSPeach asked (ask_question, approvals) with the
+//                              options shown and the answer picked
+//   /export docx <file>.md     unchanged (export-docx.ts)
+//
+// Reads only what is already in the session: no model call, no SAP call.
+// Raw tool results are never written (a source body read from SAP stays out);
+// only the answers to questions are taken from them. Files go to
+// cspeach-out/ (never overwritten), the .docx next to the .md.
+import fs from 'node:fs';
+import path from 'node:path';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
+import { normalizeAskInput } from '../tools/ask-question.js';
+import { isUserPrompt, userPromptText } from '../session/user-prompt.js';
+import { resolveCliMarks, startsTurn } from '../session/cli-record.js';
+import { docxFileFromReplArgs, runExportDocxCommand } from './export-docx.js';
+// The usage line lives in the light export-audit module (final-review I-2); re-exported here.
+export { EXPORT_REPL_USAGE } from './export-audit.js';
+const OUT_DIR = 'cspeach-out';
+/** HTML comments are machine blocks (artefact manifests, widget markers): the terminal never shows them. */
+function readerText(text) {
+    return text.replace(/<!--[\s\S]*?-->/g, '').replace(/\n{3,}/g, '\n\n').trim();
+}
+/** Context blocks the CLI adds to a prompt; the developer never typed them. */
+const INJECTED_TAGS = ['session_context', 'project_context', 'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection'];
+function typedText(text) {
+    let out = text;
+    for (const tag of INJECTED_TAGS) {
+        out = out.replace(new RegExp(`<${tag}(?:\\s[^>]*)?>[\\s\\S]*?</${tag}>`, 'g'), '');
+    }
+    out = out.replace(/<attached file="([^"]*)">[\s\S]*?<\/attached>/g, (_m, f) => `@${f}`);
+    return out.trim();
+}
+function blocks(m) {
+    return Array.isArray(m.content) ? m.content : [];
+}
+function assistantTexts(m) {
+    if (m.role !== 'assistant')
+        return [];
+    if (typeof m.content === 'string')
+        return [m.content];
+    return blocks(m).filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text);
+}
+/** Indexes of the messages that start a turn: a typed prompt, a plan step, a queued step (fix round 1, I-1/I-2). */
+function turnStarts(messages, session) {
+    const out = [];
+    const marks = resolveCliMarks(session, messages);
+    messages.forEach((m, i) => { if (isUserPrompt(m) && startsTurn(marks[i]))
+        out.push(i); });
+    return out;
+}
+/**
+ * The last answer: everything CSPeach said after the last turn's prompt. A
+ * continuation after the output limit, a watchdog note or a mid-turn steer is
+ * not a new turn, so a long answer comes out whole. `turn` = session.turn_seq
+ * when the session has it (right after a compaction too), else the count.
+ */
+export function lastAnswer(messages, session) {
+    const starts = turnStarts(messages, session);
+    if (starts.length === 0)
+        return null;
+    const last = starts[starts.length - 1];
+    const turn = session?.turn_seq ?? starts.length;
+    const text = readerText(messages.slice(last + 1).flatMap(assistantTexts).join('\n\n'));
+    return text.length > 0 ? { text: text + '\n', turn } : null;
+}
+/** tool_use_id → the result's text (only read for questions and approvals). */
+function resultsById(messages) {
+    const out = new Map();
+    for (const m of messages) {
+        if (m.role !== 'user')
+            continue;
+        for (const b of blocks(m)) {
+            if (b?.type !== 'tool_result' || typeof b.tool_use_id !== 'string')
+                continue;
+            const c = b.content;
+            const text = typeof c === 'string' ? c
+                : Array.isArray(c) ? c.filter((x) => x?.type === 'text').map((x) => String(x.text ?? '')).join('') : '';
+            out.set(b.tool_use_id, text);
+        }
+    }
+    return out;
+}
+function parse(json) {
+    if (json === undefined)
+        return undefined;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+const quote = (lines) => lines.map((l) => (l.length ? `> ${l}` : '>')).join('\n');
+/** One question (or a form of up to four) with its options and the answer picked. */
+function questionBlock(input, result) {
+    let form;
+    try {
+        form = normalizeAskInput(input);
+    }
+    catch {
+        return null;
+    }
+    const r = parse(result);
+    const answers = [];
+    if (r && Array.isArray(r.answers)) {
+        for (const a of r.answers)
+            answers.push({ id: String(a?.id), answer: a?.answer == null ? null : String(a.answer), auto: a?.auto_answered === true });
+    }
+    else if (r && 'answer' in r) {
+        answers.push({ id: String(r.id ?? form.questions[0]?.id), answer: r.answer == null ? null : String(r.answer), auto: r.auto_answered === true });
+    }
+    const out = [];
+    for (const q of form.questions) {
+        out.push(`**CSPeach asked:** ${q.question}`);
+        if (q.options.length)
+            out.push(`Options: ${q.options.map((o) => o.label).join(' · ')}`);
+        const a = answers.find((x) => x.id === q.id) ?? (form.questions.length === 1 ? answers[0] : undefined);
+        if (a && a.answer !== null && a.answer.length > 0) {
+            const shown = q.options.length && !q.freeText
+                ? a.answer.split(',').map((v) => q.options.find((o) => o.value === v)?.label ?? v).join(', ')
+                : a.answer;
+            out.push(a.auto ? `**Answer (picked automatically, no one answered):** ${shown}` : `**Answer:** ${shown}`);
+        }
+        else if (r?.error === 'headless_unanswerable' || r?.error === undefined && r?.headless) {
+            out.push('**Answer:** none (no one was there to answer)');
+        }
+        else if (r?.cancelled) {
+            out.push('**Answer:** none (the question was closed)');
+        }
+        else {
+            out.push('**Answer:** not recorded');
+        }
+        out.push('');
+    }
+    return quote(out.slice(0, -1));
+}
+/** An approval CSPeach asked for: the summary, the changes (never the diff), the answer. */
+function approvalBlock(input, result) {
+    const r = parse(result);
+    if (!r || r.error)
+        return null; // refused before anything was shown: no question was asked
+    const out = [`**CSPeach asked for approval:** ${String(input?.summary ?? 'a change')}`];
+    for (const c of Array.isArray(input?.changes) ? input.changes : []) {
+        out.push(`- ${String(c?.op ?? '')} ${String(c?.object ?? '')}${c?.type ? ` (${String(c.type)})` : ''}`.replace(/\s+/g, ' ').trimEnd());
+    }
+    let answer;
+    if (typeof r.advisory_outcome === 'string') {
+        answer = r.headless ? '**Answer (no one answered):** not applied'
+            : `**Answer:** ${r.advisory_outcome === 'applied' ? 'applied by hand' : r.advisory_outcome === 'aborted' ? 'stopped' : 'skipped'}`;
+    }
+    else if (r.auto_approved) {
+        answer = '**Answer (approved automatically, auto-approve is on):** Approved';
+    }
+    else if (typeof r.approved_by === 'string') {
+        answer = `**Answer (approved earlier, by ${r.approved_by}):** Approved`;
+    }
+    else if (r.reason === 'headless_no_approval') {
+        answer = '**Answer (no one answered):** Not approved';
+    }
+    else if (r.reason === 'plan_rejected') {
+        answer = '**Answer:** Cancelled at the plan gate';
+    }
+    else if (r.reason === 'user_cancelled_turn') {
+        answer = '**Answer:** Stopped';
+    }
+    else if (r.approved === true) {
+        const skipped = Array.isArray(r.skipped) ? r.skipped.map((s) => String(s?.object ?? '')).filter(Boolean) : [];
+        answer = skipped.length ? `**Answer:** Approved, except ${skipped.join(', ')} (skipped)` : '**Answer:** Approved';
+    }
+    else {
+        answer = '**Answer:** Not approved';
+    }
+    out.push(answer);
+    return quote(out);
+}
+/** One CLI card: the question, what it showed, the options and the answer. */
+function cardBlock(c) {
+    const out = [`**CSPeach asked:** ${c.question}`];
+    // Fix round 2 (N-1): when it was answered (UTC, to the minute) and which plan it was about.
+    const when = c.at && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(c.at) ? `At: ${c.at.slice(0, 10)} ${c.at.slice(11, 16)} UTC` : '';
+    const about = c.ref ? `Plan: ${c.ref}` : '';
+    if (when || about)
+        out.push([when, about].filter(Boolean).join(' · '));
+    for (const f of c.facts ?? [])
+        out.push(`- ${f}`);
+    if (c.options?.length)
+        out.push(`Options: ${c.options.join(' · ')}`);
+    out.push(c.by === 'user' ? `**Answer:** ${c.answer}`
+        : c.by === 'auto' ? `**Answer (picked automatically):** ${c.answer}`
+            : `**Answer (no one at the terminal):** ${c.answer}`);
+    return quote(out);
+}
+/** The whole conversation, in order. Pure: the same session always gives the same text. */
+export function conversationMarkdown(o) {
+    const results = resultsById(o.messages);
+    const parts = [
+        '# CSPeach conversation', '',
+        `- Date: ${o.date}`,
+        `- SAP system: ${o.system ? o.system : 'none'}`,
+        `- Session: ${o.sessionId}`,
+        ...(o.person ? [`- Signed in as: ${o.person}`] : []),
+    ];
+    let speaker = null;
+    const say = (who, text) => {
+        if (speaker !== who) {
+            parts.push('', who === 'you' ? '## You' : '## CSPeach');
+            speaker = who;
+        }
+        parts.push('', text);
+    };
+    // CLI cards, anchored by turn_seq. The turns kept in `messages` are the last
+    // ones, so the i-th turn start here is turn (turn_seq - count + 1 + i). A
+    // card answered in turn t is placed before the prompt of turn t + 1.
+    const cards = [...(o.session?.cli_cards ?? [])].sort((a, b) => a.turn_seq - b.turn_seq);
+    const starts = turnStarts(o.messages, o.session);
+    const marks = resolveCliMarks(o.session, o.messages);
+    const lastTurn = o.session?.turn_seq ?? starts.length;
+    const turnOf = new Map(starts.map((idx, i) => [idx, lastTurn - starts.length + 1 + i]));
+    let nextCard = 0;
+    const flushCards = (beforeTurn) => {
+        while (nextCard < cards.length && cards[nextCard].turn_seq < beforeTurn)
+            say('cspeach', cardBlock(cards[nextCard++]));
+    };
+    for (const [idx, m] of o.messages.entries()) {
+        if (m.role === 'user') {
+            const n = turnOf.get(idx);
+            if (n !== undefined)
+                flushCards(n);
+            const typed = userPromptText(m);
+            if (typed === null)
+                continue;
+            // A message CSPeach wrote itself: one plain line, never its body.
+            const mark = marks[idx];
+            if (mark && mark.kind !== 'steer') {
+                say('cspeach', `*${mark.line}*`);
+                continue;
+            }
+            const t = readerText(typedText(typed));
+            if (t.length)
+                say('you', t);
+            continue;
+        }
+        if (m.role !== 'assistant')
+            continue;
+        const list = typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : blocks(m);
+        for (const b of list) {
+            if (b?.type === 'text' && typeof b.text === 'string') {
+                const t = readerText(b.text);
+                if (t.length)
+                    say('cspeach', t);
+            }
+            else if (b?.type === 'tool_use' && typeof b.id === 'string') {
+                const block = b.name === 'ask_question' ? questionBlock(b.input, results.get(b.id))
+                    : b.name === 'request_approval' ? approvalBlock(b.input, results.get(b.id))
+                        : null;
+                if (block)
+                    say('cspeach', block);
+            }
+        }
+    }
+    flushCards(Number.POSITIVE_INFINITY);
+    return parts.join('\n') + '\n';
+}
+function localDate() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+async function saveWithCopy(target, markdown, meta, emit) {
+    let mdPath;
+    try {
+        await fs.promises.mkdir(path.dirname(target), { recursive: true });
+        mdPath = await writeNoClobber(target, markdown);
+    }
+    catch (e) {
+        emit(`Not saved. ${e.message}`);
+        return 1;
+    }
+    emit(`Saved: ${path.resolve(mdPath)}`);
+    try {
+        const docx = await writeDocxNextTo(mdPath, markdown, meta);
+        emit(`Word copy: ${path.resolve(docx)}`);
+        return 0;
+    }
+    catch (e) {
+        emit(`Word copy not written. ${e.message}`);
+        return 1;
+    }
+}
+/** `/export docx …` in the REPL (Ink and classic call this one body). */
+export async function runExportDocxRepl(o) {
+    const file = docxFileFromReplArgs(o.args);
+    const system = o.session.sap_system ?? null;
+    const cwd = o.cwd ?? process.cwd();
+    if (file !== undefined && /\.md$/i.test(file) && fs.existsSync(path.resolve(cwd, file))) {
+        // Unchanged: a Word copy next to an existing Markdown file.
+        return runExportDocxCommand({ file, docx: true, system, ...(o.cwd ? { cwd: o.cwd } : {}), ...(o.today ? { today: o.today } : {}), emit: o.emit });
+    }
+    const today = o.today ?? localDate();
+    const out = path.join(cwd, OUT_DIR);
+    if (file === undefined || !/^conversation$/i.test(file)) {
+        // The last answer. Any other name ("explain1", "explain1.docx", a .md that
+        // does not exist yet) is the name to save it under: bare names go to
+        // cspeach-out/, a name with a folder goes where it says.
+        const a = lastAnswer(o.session.messages, o.session);
+        if (!a) {
+            o.emit('There is no answer to export yet.');
+            return 1;
+        }
+        const meta = metaFromMarkdown(a.text, { date: today, kind: 'answer', ...(system ? { system } : {}) });
+        const raw = (file ?? '').replace(/\.(?:md|docx)$/i, '').trim().replace(/\\/g, '/');
+        const folder = raw.slice(0, raw.lastIndexOf('/') + 1);
+        const name = raw.slice(folder.length).trim() || `${today}-answer-${a.turn}`;
+        // A colon after the drive letter would write into a hidden Windows file
+        // stream (the user sees an empty file); the others are never valid.
+        if (/[<>:"|?*]/.test(folder.replace(/^[A-Za-z]:\//, '') + name)) {
+            o.emit(`"${file}" cannot be a file name. Use letters, numbers, spaces, - or _, for example: /export docx explain1`);
+            return 1;
+        }
+        const target = folder ? path.resolve(cwd, folder, `${name}.md`) : path.join(out, `${name}.md`);
+        return saveWithCopy(target, a.text, meta, o.emit);
+    }
+    if (turnStarts(o.session.messages, o.session).length === 0) {
+        o.emit('There is no conversation to export yet.');
+        return 1;
+    }
+    const md = conversationMarkdown({ messages: o.session.messages, session: o.session, date: today, system, sessionId: o.session.id, ...(o.person ? { person: o.person } : {}) });
+    const meta = {
+        title: 'CSPeach conversation', date: today, kind: 'conversation', session: o.session.id,
+        ...(system ? { system } : {}), ...(o.person ? { person: o.person } : {}),
+    };
+    const short = o.session.id.replace(/[^A-Za-z0-9]/g, '').slice(0, 8) || 'session';
+    return saveWithCopy(path.join(out, `${today}-conversation-${short}.md`), md, meta, o.emit);
+}

package/dist/commands/help.js

@@ -47,6 +47,9 @@ export const HELP_GROUPS = [
             { name: '/files', description: fixed('Pick a saved project file and what to do with it') },
             { name: '@<file>', description: fixed('Attach a file from this folder to your prompt') },
             { name: '/export audit [file]', description: fixed('Write the signable session audit record to a file') },
+            { name: '/export docx', description: fixed('Word copy of the last answer, saved in cspeach-out. Add a name to choose the file name: /export docx explain1') },
+            { name: '/export docx conversation', description: fixed('Word copy of the whole conversation: your messages, the answers, the questions and what you picked') },
+            { name: '/export docx <file>.md', description: fixed('Word copy of a Markdown file, next to it') },
         ] },
     { title: 'Session', rows: [
             { name: '/new', description: fixed('Next prompt picks a skill afresh (also /reset)') },

package/dist/commands/plan-boundary.js

@@ -1,4 +1,5 @@
 import { saveSession } from '../session/store.js';
+import { rebuildCliMarksAfterCompact, PLAN_BOUNDARY_LINE } from '../session/cli-record.js';
 import { formatInfo } from '../renderer/notice-shape.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
 import { paint } from '../renderer/theme.js';
@@ -35,7 +36,11 @@ export async function compactAtPhaseBoundary(session, summarise) {
     if (!summary || summary.trim().length === 0)
         throw new Error('the summary came back empty');
     const backupPath = await backupBeforeCompact(session);
+    const oldMessages = session.messages;
     session.messages = [buildPhaseBoundaryMessage(summary)];
+    // /export docx conversation: the summary is CSPeach's, not the developer's (one plain line there).
+    // Every earlier message is dropped: the record holds only the summary's mark.
+    rebuildCliMarksAfterCompact(session, oldMessages, oldMessages.length, session.messages[0].content, { kind: 'plan-boundary', line: PLAN_BOUNDARY_LINE });
     delete session.last_context_tokens;
     await saveSession(session);
     return { performed: true, backupPath };

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

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

package/dist/commands/plan-continue.js

@@ -29,6 +29,17 @@ function stepTitle(envelope, phaseId) {
     const p = pc.ok ? pc.content.phases.find((q) => q.id === phaseId) : undefined;
     return p && pc.ok ? phaseDisplayTitle(p, pc.content.phases) : 'the interrupted step';
 }
+/**
+ * /export docx conversation (2026-10-23): the one line that stands for a plan
+ * step prompt CSPeach wrote, e.g. "CSPeach ran plan step 2 (Skeleton)."
+ */
+export function planStepOriginLine(prepared) {
+    const pc = parsePlanContent(prepared.envelope.content);
+    const i = pc.ok ? pc.content.phases.findIndex((q) => q.id === prepared.nextPhaseId) : -1;
+    if (!pc.ok || i < 0)
+        return 'CSPeach ran the next plan step.';
+    return `CSPeach ran plan step ${i + 1} (${phaseDisplayTitle(pc.content.phases[i], pc.content.phases)}).`;
+}
 /** The one line shown when a bare "continue" re-attaches to an interrupted step. */
 export function continuationNotice(prepared) {
     return `Continuing ${stepTitle(prepared.envelope, prepared.nextPhaseId)} where it stopped`;

package/dist/commands/plan-startup.js

@@ -20,6 +20,7 @@ import { computeNextPhaseForRun, isPhaseSatisfiedForRun, phaseDisplayTitle, stat
 import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from './plan-resume.js';
 import { newestPlanFamilyFiles } from '../session/recap.js';
+import { recordCliCard } from '../session/cli-record.js';
 import { legacyDirsFor } from '../projects/project-folder.js';
 import { getPlanGrant, installPlanGrant, planGrantAllowed } from '../approvals/plan-grant.js';
 import { DEFAULT_PLAN_MODE } from './plan-gate.js';
@@ -256,6 +257,9 @@ export function classicStartupChooser(prompt, log) {
         log('', q.title, ...q.facts.map((f) => `  ${f}`), ...q.choices.map((c, i) => `  ${i + 1}. ${c.label}`));
         const ans = (await prompt(`Choose 1-${q.choices.length} (Enter = ${q.choices[0].label}): `)).trim();
         const n = ans === '' ? 1 : Number(ans);
-        return Number.isInteger(n) && n >= 1 && n <= q.choices.length ? q.choices[n - 1].value : null;
+        const picked = Number.isInteger(n) && n >= 1 && n <= q.choices.length ? q.choices[n - 1] : null;
+        // /export docx conversation: the classic startup choice is recorded like the Ink card.
+        recordCliCard({ question: q.title, options: q.choices.map((c) => c.label), ...(q.facts.length ? { facts: [...q.facts] } : {}), answer: picked?.label ?? 'Cancelled', by: 'user' });
+        return picked ? picked.value : null;
     };
 }

package/dist/cost/cost-log.js

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

package/dist/cost/system-block.js

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

package/dist/docx/doc-meta.js

@@ -3,7 +3,15 @@
 // The metadata a Word copy carries on its title page. Filled by the caller
 // (the save hook knows the session's SAP alias; the export command knows the
 // file) and, for what the text itself says, by metaFromMarkdown (Task 3).
-const KIND_TITLE = { review: 'Code review', handover: 'Handover', document: 'Document' };
+const KIND_TITLE = {
+    review: 'Code review', handover: 'Handover', document: 'Document',
+    explanation: 'Explanation', impact: 'Impact analysis', preflight: 'Preflight check',
+    'transport-analysis': 'Transport analysis', migration: 'Migration assessment',
+    'clean-core': 'Clean-core assessment', 'custom-code-analysis': 'Custom code analysis',
+    'spec-gap': 'Spec gaps', design: 'Design', estimate: 'Estimate', plan: 'Plan',
+    'upgrade-scan': 'Upgrade scan', 'upgrade-report': 'Upgrade report',
+    answer: 'CSPeach answer', conversation: 'CSPeach conversation',
+};
 /** Z/Y objects, SAP-style names: ZCL_X, ZFI_DUP_INVOICE_CHECK, Z_REPORT, /NS/ZCL_X. */
 const OBJECT_RE = /(?<![\w/])((?:\/[A-Z0-9]+\/)?[ZY][A-Z0-9_]{2,39})\b/;
 /** Inline Markdown → plain words: `code` → code, [text](url) → text, **x** → x. */

package/dist/docx/markdown-to-docx.js

@@ -63,6 +63,10 @@ function titlePage(meta) {
         facts.push(`System: ${meta.system}`);
     if (meta.object)
         facts.push(`Object: ${meta.object}`);
+    if (meta.session)
+        facts.push(`Session: ${meta.session}`);
+    if (meta.person)
+        facts.push(`Signed in as: ${meta.person}`);
     return [
         new Paragraph({ text: meta.title, heading: HeadingLevel.TITLE, spacing: { before: 2400 } }),
         ...facts.map((f) => new Paragraph({ text: f })),
@@ -120,18 +124,27 @@ function list(l, ctx, depth) {
         const mark = l.ordered
             ? { numbering: { reference: NUMBERED, level, instance } }
             : { bullet: { level } };
+        // Task-list items (`- [ ]` / `- [x]`) keep their box at the start of the item (2026-10-23).
+        const box = item.task ? (item.checked ? '☒ ' : '☐ ') : '';
         let first = true;
         for (const child of item.tokens) {
             if (child.type === 'list') {
                 out.push(...list(child, ctx, depth + 1));
                 continue;
             }
+            if (first && box && (child.type === 'text' || child.type === 'paragraph')) {
+                const p = child;
+                const kids = 'tokens' in p && p.tokens ? inline(p.tokens) : [new TextRun(p.text ?? p.raw ?? '')];
+                out.push(new Paragraph({ ...mark, children: [new TextRun(box), ...kids] }));
+                first = false;
+                continue;
+            }
             // The first text block of an item carries the marker; later paragraphs are indented plain text.
             out.push(...blockToDocx(child, ctx, depth, first ? mark : { indent: { left: 720 * (level + 1) } }));
             first = false;
         }
         if (first)
-            out.push(new Paragraph({ ...mark, text: item.text ?? '' }));
+            out.push(new Paragraph({ ...mark, text: box + (item.text ?? '') }));
     }
     return out;
 }

package/dist/lane/app-chain.js

@@ -30,6 +30,7 @@ import { containSpecPath, specDisplayPath, SpecProtectedError } from './roots.js
 import { resolveAtTokenAsync } from '../projects/workspace.js';
 import { parseFromFlag } from '../skills/promotion-dispatch.js';
 import { rebuildStartedAfterPlanSave } from '../journey/rebuild.js';
+import { recordCliCard } from '../session/cli-record.js';
 export const STEP_1 = 'Step 1 of 3: finding the gaps in the spec.';
 export const STEP_2 = 'Step 2 of 3: choosing the build lane.';
 export const STEP_3 = 'Step 3 of 3: planning the build.';
@@ -239,6 +240,10 @@ function readSavedPlan(savedPath) {
     }
 }
 const OBJECT_LIST_FAILED = 'The object list could not be approved. Each SAP write asks first.';
+/** The plan a "Build this now?" record is about: the plan file name and its version. */
+function planRef(savedPath, version) {
+    return `${savedPath.split(/[\\/]/).pop() ?? savedPath} v${version}`;
+}
 /**
  * The facts under "Build this now?": steps, the exact object list, transport,
  * deploy, what stops. `grant: false` (the object-list approval cannot be
@@ -367,6 +372,9 @@ export async function afterPlanSave(h, savedPath) {
         return;
     }
     if (h.headless || !h.queueNext) {
+        // /export docx conversation: the plan gate was not shown; say so in the record.
+        if (h.headless)
+            recordCliCard({ question: START_QUESTION, ref: planRef(savedPath, saved.envelope.version), answer: 'Not asked (no one at the terminal)', by: 'headless' }, h.session);
         h.emit(`Start building with: ${cmd}`);
         end();
         return;
@@ -389,27 +397,42 @@ export async function afterPlanSave(h, savedPath) {
         initial: 0,
         aliases: { y: 'yes', n: 'no' },
     });
+    // /export docx conversation (fix round 2, N-1): the record a change ticket
+    // needs — when, which plan file and version, the objects and transport shown,
+    // the answer, and whether the object-list approval was installed. Only when
+    // a card was really shown (an injected confirm, or a card listener).
+    const shown = h.confirm !== undefined || (await import('../ui/card-slot.js')).cardSlotEmitter.listenerCount('confirm') > 0;
+    const record = (answer) => {
+        if (shown)
+            recordCliCard({ question: START_QUESTION, ref: planRef(savedPath, saved.envelope.version), options: ['Yes', 'No'], facts: [...facts], answer, by: 'user' }, h.session);
+    };
     if (res.value === 'yes' && !res.cancelled) {
         // The plan's recorded transport becomes the session transport when the
         // session has none, so the first step's writes land on (and are covered
         // by) it without the model naming it — the same rule a resume uses.
         adoptPlanTransportOnResume(saved.content.phases);
         const sessionId = h.session.id;
+        let installed = true;
         if (grantable && objects.length > 0 && typeof sessionId === 'string' && sessionId) {
             const a = { planId: saved.envelope.id, sessionId, objects, ...(transport ? { transport } : {}) };
             try {
                 if (h.grant)
                     await h.grant(a);
-                else if (!(await installPlanGrant({ ...a, ...(sapAlias ? { sapAlias } : {}) })))
+                else if (!(await installPlanGrant({ ...a, ...(sapAlias ? { sapAlias } : {}) }))) {
+                    installed = false;
                     h.emit(OBJECT_LIST_FAILED);
+                }
             }
             catch {
+                installed = false;
                 h.emit(OBJECT_LIST_FAILED);
             }
         }
+        record(installed ? 'Yes' : 'Yes (object list not installed; each SAP write asks first)');
         h.queueNext(cmd, APP_ORIGIN);
     }
     else {
+        record(res.value === 'no' ? 'No' : 'Cancelled');
         h.emit(`Start it later with: ${cmd}`);
     }
     end();