@cspeach/cli 1.1.52 → 1.1.53

package/dist/projects/document-save.js

@@ -53,6 +53,92 @@ export async function offerDocumentSave(p) {
     });
     return docxPath ? { mdPath, docxPath } : { mdPath };
 }
+/**
+ * The header the CLI writes above a saved change options document (never the
+ * model: the document itself never names the person). Parts that are not
+ * known are left out: no system in standalone, no person in a one-shot run.
+ */
+export function changeOptionsHeader(p) {
+    const parts = [`Date: ${p.today}`];
+    if (p.sapSystem)
+        parts.push(`System: ${p.sapSystem}`);
+    if (p.sessionId)
+        parts.push(`Session: ${p.sessionId}`);
+    if (p.operator)
+        parts.push(`Prepared for: ${p.operator}`);
+    return `> **Saved by CSPeach** · ${parts.join(' · ')}\n\n`;
+}
+/**
+ * Change options (2026-10-23): the marked document(s) from refactor / impact.
+ * One "Save this change options document?" for the turn (headless saves
+ * without asking). Each document goes to
+ * cspeach-out/<date>-change-options-<OBJECT>.md, never overwritten (a second
+ * one is -2), with the CLI header on top. Then the one shared Word step for
+ * each file; in ask mode "Word copy too?" is asked once and covers all.
+ * The Word copy is made from the document alone; its title page carries the
+ * facts. Never throws: a failure is one line through `emit`.
+ */
+export async function offerChangeOptionsSave(p) {
+    const docs = p.docs.filter((d) => d.markdown.trim().length > 0);
+    if (docs.length === 0)
+        return {};
+    if (!p.headless) {
+        // Defaults to Yes (live check 2026-10-26, same as F-A for plans): Enter
+        // must not lose the document.
+        const a = await askYesNo({ question: 'Save this change options document?', confirm: p.confirm, defaultYes: true });
+        if (!isYes(a))
+            return {};
+    }
+    else {
+        p.emit(chalk.dim('headless: saving the change options document without asking'));
+    }
+    const header = changeOptionsHeader(p);
+    const mdPaths = [];
+    const docxPaths = [];
+    let wordCopy = p.wordCopy;
+    for (const doc of docs) {
+        let mdPath;
+        try {
+            const target = path.join(p.cwd, OUT_DIR, documentFilename('change-options', doc.object, p.today));
+            await fs.promises.mkdir(path.dirname(target), { recursive: true });
+            mdPath = await writeNoClobber(target, `${header}${doc.markdown}\n`);
+        }
+        catch (e) {
+            p.emit(`Not saved. ${e.message}`);
+            continue;
+        }
+        p.emit(`Saved: ${path.resolve(mdPath)}`);
+        mdPaths.push(mdPath);
+        // The Word copy reads plain \n line endings (Task 5 review: CRLF answers).
+        const markdown = doc.markdown.replace(/\r\n?/g, '\n');
+        const fromText = metaFromMarkdown(markdown, { date: p.today, kind: 'change-options' });
+        const meta = {
+            title: fromText.title,
+            date: p.today,
+            ...(p.sapSystem ? { system: p.sapSystem } : {}),
+            ...(doc.object ? { object: doc.object } : {}),
+            kind: 'change-options',
+            ...(p.operator ? { preparedFor: p.operator } : {}),
+        };
+        let answer;
+        const docxPath = await offerWordCopy({
+            nextTo: mdPath, markdown, meta, headless: p.headless, wordCopy, emit: p.emit,
+            confirm: async (q, o) => { const a = await p.confirm(q, o); answer = isYes(a); return a; },
+        });
+        // One "Word copy too?" for the turn: its answer decides the next files.
+        if (answer !== undefined)
+            wordCopy = answer ? 'always' : 'never';
+        if (docxPath)
+            docxPaths.push(docxPath);
+    }
+    if (mdPaths.length === 0)
+        return {};
+    return {
+        mdPath: mdPaths[mdPaths.length - 1],
+        mdPaths,
+        ...(docxPaths.length ? { docxPath: docxPaths[docxPaths.length - 1], docxPaths } : {}),
+    };
+}
 /**
  * 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 →

package/dist/projects/extract-design.js

@@ -93,6 +93,10 @@ function parseDependencySequence(section, nameToId) {
     }
     return out;
 }
+/** Task 17 (F-N) — the design's title heading is the sign of the document. */
+export function hasDesignSign(markdown) {
+    return matchTitleHeading(markdown, TITLE_SPEC) !== null;
+}
 export function extractDesign(markdown) {
     const titleMatch = matchTitleHeading(markdown, TITLE_SPEC);
     if (!titleMatch) {

package/dist/projects/extract-estimate.js

@@ -60,6 +60,10 @@ function parseComponentsTable(section) {
     }
     return rows;
 }
+/** Task 17 (F-N) — the estimate's title heading is the sign of the document. */
+export function hasEstimateSign(markdown) {
+    return matchTitleHeading(markdown, TITLE_SPEC) !== null;
+}
 export function extractEstimate(markdown) {
     const titleMatch = matchTitleHeading(markdown, TITLE_SPEC);
     if (!titleMatch) {

package/dist/projects/extract-spec-gap.js

@@ -126,6 +126,14 @@ export function looksLikeSpecGap(markdown) {
     }
     return false;
 }
+/**
+ * Task 17 (F-N) — any sign of a spec-gap document: its title heading or its
+ * body (looksLikeSpecGap). A recap turn carries neither, so the save step
+ * stays quiet on it.
+ */
+export function hasSpecGapSign(markdown) {
+    return matchTitleHeading(markdown, TITLE_SPEC) !== null || looksLikeSpecGap(markdown);
+}
 function parseGapsFromSection(sectionBody, nextId) {
     const out = [];
     const gapRe = new RegExp(GAP_LINE_RE.source); // per-line, no /m — exec on each line

package/dist/projects/index.js

@@ -5,7 +5,7 @@ export { validateEnvelope } from './validate.js';
 export { canonicalSha256 } from './canonicalize.js';
 export { titleSlug, shortId, projectFilename } from './filename.js';
 export { runSaveCommand, detectArtifactSkill, peekPlanManifestTitle, resolvePriorPlanEnvelope } from './save-command.js';
-export { offerAnswerBlockers, openBlockers, applyBlockerAnswers } from './answer-blockers.js';
+export { offerAnswerBlockers, openBlockers, applyBlockerAnswers, saveBlockerAnswers } from './answer-blockers.js';
 export { mergeUpgradeProgress, renderUpgradeMergeManifest } from './merge-upgrade.js';
 export { extractDesign } from './extract-design.js';
 export { extractEstimate } from './extract-estimate.js';

package/dist/projects/plan-objects.js

@@ -73,3 +73,27 @@ export function plannedObjectFacts(objs, max = 12) {
 export function planGrantFactLines() {
     return ['Writes to these objects need no further card.', 'Anything else stops and asks.'];
 }
+/**
+ * True when the plan lists objects and every one is in a local package
+ * (`$TMP`, `$…`): nothing on the list goes into a transport.
+ */
+export function localOnlyObjects(objs) {
+    return objs.length > 0 && objs.every((o) => typeof o.package === 'string' && o.package.startsWith('$'));
+}
+/** The card's transport line. Local-only objects with no transport say so plainly. */
+export function planTransportFact(transport, objs) {
+    if (transport)
+        return `Transport: ${transport}`;
+    if (localOnlyObjects(objs))
+        return 'Transport: none (local objects, not transported)';
+    return 'Transport: a new one for this build';
+}
+/**
+ * Will the object-list grant cover these writes? It mirrors grantCovers
+ * (approvals/plan-grant.ts): with no bound transport no write is covered,
+ * and a local-only plan never creates one, so each write asks. Card text
+ * only; the grant itself is minted exactly as before.
+ */
+export function planGrantCoversWrites(transport, objs) {
+    return transport !== undefined || !localOnlyObjects(objs);
+}

package/dist/projects/plan-run.js

@@ -373,7 +373,11 @@ export function findServiceBinding(phases) {
 export function planCompletionLines(phases, 
 // Terminal callers follow the terminal's glyph set; file writers (the
 // handover markdown) pass UNICODE_GLYPHS so file content never varies.
-g = getGlyphs()) {
+g = getGlyphs(), 
+// 1.1.53 item 11: the run's transport (terminal callers pass
+// planBuildTransport). The handover file passes none, so its content
+// depends only on the transport recorded in the plan file.
+transport) {
     const lines = ['Plan complete — every phase validated.'];
     // Confidence-tiered redesign (2026-07-08): a completed plan that carried
     // non-blocking warn verdicts surfaces them in the FINAL summary — a warned
@@ -436,7 +440,13 @@ g = getGlyphs()) {
             ? `${g.info} Deploy skipped by the developer: ${sanitizeControlChars(optOut)}`
             : `${g.attention} The app was not deployed to SAP — it runs only in local preview. Deploy it with /abap-fiori-build or record why not.`);
     }
-    lines.push('Consider /abap-preflight on the produced transport(s) before release.');
+    // A run that produced no transport (all objects local, e.g. $TMP) has
+    // nothing to preflight before release, so the hint is left out.
+    const producedTransport = !!transport?.trim()
+        || phases.some((p) => typeof p.work?.transport === 'string' && p.work.transport.trim() !== '');
+    if (producedTransport) {
+        lines.push('Consider /abap-preflight on the produced transport(s) before release.');
+    }
     return lines;
 }
 /**

package/dist/projects/save-command.js

@@ -1,8 +1,8 @@
 import { readdirSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { extractSpecGap } from './extract-spec-gap.js';
-import { extractDesign } from './extract-design.js';
-import { extractEstimate } from './extract-estimate.js';
+import { extractSpecGap, hasSpecGapSign } from './extract-spec-gap.js';
+import { extractDesign, hasDesignSign } from './extract-design.js';
+import { extractEstimate, hasEstimateSign } from './extract-estimate.js';
 import { extractUpgradeScan, extractUpgradeProgress, extractUpgradeReport } from './extract-upgrade.js';
 import { extractCcaAssessment } from './extract-cca.js';
 import { extractModernizeResult } from './extract-modernize.js';
@@ -29,16 +29,22 @@ const SKILL_REGISTRY = {
         artefactType: 'spec-gap',
         extract: (md) => extractSpecGap(md),
         itemNoun: 'questions',
+        hasDocumentSign: hasSpecGapSign,
+        documentNoun: 'a spec-gap document',
     },
     'abap-design': {
         artefactType: 'design',
         extract: (md) => extractDesign(md),
         itemNoun: 'objects',
+        hasDocumentSign: hasDesignSign,
+        documentNoun: 'a design document',
     },
     'abap-estimate': {
         artefactType: 'estimate',
         extract: (md) => extractEstimate(md),
         itemNoun: 'components',
+        hasDocumentSign: hasEstimateSign,
+        documentNoun: 'an estimate document',
     },
     'abap-upgrade-scan': {
         artefactType: 'upgrade-scan',
@@ -231,6 +237,18 @@ export function resolvePriorPlanEnvelope(title, dir, opts = {}) {
     opts.log?.(`[save] More than one plan is titled '${pick.envelope.title}'; revising the newest: ${basename(pick.path)}`);
     return pick;
 }
+/**
+ * Task 17 (F-N) — the person's message asks us to save the document:
+ * "save this/it/that", "save the spec-gap/design/estimate/document",
+ * "can you save", "please save". Ordinary wording about saving in the app
+ * ("validation on save", "the user clicks Save", "saving changes") is not.
+ */
+const ASKED_TO_SAVE_RE = new RegExp([
+    String.raw `\b(?:can|could|would|will)\s+you\s+(?:please\s+)?save\b`,
+    String.raw `\bplease\s+save\b`,
+    String.raw `\bsave\s+(?:this|it|that|them)\b`,
+    String.raw `\bsave\s+(?:the|my|our)\s+(?:spec[\s-]*gaps?|design|estimate|document|doc|result|analysis|file|project\s+file)\b`,
+].join('|'), 'i');
 export async function runSaveCommand(args) {
     const spec = SKILL_REGISTRY[args.skillName];
     if (!spec)
@@ -323,22 +341,31 @@ export async function runSaveCommand(args) {
                 return runSaveCommand({ ...args, skillName: detected });
             }
         }
-        if (spec.manifestMarker && args.skillOutput.includes(spec.manifestMarker)) {
-            args.log('');
-            args.log(`[save] ${args.skillName}: a ${spec.manifestMarker} block IS present but failed to parse — artefact NOT saved.`);
-            args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
-            args.log(`[save] The output above is otherwise complete — re-run the skill or report this as a manifest bug.`);
+        if (spec.manifestMarker) {
+            // Task 17 fix round 1 (F-N): the manifest skills send every turn here.
+            // A turn with no manifest block is a conversational turn, not a failed
+            // save: say nothing (the B5 contract on manifestMarker above). A block
+            // that is present but fails to parse keeps its loud lines.
+            if (args.skillOutput.includes(spec.manifestMarker)) {
+                args.log('');
+                args.log(`[save] ${args.skillName}: a ${spec.manifestMarker} block IS present but failed to parse — artefact NOT saved.`);
+                args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
+                args.log(`[save] The output above is otherwise complete — re-run the skill or report this as a manifest bug.`);
+            }
         }
-        else {
-            // 2026-09-17 — marker-less skills (design, estimate, spec-gap) used to
-            // fail here in silence: no file, no line, and the next --from step had
-            // nothing to start from (seen live: a design titled "# ABAP Design"
-            // instead of "## ABAP Design"). Say what happened and what to do.
-            args.log('');
-            args.log(`[save] ${args.skillName}: could not read the output as a ${spec.artefactType} — nothing was saved.`);
-            args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
-            args.log(`[save] Ask CSPeach to "re-issue the ${spec.artefactType} in the standard structure" and it will be saved then.`);
+        else if (spec.hasDocumentSign && spec.documentNoun) {
+            // Task 17 (F-N, 2026-10-26) — the save step runs on every turn of the
+            // session skill. A turn with no sign of the document (a recap after a
+            // choice card) is not a failed save: say nothing, unless the person
+            // asked to save. A text that does look like the document gets one
+            // plain line.
+            if (spec.hasDocumentSign(args.skillOutput) || ASKED_TO_SAVE_RE.test(args.skillInput ?? '')) {
+                args.log('');
+                args.log(`We couldn't save this as ${spec.documentNoun}. Ask us to write it again in the usual layout.`);
+            }
         }
+        // (2026-09-17's "[save] … could not read the output" lines are gone: every
+        // registry skill now has a manifest marker or a document sign above.)
         args.onNotSaved?.('unreadable');
         return null;
     }
@@ -401,7 +428,8 @@ export async function runSaveCommand(args) {
     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 } : {}),
+        // Task 20 (owner 2026-10-26) — the spec-gap document defaults to Yes too.
+        ...(spec.artefactType === 'plan' || spec.artefactType === 'spec-gap' ? { defaultYes: true } : {}),
     });
     if (!isYes(answer)) {
         args.onNotSaved?.('declined');

package/dist/renderer/change-card.js

@@ -103,6 +103,20 @@ export function diffBody(card, differ = defaultDiffer) {
         for (const l of part.value.replace(/\r?\n$/, '').split(/\r?\n/))
             changed.push(`${part.added ? '+' : '-'} ${clean(l)}`);
     }
+    // 1.1.53 (live F-E): the first write after a create replaces SAP's template,
+    // whose removed lines are only comments. Myers puts those first and hides the
+    // new code, so in that case the added code leads, then added comment/blank
+    // lines, then the removals. Any removal that carries code keeps Myers order.
+    const isCommentOrBlank = (l) => {
+        const code = l.slice(2);
+        return code.trim() === '' || code.startsWith('*') || /^\s*"/.test(code);
+    };
+    const removed = changed.filter((l) => l.startsWith('-'));
+    const added = changed.filter((l) => l.startsWith('+'));
+    const addedCode = added.filter((l) => !isCommentOrBlank(l));
+    if (removed.length > 0 && removed.every(isCommentOrBlank) && addedCode.length > 0) {
+        changed.splice(0, changed.length, ...addedCode, ...added.filter(isCommentOrBlank), ...removed);
+    }
     return { lines: changed.slice(0, DIFF_LINES), hidden: Math.max(0, changed.length - DIFF_LINES) };
 }
 export function buildChangeCard(input, width, box = getBoxChars()) {

package/dist/renderer/html-entities.js

@@ -0,0 +1,25 @@
+/**
+ * 1.1.53 item 5 — the model sometimes writes `<` / `>` / `&` in the
+ * text and diffs it puts on an approval card. Cards show the real characters.
+ * One pass only: `&amp;lt;` becomes `&lt;`, never `<`.
+ *
+ * Display only. Never apply this to anything written to SAP or saved.
+ */
+const ENTITY = /&(lt|gt|amp);/g;
+const CHAR = { lt: '<', gt: '>', amp: '&' };
+export function decodeDisplayEntities(s) {
+    return s.replace(ENTITY, (_m, name) => CHAR[name]);
+}
+/** A raw field symbol or raw markup: `<` followed by a letter, `_`, `/` or `!`. */
+const RAW_TAG = /<[A-Za-z_/!]/;
+/**
+ * The same decode for a whole source or diff block, except when the block
+ * holds a raw field symbol or raw markup (`<fs>`, `<b>`, `</p>`, `<!--`).
+ * A model that escapes field symbols escapes them throughout; real source
+ * that holds `&lt;` in a literal almost always has a raw `<fs>` or markup
+ * too, so it stays as written. Operators and comparisons (`->`, `=>`, `>=`,
+ * `<=`, `<>`, ` < `) do not count. Display only, like decodeDisplayEntities.
+ */
+export function decodeDisplayBlock(s) {
+    return RAW_TAG.test(s) ? s : decodeDisplayEntities(s);
+}

package/dist/renderer/machine-blocks.js

@@ -16,6 +16,12 @@
 // at the START of a line. It ends at a `-->` on the opener's own line, or
 // else at a `-->` that starts a later line (one newline straight after it is
 // dropped too). An inline mention mid-line is prose and stays.
+// 1.1.53: a line that starts with a closing marker (`<!-- /cspeach:…` or
+// `<!-- /csforge:…`) is a block like an opener. A one-line change options
+// marker (`<!-- csforge:change-options OBJECT=X -->`, `<!-- /csforge:change-options -->`)
+// is removed wherever it sits on a line; the text around it stays. Other
+// mid-line mentions stay prose, and so does a mid-line marker whose `-->` is
+// not on the same line.
 // A chunk boundary can fall anywhere: a line that could still become an
 // opener is held until it can be decided; inside a block a tail that could
 // still become the closing `-->` is held the same way.
@@ -24,8 +30,10 @@ export function initialMachineBlockState() {
 }
 // A leading `\n` marks a line start (the probe prepends one when the text
 // begins at a line start) — no `^`, which would match a mid-line chunk start.
-const OPENER_RE = /\n[ \t]*<!--[ \t]*(?:cspeach|csforge):/;
-const PREFIXES = ['cspeach:', 'csforge:'];
+const OPENER_RE = /\n[ \t]*<!--[ \t]*\/?(?:cspeach|csforge):/;
+const PREFIXES = ['cspeach:', 'csforge:', '/cspeach:', '/csforge:'];
+const INLINE_MARKER_RE = /<!--[ \t]*\/?(?:cspeach|csforge):change-options\b[^\n]*?-->/g;
+const INLINE_PREFIXES = ['cspeach:change-options', 'csforge:change-options'];
 const CLOSER_RE = /\n[ \t]*-->/;
 const PARTIAL_CLOSER_RE = /^\n[ \t]*-{0,2}$/;
 /** Could `frag` (one incomplete line) still grow into a block opener? */
@@ -38,6 +46,27 @@ function couldBeOpener(frag) {
     const r = s.slice(4).replace(/^[ \t]*/, '');
     return PREFIXES.some((p) => p.startsWith(r));
 }
+/**
+ * Could `frag` (text from a mid-line `<`, no newline yet) still grow into a
+ * one-line change options marker? A full prefix stays held until its `-->`
+ * or the end of the line decides it.
+ */
+function couldBeInlineMarker(frag) {
+    if (frag.includes('-->') || frag.includes('\n'))
+        return false;
+    if (frag.length <= 4)
+        return '<!--'.startsWith(frag);
+    if (!frag.startsWith('<!--'))
+        return false;
+    let r = frag.slice(4).replace(/^[ \t]*/, '');
+    if (r.startsWith('/'))
+        r = r.slice(1);
+    return INLINE_PREFIXES.some((p) => p.startsWith(r) || r.startsWith(p));
+}
+/** Remove every complete one-line change options marker. */
+function stripInlineMarkers(text) {
+    return text.replace(INLINE_MARKER_RE, '');
+}
 export function filterMachineBlocks(chunk, prev) {
     const st = { ...prev };
     let work = st.held + chunk;
@@ -103,7 +132,7 @@ export function filterMachineBlocks(chunk, prev) {
         if (m) {
             const offset = st.lineStart ? 1 : 0;
             const lineBegin = m.index + 1 - offset; // index in `work`, just after the newline
-            output += work.slice(0, lineBegin);
+            output += stripInlineMarkers(work.slice(0, lineBegin));
             work = work.slice(m.index + m[0].length - offset);
             st.inBlock = true;
             st.firstLine = true;
@@ -113,14 +142,32 @@ export function filterMachineBlocks(chunk, prev) {
         const lastNl = work.lastIndexOf('\n');
         const fragStart = lastNl >= 0 ? lastNl + 1 : st.lineStart ? 0 : -1;
         if (fragStart >= 0 && fragStart < work.length && couldBeOpener(work.slice(fragStart))) {
-            output += work.slice(0, fragStart);
+            output += stripInlineMarkers(work.slice(0, fragStart));
             st.held = work.slice(fragStart);
             st.lineStart = true;
         }
         else {
-            output += work;
-            if (work.length > 0)
-                st.lineStart = work.endsWith('\n');
+            // Remove complete one-line markers; hold a mid-line tail that could
+            // still become one until its `-->` or the newline decides it.
+            const shown = stripInlineMarkers(work);
+            const tailStart = shown.lastIndexOf('\n') + 1;
+            let holdAt = -1;
+            for (let i = shown.indexOf('<', tailStart); i >= 0; i = shown.indexOf('<', i + 1)) {
+                if (couldBeInlineMarker(shown.slice(i))) {
+                    holdAt = i;
+                    break;
+                }
+            }
+            if (holdAt >= 0) {
+                output += shown.slice(0, holdAt);
+                st.held = shown.slice(holdAt);
+                st.lineStart = holdAt === 0 ? st.lineStart : shown[holdAt - 1] === '\n';
+            }
+            else {
+                output += shown;
+                if (shown.length > 0)
+                    st.lineStart = shown.endsWith('\n');
+            }
         }
         break;
     }

package/dist/renderer/tool-labels.js

@@ -168,6 +168,7 @@ const RULES = {
     team_findings: (a) => ({ verb: 'Read team findings', object: str(a['lane']) ?? str(a['packages']) ?? 'all objects' }),
     rules_propose: () => ({ verb: 'Check a proposed decision rule', object: 'nothing is saved' }),
     team_estate: (a) => ({ verb: 'Read estate inventory', object: str(a['packages']) ?? 'all packages' }),
+    spec_answers_record: (a) => ({ verb: 'Recorded answers in', object: shortLeft(str(a['path']) ?? '') }),
     team_lane_move: (a) => ({ verb: 'Move packages to another person', object: shortRight(Array.isArray(a['packages']) ? a['packages'].map(String).join(', ') : 'packages') }),
     sap_badi_list: (a) => ({ verb: 'Searched BAdIs', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
     sap_badi_read: (a) => ({ verb: 'Read BAdI', object: shortRight([str(a['kind']), str(a['name'])].filter(Boolean).join(' ')) }),
@@ -289,6 +290,7 @@ const PRESENT = {
     'Audited metadata': 'Auditing metadata', 'Extended model': 'Extending model',
     'Checked capability': 'Checking capability',
     'Read texts of': 'Reading texts of', 'Read team findings': 'Reading team findings', 'Check a proposed decision rule': 'Checking a proposed decision rule', 'Read estate inventory': 'Reading estate inventory', 'Move packages to another person': 'Moving packages to another person', 'Wrote texts': 'Writing texts',
+    'Recorded answers in': 'Recording answers in',
 };
 export function toolActivityLabel(name, args) {
     const l = toolLabel(name, args);

package/dist/renderer/tool-widget.js

@@ -6,6 +6,16 @@ import { toolLabel, toolActivityLabel, foldOutput, clean } from './tool-labels.j
 import { getEffectiveBodyWidth } from './tty.js';
 import { flowFor, stdoutFlow, writeStdout, canAnimateInPlace } from './transcript-flow.js';
 import { humanErrorDetail } from './error-detail.js';
+import { STOPPED_BEFORE_START_RESULT } from '../agent/repair-partial.js';
+/**
+ * 1.1.53 item 10 — a call stopped before it started (Esc / Ctrl+C) changed
+ * nothing: the row is a neutral dim stop, not a red failure. The model still
+ * receives STOPPED_BEFORE_START_RESULT unchanged; this is display only.
+ */
+const STOPPED_BEFORE_START_LINE = 'Stopped before it started. Nothing changed in SAP.';
+function stoppedBeforeStart(isError, content) {
+    return isError && content === STOPPED_BEFORE_START_RESULT;
+}
 export { canAnimateInPlace };
 /**
  * Tool-dispatch renderer — CC-style two-line format with peach spinner.
@@ -316,7 +326,8 @@ export function renderToolCallBottom(params) {
         write(panelsRow({ name: name ?? '', args: args ?? {}, isError, resultSummary, resultContent, durationMs }));
         return;
     }
-    const icon = isError ? chalk.red('✗') : chalk.green('✓');
+    const stopped = stoppedBeforeStart(isError, resultContent);
+    const icon = stopped ? chalk.dim('·') : isError ? chalk.red('✗') : chalk.green('✓');
     // Label: plain (not bold — the top line keeps visual primacy) name +
     // dim arg summary, mirroring the top-line shape so orphaned rows still
     // read as "which tool, on what object".
@@ -326,9 +337,9 @@ export function renderToolCallBottom(params) {
         const wrapped = summary ? chalk.gray('(') + chalk.gray(summary) + chalk.gray(')') : '';
         label = ` ${name}${wrapped}`;
     }
-    const detailRaw = resultSummary ? truncate(resultSummary, RESULT_SUMMARY_MAX) : '';
+    const detailRaw = stopped ? STOPPED_BEFORE_START_LINE : resultSummary ? truncate(resultSummary, RESULT_SUMMARY_MAX) : '';
     const detail = detailRaw
-        ? (isError ? chalk.red(detailRaw) : chalk.gray(detailRaw))
+        ? (stopped ? chalk.dim(detailRaw) : isError ? chalk.red(detailRaw) : chalk.gray(detailRaw))
         : '';
     const timing = chalk.dim(formatDuration(durationMs));
     const sep = chalk.dim('·');
@@ -424,7 +435,8 @@ function panelsRow(p) {
     // Round 8 item 2 — a cancelled / rejected approval is not a success: no
     // green tick, and the row says what happened.
     const declined = !p.isError && p.name === 'request_approval' ? approvalDeclined(p.resultContent) : undefined;
-    const icon = p.isError ? paint('bad', '✗') : declined ? paint('warn', '·') : paint('ok', '✓');
+    const stopped = stoppedBeforeStart(p.isError, p.resultContent);
+    const icon = stopped ? paint('dim', '·') : p.isError ? paint('bad', '✗') : declined ? paint('warn', '·') : paint('ok', '✓');
     const timing = p.durationMs >= 1000 ? formatDuration(p.durationMs) : '';
     // 1.1.31: a setting said yes, not a person — the row says so.
     const auto = !p.isError && !declined && p.name === 'request_approval' && approvalAutoApproved(p.resultContent);
@@ -440,7 +452,10 @@ function panelsRow(p) {
     // Live fix 2026-09-26: a JSON tool result (e.g. sap_activate's
     // activation_results) is turned into readable lines, never shown raw.
     const errorSource = p.resultContent?.trim().startsWith('{') ? p.resultContent : p.resultSummary;
-    if (p.isError && errorSource) {
+    if (stopped) {
+        out.push('    ' + paint('dim', truncate(STOPPED_BEFORE_START_LINE, width - 4)));
+    }
+    else if (p.isError && errorSource) {
         // Raw error text can carry ANSI codes, \r redraws and tabs: clean() each
         // line (the one sanitiser, shared with the labels) before truncate + paint.
         for (const d of humanErrorDetail(errorSource).map(clean).filter(Boolean).slice(0, ERROR_DETAIL_LINES)) {

package/dist/repl/chat-lane.js

@@ -85,9 +85,18 @@ const THANKS_PHRASES = new Set(['thanks', 'thank you', 'thank u', 'thx', 'tx', '
 function isThanksOnly(trimmed) {
     return THANKS_PHRASES.has(stripOkPrefix(trimmed).toLowerCase().replace(/[.!?,]+$/, ''));
 }
+/** Change options (1.1.53): the reply names a level (1-4) AND the document's
+ *  object (case-insensitive). */
+export function isLevelDecisionFor(trimmed, last) {
+    return /\blevel\s*[1-4]\b/i.test(trimmed) && trimmed.toUpperCase().includes(last.object.toUpperCase());
+}
 /** Today's continuation predicate (repl.tsx Ink + classic paths), as one
- *  function: the skill that keeps the turn, or null. */
+ *  function: the skill that keeps the turn, or null. A level decision for the
+ *  last change options object goes back to the skill that showed it (only the
+ *  skills-lane call sites pass lastChangeOptions). */
 export function wantsContinuation(i) {
+    if (i.lastChangeOptions && isLevelDecisionFor(i.trimmed, i.lastChangeOptions))
+        return i.lastChangeOptions.skill;
     if (!i.sessionSkill)
         return null;
     return (i.awaitingSkillAnswer || (i.resumedSkill !== null && isShortFollowUp(i.trimmed)) || isAckContinuation(i.trimmed, i.sessionSkill)) ? i.sessionSkill : null;

package/dist/repl.js

@@ -205,6 +205,7 @@ import './tools/project/team_findings.js';
 import './tools/project/team_estate.js';
 import './tools/project/rules_propose.js';
 import './tools/project/team_lane_move.js';
+import './tools/project/spec_answers_record.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
@@ -1409,6 +1410,7 @@ export async function runRepl(opts) {
                         userMessage: rr.prompt,
                         skill: rr.skill,
                         ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !!process.stdin.isTTY, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !!process.stdin.isTTY), turnBy: lastTurnBy },
+                        ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                         chunkEmitter,
                         pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                         autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
@@ -1638,7 +1640,7 @@ export async function runRepl(opts) {
                 // Round 6 item 4c / review I2 — after a resume, a short follow-up
                 // ("continue", a number) stays in the session's skill; anything else
                 // is classified (applyResumedSkill below).
-                const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+                const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill, lastChangeOptions: session.lastChangeOptions ?? null });
                 if (continuedSkill) {
                     chunkEmitter.emit('chunk', formatRoutingLine({ kind: 'continuing', skill: continuedSkill }));
                     skill = continuedSkill;
@@ -2116,6 +2118,7 @@ export async function runRepl(opts) {
                     skill: skill,
                     // Stage 1A — inline is decided here, at every submit, from today's inputs (never cached).
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: inkPreview, chunkEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !!process.stdin.isTTY, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !!process.stdin.isTTY), turnBy: lastTurnBy },
+                    ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                     chunkEmitter,
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     explicitSlash: parsed.skill !== undefined, // Task 7 R11 — typed or queued slash command
@@ -2347,6 +2350,8 @@ export async function runRepl(opts) {
                             tokensUsed: 0,
                             model: session.model,
                             emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                            ...(signedInAs ? { operator: signedInAs } : {}),
+                            sessionId: session.id,
                         });
                     }
                     else if (r.kind === 'none' && !(await import('./sap/reachability-state.js')).isSapUnreachableNoted()) {
@@ -3526,6 +3531,7 @@ export async function runRepl(opts) {
                     userMessage: rr.prompt,
                     skill: rr.skill,
                     ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !pipedStdin, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !pipedStdin), turnBy: lastTurnBy },
+                    ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                     pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                     autoCompact: true, // Task 19 — top-level REPL turn: auto-compact gate at turn end
                 }),
@@ -3833,7 +3839,7 @@ export async function runRepl(opts) {
                 continue;
             }
             // Round 6 item 4c / review I2 — see the Ink path.
-            const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill });
+            const continuedSkill = wantsContinuation({ trimmed, sessionSkill: session.skill, awaitingSkillAnswer: session.awaitingSkillAnswer, resumedSkill, lastChangeOptions: session.lastChangeOptions ?? null });
             if (continuedSkill) {
                 console.log(formatRoutingLine({ kind: 'continuing', skill: continuedSkill }).trimEnd());
                 skill = continuedSkill;
@@ -4269,6 +4275,7 @@ export async function runRepl(opts) {
                 skill: skill,
                 // Stage 1A — inline is decided here, at every submit, from today's inputs (never cached).
                 ctx: { adt, sapAlias: selectedAlias, session, cwd: process.cwd(), provider, skillSource: provider.skillSource, previewHook: replPreviewHook, chunkEmitter: classicOutputEmitter, todoEmitter, currentTransport: currentTransportAccessor, pendingDispatch: pendingDispatchAccessor, inlineSkills: inlineActive({ skills: cfg.assistant.skills, lane: laneSetting, interactive: !pipedStdin, served: inlineServed(cfg.llm?.mode) }), chatLaneProcess: isChatLaneProcess(laneSetting, !pipedStdin), turnBy: lastTurnBy },
+                ...(signedInAs ? { operator: signedInAs } : {}), // change options: Prepared for
                 pushSpend: true, // F-L2-2 — top-level REPL turn: live statusline spend
                 explicitSlash: parsed.skill !== undefined, // Task 7 R11 — typed or queued slash command
                 signal: turnAbort.signal,
@@ -4462,6 +4469,8 @@ export async function runRepl(opts) {
                         tokensUsed: 0,
                         model: session.model,
                         emit: (line) => console.log(line),
+                        ...(signedInAs ? { operator: signedInAs } : {}),
+                        sessionId: session.id,
                     });
                 }
                 else if (r.kind === 'none' && !(await import('./sap/reachability-state.js')).isSapUnreachableNoted()) {