@cspeach/cli 1.1.51 → 1.1.53

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;
     }
@@ -398,7 +425,12 @@ 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.
+        // 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');
         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;
@@ -101,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/steering-echo.js

@@ -1,8 +1,8 @@
 // src/renderer/steering-echo.ts
 //
-// The receipt a mid-turn message leaves in scrollback (spec §7). ONE themed
-// helper for both echo paths: App.beginSubmit (ui/app.tsx) and the fallback
-// in repl.tsx handleSubmit for callers that bypass beginSubmit.
+// How a mid-turn message is shown (spec §7). LT-15 Feature 1 (D5): typing it
+// leaves no scrollback receipt any more; the App's live queue row shows it
+// while it waits, and the loop prints "↳ read · …" when the model reads it.
 import { paint } from './theme.js';
 import { sanitizeControlChars } from './sanitize.js';
 /** Wave1 fast-follow — only the first line, clipped, with a line count. */
@@ -20,12 +20,57 @@ export function formatSteeringEcho(text) {
     return out;
 }
 /**
- * `↳ queued · <first line…>` in the dim role, newline-terminated. The text may
- * come from a paste, so control characters are neutralised before it reaches
- * scrollback.
+ * One waiting or read message as shown: first line, clipped, no control
+ * characters, and each tab as one space (a tab is 0 wide to string-width, so
+ * Ink's truncate-end would cut too late and the line could wrap).
  */
-export function steeringEchoLine(text) {
-    return paint('dim', `↳ queued · ${sanitizeControlChars(formatSteeringEcho(text))}`) + '\n';
+function shownSteer(text) {
+    return sanitizeControlChars(formatSteeringEcho(text)).replace(/\t/g, ' ');
+}
+/**
+ * LT-15 Feature 1 (D5, F7) — the receipt the loop prints when the model reads
+ * a waiting message: `↳ read · <first line…>` in the dim role, one line per
+ * message (the caller adds the newline). The text may come from a paste, so
+ * it is clipped and control characters are neutralised.
+ */
+export function steeringReadLine(text) {
+    return paint('dim', `↳ read · ${shownSteer(text)}`);
+}
+/** The queue row shows at most this many messages; the rest are counted. */
+export const QUEUE_ROW_MAX_ITEMS = 3;
+/**
+ * LT-15 Feature 1 — the live row's lines (plain text, one terminal row each;
+ * App paints them dim and truncates to the width). Empty queue → no lines.
+ *
+ *   4 waiting · use ZPKG
+ *             · also check the tests… (+1 line)
+ *             · and the docs
+ *             + 1 more
+ *
+ * `maxLines` is the room left in the live area. When the full row does not
+ * fit it folds to ONE line, never fewer: `4 waiting · use ZPKG + 3 more`.
+ *
+ * LT-15 Feature 2 (review I6) — `canEdit` adds `· ↑ to edit` right after the
+ * count, only while ↑ would really take the last message back (the App
+ * decides). It sits before the messages so a long message never cuts it off.
+ * Without it the bytes are exactly the Task 2 ones.
+ */
+export function formatQueueRow(items, maxLines = Infinity, opts = {}) {
+    if (items.length === 0)
+        return [];
+    const count = `${items.length} waiting${opts.canEdit ? ' · ↑ to edit' : ''}`;
+    const full = Math.min(items.length, QUEUE_ROW_MAX_ITEMS) + (items.length > QUEUE_ROW_MAX_ITEMS ? 1 : 0);
+    if (full > Math.max(1, maxLines)) {
+        return [`${count} · ${shownSteer(items[0])} + ${items.length - 1} more`];
+    }
+    const head = `${count} `;
+    const pad = ' '.repeat(head.length);
+    const shown = items.slice(0, QUEUE_ROW_MAX_ITEMS);
+    const lines = shown.map((t, i) => `${i === 0 ? head : pad}· ${shownSteer(t)}`);
+    const rest = items.length - shown.length;
+    if (rest > 0)
+        lines.push(`${pad}+ ${rest} more`);
+    return lines;
 }
 export function classifyMidTurnLine(text) {
     const first = text.trim().split(/\s+/)[0] ?? '';

package/dist/renderer/tool-labels.js

@@ -1,4 +1,5 @@
 import { spillLabelFor } from '../lib/spill-labels.js';
+import { writtenObjectName } from '../approvals/op-labels.js';
 const OBJECT_MAX = 60;
 /**
  * Every value shown in a label goes through here: ANSI escape sequences and
@@ -108,7 +109,8 @@ const RULES = {
     },
     background_run: (a) => ({ verb: 'Started', object: shortRight(commandLine(a)) }),
     sap_get_source: sapObject('Read'),
-    sap_set_source: sapObject('Wrote'),
+    // LT-11 — an access control, metadata extension or behavior definition names its kind.
+    sap_set_source: (a) => ({ verb: 'Wrote', object: shortRight(writtenObjectName(str(a['type']), str(a['name']) ?? '')) }),
     sap_activate: (a) => ({ verb: 'Activated', object: shortRight(activateObject(a)) }),
     sap_syntax_check: sapObject('Checked syntax'),
     sap_atc_run: sapObject('Ran ATC on'),
@@ -166,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(' ')) }),
@@ -287,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;
@@ -113,8 +122,11 @@ export function turnStatusLabel(skill) {
 }
 /** D11 — the one dim line shown in place of the echo when the message re-runs through today's router. */
 export const CHAT_UNAVAILABLE_LINE = "Chat isn't available on this server yet — using skill routing.";
-export function chatFallbackOrigin() {
-    return { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE };
+export function chatFallbackOrigin(prose = false) {
+    // LT-15 Task 4 fix round 1 — a withdrawn prose replay re-runs as prose.
+    return prose
+        ? { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE, prose: true }
+        : { by: 'chat_fallback', line: CHAT_UNAVAILABLE_LINE };
 }
 /**
  * The one place a process lane's tool side effect is applied (D5, §6.1).

package/dist/repl/inline-mode.js

@@ -0,0 +1,51 @@
+// cspeach-cli/src/repl/inline-mode.ts
+//
+// Stage 1A, Task 1A.1 — when `assistant.skills = inline` is active.
+//
+// Decided at EVERY submit from the inputs as they are then (rev 4 M4), never
+// cached, never stored in the session file: a resumed session re-decides from
+// today's config and today's proxy. The history is NOT an input (rev 5 S-B):
+// `assistant.skills = system`, `/chat off`, a non-TTY and a non-serving proxy
+// always win. The REPL passes the result to the loop as `ctx.inlineSkills`.
+// Piped stdin and one-shot never get it; reader and agent_run children never
+// carry it (their ctx is built field by field).
+import { servedInlineSkills } from '../models/server-config.js';
+/** True only for `skills = inline` in the chat lane, on a TTY, where the provider can serve it. */
+export function inlineActive({ skills, lane, interactive, served }) {
+    return interactive && served && skills === 'inline' && lane === 'chat';
+}
+/**
+ * Can this provider serve the inline system block? Managed: only when the
+ * proxy's served config says `inline_skills: true` (an old proxy, the kill
+ * switch or a stale cache ⇒ false). byok / ai-hub / azure / local build the
+ * system block on the laptop ⇒ true. Read at submit time: the served config
+ * loads after the config is read at startup.
+ */
+export function inlineServed(mode) {
+    if (mode === undefined)
+        return false;
+    return mode === 'managed' ? servedInlineSkills() : true;
+}
+/**
+ * The `config show` comment for a stored `inline` that would not be active in
+ * an interactive session; null when there is nothing to say.
+ */
+export function inlineInactiveReason(i) {
+    if (i.skills !== 'inline')
+        return null;
+    if (i.lane !== 'chat')
+        return 'not active: skill routing is on';
+    if (!i.served)
+        return 'not active: this server does not serve it';
+    return null;
+}
+/**
+ * Stage 1A, Task 1A.2 (S5) — an interactive chat-lane process: lane `chat` and
+ * a TTY, the condition applyLaneTools uses, whatever `assistant.skills` and the
+ * proxy say. In such a process the loop neutralises `<skill`, `<playbook` and
+ * `<session_context` in what the person sends (ctx.chatLaneProcess). Decided
+ * at every turn site like inlineActive.
+ */
+export function isChatLaneProcess(lane, interactive) {
+    return lane === 'chat' && interactive;
+}

package/dist/repl/leftover.js

@@ -0,0 +1,90 @@
+/**
+ * LT-15 Feature 4 — messages typed while CSPeach worked that are still
+ * waiting when a dispatch ends (Ink REPL only; classic, headless and one-shot
+ * never queue anything).
+ *
+ * The runner holds the per-dispatch flags (plan review I4): a Ctrl+C press,
+ * a turn error, a scheduled hop. They are set during the dispatch, read ONCE
+ * by `settle` at that dispatch's end (handleSubmit's finally, after release,
+ * or a restore's end), and reset right there, so a stale flag can never touch
+ * the next hop or turn.
+ *
+ * `settle` acts on leftoverDecision:
+ *  - run:      on the next tick, drain the queue THERE (a message typed
+ *              between the end and the tick rides along) and submit it once
+ *              as the person's prose. Nothing when a dispatch is already busy
+ *              (that turn reads the queue at its round 0, or its own end
+ *              decides) or the session is ending (I4.1, I4.3).
+ *  - to-input: ask the App to put the text back into the input box (D1, I5).
+ *  - wait / report-unsent / none: touch nothing. A queued hop reads the
+ *              message at its round 0 (D3); the exit reports what is left.
+ * Every message ends in exactly one place (I1.1).
+ */
+import { drainSteering, drainSteeringText, steeringSnapshot } from '../agent/steering-queue.js';
+import { leftoverDecision, unsentLine } from '../ui/interrupt.js';
+import { formatInfo } from '../renderer/notice-shape.js';
+import { parseShortcut } from '../router/classifier.js';
+export function createLeftoverRunner(deps) {
+    let ctrlCStop = false;
+    let errorEnd = false;
+    let dispatchScheduled = false;
+    const reset = () => {
+        ctrlCStop = false;
+        errorEnd = false;
+        dispatchScheduled = false;
+    };
+    return {
+        noteCtrlC() { ctrlCStop = true; },
+        noteError() { errorEnd = true; },
+        noteDispatchScheduled() { dispatchScheduled = true; },
+        reset,
+        settle(s) {
+            const decision = leftoverDecision({
+                done: deps.isDone(),
+                exitRequested: s.exitRequested,
+                forceExit: s.forceExit === true,
+                ctrlCStop,
+                braked: s.braked === true,
+                errorEnd,
+                dispatchScheduled,
+                restoreActive: s.restoreActive === true,
+                waiting: steeringSnapshot().length,
+            });
+            reset();
+            if (decision === 'run') {
+                deps.schedule(() => {
+                    if (deps.isDone() || deps.isBusy())
+                        return;
+                    const text = drainSteeringText();
+                    if (text !== null)
+                        deps.submit(text);
+                });
+            }
+            else if (decision === 'to-input') {
+                deps.toBox();
+            }
+            return decision;
+        },
+        toBoxOrReport() {
+            if (steeringSnapshot().length === 0)
+                return;
+            deps.toBox();
+            const left = drainSteering();
+            if (left.length > 0)
+                deps.print(formatInfo(unsentLine(left.length)));
+        },
+    };
+}
+/** At exit: drain what still waits and return the one line to print, or null. */
+export function takeUnsentReport() {
+    const left = drainSteering();
+    return left.length > 0 ? formatInfo(unsentLine(left.length)) : null;
+}
+/**
+ * LT-15 F4 — how a submitted line is read. A replayed waiting message is
+ * prose: never a slash command or an @-shortcut, so "/sap/bc/adt/x is slow"
+ * reaches the model as text. Anything typed at the prompt is read as today.
+ */
+export function parseSubmitted(input, prose) {
+    return prose ? { prompt: input } : parseShortcut(input);
+}