@cspeach/cli 1.1.50 → 1.1.52

package/dist/commands/plan-resume.js

@@ -45,6 +45,7 @@ import { resolveAtTokenAsync, formatProjectFileList, ensureWorkspace } from '../
 import { parsePlanContent, phaseWrites } from '../projects/plan-schema.js';
 import { statusesFromItems, computeNextPhase, computeNextPhaseForRun, pendingAuditPhaseIds, renderPlanTracker, renderPlanProgressLine, buildPlanRevision, isPhaseSatisfied, isAuditResolved, planCompletionLines, findServiceBinding, phaseDisplayTitle, } from '../projects/plan-run.js';
 import { extractPlan, NO_PLAN_MANIFEST_MESSAGE } from '../projects/extract-plan.js';
+import { finishCheckGuard } from './finish-check-guard.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
 import { isSapUnreachableNoted } from '../sap/reachability-state.js';
 import { saveProject } from '../projects/save.js';
@@ -66,6 +67,8 @@ import { isCredentialHandoverApproved } from '../repl/credential-handover-gate.j
 import { FIORI_DEPLOY_HANDOVER_SCOPE } from '../tools/fiori/deploy/scope.js';
 import { resolvePlanSources, renderPlanSourcesBlock } from '../projects/plan-sources.js';
 import { regroundPlan } from './plan-reground.js';
+import { getGrantTransport, isPlanGrantInForceFor } from '../approvals/plan-grant.js';
+import { projectTransport, transportForWrite } from '../register/project-transport.js';
 import { PAUSED_LINE, makeSapProbe, pauseUntilSapReachable, promptLockedChoice, resumeCommandFor } from './plan-sap-pause.js';
 /**
  * Parse and STRIP the per-run chaining-mode (`--guarded` / `--step`) and
@@ -166,6 +169,51 @@ export function buildUiPhaseContext(phases, next) {
     }
     return lines;
 }
+const sameTransport = (a, b) => !!a && !!b && a.trim().toUpperCase() === b.trim().toUpperCase();
+/**
+ * 2026-10-23 (owner-approved fix, review round 1) — the transport a create in
+ * this step would go to, by the write path's own order, so the step prompt can
+ * name it. Never the step's own work.transport ahead of that order.
+ *   - A plan grant of THIS plan is in force: its transport (writes under the
+ *     grant are held to it; a grant whose new transport is not bound yet names
+ *     none).
+ *   - Guarded mode, no grant yet: the grant offered for this step would bind
+ *     the plan's recorded transport, else the session one; if it is not
+ *     installed, writes take transportForWrite's order. Named only when the
+ *     two agree.
+ *   - Otherwise (step mode): transportForWrite for a create: the joined team
+ *     project's request, else the session transport (an explicit /transport).
+ * Resolve-mode writes (set_source, update_method, delete) never fall back to
+ * the session transport, and an object's owning lock still wins over any
+ * transport passed. Pure.
+ */
+export function resolveStepWriteTransport(i) {
+    if (i.grantInstalled)
+        return i.grantTransport?.trim() || undefined;
+    const perWrite = transportForWrite({ op: 'create', project: i.project, session: i.session }).request;
+    if (i.mode !== 'guarded')
+        return perWrite || undefined;
+    const planned = recordedPlanTransport(i.phases) ?? i.session ?? undefined;
+    return sameTransport(planned, perWrite) ? perWrite : undefined;
+}
+/**
+ * The step-prompt line naming the transport. `transport` is passed only when
+ * it is the one the write path uses AND the pre-step SAP check listed it as
+ * open. Returns [] (prompt unchanged) with no transport, for read-only steps
+ * (writes:false), design steps, and UI/CAP steps (local files; a UI deploy
+ * names its own).
+ */
+export function buildStepTransportLine(next, transport) {
+    if (!transport)
+        return [];
+    if (!phaseWrites(next))
+        return [];
+    if (next.delegateTo === 'abap-design')
+        return [];
+    if (next.layer === 'ui' || next.layer.startsWith('cap.'))
+        return [];
+    return [`Transport for this step: ${transport} (already settled: use it, do not ask the developer which transport).`];
+}
 /** Compact-example work keys for ui phases — the write-back contract
  * (review C3). Returns an OBJECT fragment because compactExample renders
  * via JSON.stringify: it is spread into the `work` object exactly like the
@@ -528,17 +576,31 @@ export async function preparePlanResume(args) {
     // what this plan built, what a dead run left inactive (a stale lock is
     // waited out, then reported), and whether the transport is still open.
     let sapStateBlock = [];
+    // 2026-10-23 — the transport this step's writes would use (write-path
+    // order). It is named in the prompt only when the re-check lists it open.
+    // A grant counts only while it is in force (this plan, not expired, approvals
+    // = plan); otherwise writes take the per-write order, and so does the line.
+    const stepWriteTransport = resolveStepWriteTransport({
+        phases: content.phases,
+        mode: effectiveMode,
+        grantInstalled: isPlanGrantInForceFor(envelope.id),
+        grantTransport: getGrantTransport(),
+        project: projectTransport(args.cwd),
+        session: getCurrentTransport(),
+    });
+    let stepTransportOpen = false;
     if (args.reground) {
         const regroundDeps = args.reground;
         const canAsk = args.interactive === true && !!args.prompt;
         const resumeCommand = resumeCommandFor({ path, mode: flags.mode, auditFlag: flags.audit });
         for (;;) {
-            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log });
+            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log, ...(stepWriteTransport ? { stepTransport: stepWriteTransport } : {}) });
             if (r.ok) {
                 // An in-run hop stays quiet unless something needs attention.
                 if (!r.quiet || args.boardStyle !== 'line')
                     args.log(formatInfo(r.summary).trimEnd());
                 sapStateBlock = r.sapStateBlock;
+                stepTransportOpen = r.stepTransportOpen === true;
                 break;
             }
             if (r.reason === 'unreachable') {
@@ -562,6 +624,7 @@ export async function preparePlanResume(args) {
                     continue;
                 if (choice === 'continue') {
                     sapStateBlock = r.sapStateBlock;
+                    stepTransportOpen = r.stepTransportOpen === true;
                     break;
                 }
                 args.log(PAUSED_LINE);
@@ -631,6 +694,10 @@ export async function preparePlanResume(args) {
     // '' already ends the prior element). Spread the blank AFTER the block so
     // context keeps single-blank separation on both sides.
     const uiContext = buildUiPhaseContext(content.phases, next);
+    // Named only when it is the transport the write uses, it is listed open, and
+    // it does not contradict the plan's recorded transport in <sap_state>.
+    const recordedTr = recordedPlanTransport(content.phases);
+    const stepTransport = buildStepTransportLine(next, stepTransportOpen && (!recordedTr || sameTransport(recordedTr, stepWriteTransport)) ? stepWriteTransport : undefined);
     // 2026-10-04 (plan sources) — the spec-gap items this phase reads, in full,
     // from the file the plan was made from (or the plan's creation snapshot).
     // A phase must never have to hunt the folder for its gap answers.
@@ -671,6 +738,7 @@ export async function preparePlanResume(args) {
         'Only if the plan itself must change structurally (a phase added, removed, or re-sequenced) fall back to the full shape with "content" — CSPeach accepts both. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase.',
         '',
         ...(uiContext.length ? [...uiContext, ''] : []),
+        ...(stepTransport.length ? [...stepTransport, ''] : []),
         PLAN_RESUME_HARNESS_OVERRIDE,
     ].join('\n');
     return {
@@ -935,6 +1003,12 @@ export async function finishPlanResume(args) {
             return null;
         }
     }
+    // 2026-10-23 — finish-check guard (inline-waiver findings §6 Option A): a
+    // step claimed "validated" while this turn's LAST rap_finish_check is below
+    // 5 of 5 is saved "blocked" (a waiver only when its notes name every failed
+    // item). Downgrade, never refuse. No check this turn, a 5 of 5, an
+    // unreadable result or any other status → saved exactly as written.
+    applyFinishCheckGuard(extract, args);
     const nowIso = new Date().toISOString();
     const statuses = extract.statuses;
     const executedId = args.prepared.nextPhaseId;
@@ -1056,6 +1130,42 @@ export async function finishPlanResume(args) {
         nextTitle: next ? phaseDisplayTitle(next, extract.content.phases) : null,
     };
 }
+/**
+ * The finish-check guard's write: when finishCheckGuard rules the executed
+ * step down, set it to 'blocked' in the status map, the item list and the
+ * summary, append the note to its work.notes and log the same line.
+ */
+function applyFinishCheckGuard(extract, args) {
+    const executedId = args.prepared.nextPhaseId;
+    const executed = extract.content.phases.find((p) => p.id === executedId);
+    if (!executed)
+        return;
+    const ruling = finishCheckGuard({
+        messages: args.messages,
+        messagesStart: args.messagesStart,
+        status: extract.statuses[executedId],
+        step: phaseDisplayTitle(executed, extract.content.phases),
+        notes: executed.work?.notes,
+    });
+    if (!ruling)
+        return;
+    extract.statuses[executedId] = ruling.status;
+    for (const it of extract.items)
+        if (it.id === executedId)
+            it.status = ruling.status;
+    const prevNotes = executed.work?.notes;
+    executed.work = { ...(executed.work ?? {}), notes: prevNotes ? `${prevNotes}\n${ruling.note}` : ruling.note };
+    const phases = extract.content.phases;
+    const next = computeNextPhase(phases, extract.statuses);
+    extract.content.summary = {
+        ...extract.content.summary,
+        validated: phases.filter((p) => isPhaseSatisfied(extract.statuses[p.id], p.audit)).length,
+        blocked: phases.filter((p) => extract.statuses[p.id] === 'blocked').length,
+        next: next?.id ?? null,
+    };
+    args.log('');
+    args.log(ruling.note);
+}
 /**
  * Final fix wave, item 5 — save a new plan version beside the plan file. When
  * that write fails (a read-only or missing folder), save it in the working

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/config/loader.js

@@ -45,7 +45,8 @@ export const DEFAULT_CONFIG = {
     // (staged rollout, owner 2026-10-17; users opt in with /chat on, a later
     // release flips this); 'professional' sends no style; 'developer' sends no
     // level (§10 D13).
-    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL },
+    // Stage 1A — 'system' is today's request; 'inline' is opt-in (config set).
+    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL, skills: 'system' },
     // Default `approval-gated` — preserves current UX (user approves each write).
     write_mode: 'approval-gated',
     // Default `managed` — lowest-friction entry point; uses the cspeach.dev proxy.
@@ -321,6 +322,9 @@ async function readConfig() {
             merged.assistant.lane = DEFAULT_CONFIG.assistant.lane;
         merged.assistant.style = parseStyle(merged.assistant.style) ?? DEFAULT_CONFIG.assistant.style;
         merged.assistant.level = parseLevel(merged.assistant.level) ?? DEFAULT_CONFIG.assistant.level;
+        // Stage 1A — unknown values fall back, like the lane.
+        if (merged.assistant.skills !== 'system' && merged.assistant.skills !== 'inline')
+            merged.assistant.skills = DEFAULT_CONFIG.assistant.skills;
         if (merged.ui.background !== undefined && merged.ui.background !== 'dark' && merged.ui.background !== 'light') {
             delete merged.ui.background;
         }

package/dist/cost/cost-log.js

@@ -87,6 +87,12 @@ export function buildEntry(opts) {
         entry.skill = opts.skill;
     if (opts.system_block !== undefined)
         entry.system_block = opts.system_block;
+    if (opts.system_mode !== undefined)
+        entry.system_mode = opts.system_mode;
+    if (opts.skill_appended !== undefined && opts.skill_appended.length > 0)
+        entry.skill_appended = opts.skill_appended;
+    if (opts.tools_surfaced !== undefined && opts.tools_surfaced.length > 0)
+        entry.tools_surfaced = opts.tools_surfaced;
     return entry;
 }
 /**

package/dist/cost/system-block.js

@@ -11,6 +11,12 @@
  * Kept in a module WeakMap, never in the session file (no schema change). A
  * resumed session therefore starts at 'first' again.
  */
+/**
+ * Stage 1A, Task 1A.2 (M2) — the skill part of the key on an inline call: the
+ * system block is the one conversation prompt whatever the skill header says,
+ * and no delegate is composed into it (the delegate rides in the conversation).
+ */
+export const INLINE_SYSTEM_BLOCK_SKILL = '_inline';
 export function systemBlockKey(p) {
     return `${p.skill}|${p.delegateSkill ?? ''}|${p.style}|${p.level}`;
 }

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();

package/dist/models/server-config.js

@@ -284,7 +284,7 @@ export function managedProxyServesNewShapes() {
  * 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
+ * Read only by repl/inline-mode.ts `inlineServed` (Stage 1A; pinned by
  * __tests__/served-inline-skills-pin.test.ts). Pure sync read.
  */
 export function servedInlineSkills() {

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

@@ -398,7 +398,11 @@ export async function runSaveCommand(args) {
     // maybeOfferSave never does headless — so the blanket 'y' never reaches it.)
     // Inside a journey a triage is saved without the question: the journey needs the rows.
     const journey = spec.artefactType === 'clean-core-decision' ? args.journey : undefined;
-    const answer = journey ? 'y' : await askYesNo({ question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt });
+    const answer = journey ? 'y' : await askYesNo({
+        question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt,
+        // F-A (live check 2026-10-26) — a plan is only built from its saved file.
+        ...(spec.artefactType === 'plan' ? { defaultYes: true } : {}),
+    });
     if (!isYes(answer)) {
         args.onNotSaved?.('declined');
         return null;

package/dist/projects/yes-no.js

@@ -1,8 +1,12 @@
 export async function askYesNo(a) {
     if (a.confirm)
-        return a.confirm(a.question, { default: 'n' });
+        return a.confirm(a.question, { default: a.defaultYes ? 'y' : 'n' });
     if (!a.prompt)
         return '';
+    if (a.defaultYes) {
+        const reply = (await a.prompt(`${a.question} [Y/n]: `)).trim().toLowerCase();
+        return reply === '' ? 'y' : reply;
+    }
     return (await a.prompt(`${a.question} [y/N]: `)).trim().toLowerCase();
 }
 /** Today's decision rule at all six sites. */

package/dist/renderer/change-card.js

@@ -14,7 +14,9 @@ const DIFF_LINES = 6;
 /** Myers diff is O(N·D) and synchronous: past this budget we show no diff
  *  at all (object + footer only), never a partial one. */
 const DIFF_TIMEOUT_MS = 200;
-const defaultDiffer = (a, b) => diffLines(a, b, { timeout: DIFF_TIMEOUT_MS });
+// LT-7: a last line that only gains a newline (because lines follow it) is
+// the same line, never a -/+ pair.
+const defaultDiffer = (a, b) => diffLines(a, b, { timeout: DIFF_TIMEOUT_MS, ignoreNewlineAtEof: true });
 // eslint-disable-next-line no-control-regex
 const ANSI = /\x1b\[[0-9;]*m/g;
 const visibleLen = (s) => s.replace(ANSI, '').length;