@cspeach/cli 1.1.52 → 1.1.53

package/dist/project-context/index-files.js

@@ -35,6 +35,15 @@ import * as path from 'node:path';
 const MAX_FILES_TRAVERSED = 10_000;
 /** Cap on paths shipped in FileIndex. Selected by relevance. */
 const MAX_PATHS_IN_INDEX = 500;
+/**
+ * 1.1.53 item 12 — budget on entries (files AND folders) the walk looks at.
+ * %TEMP% held ~283,000 empty folders: the file cap never fired and the walk
+ * opened every one (~10 s). Spent ⇒ the walk stops and the index is cut.
+ * Measured there: 20,000 took ~2.4 s, 5,000 ~0.95 s (with two root reads).
+ * Controller ruling: 12,000, so a real project (an abapGit export of
+ * thousands of files) keeps its full picture up to the 10,000-file cap.
+ */
+export const MAX_ENTRIES_VISITED = 12_000;
 const ALWAYS_SKIPPED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -71,14 +80,32 @@ const SOURCE_EXTENSIONS = new Set([
  * IO errors during the walk are silently skipped (the offending dir/file
  * just doesn't contribute to the count). Never throws.
  */
-export async function indexFiles(cwd) {
+export async function indexFiles(cwd, options = {}) {
+    const maxEntries = options.maxEntries ?? MAX_ENTRIES_VISITED;
+    let entriesLeft = maxEntries;
+    let walkCut = false;
     const ignoreMatchers = await loadIgnoreMatchers(cwd);
-    /** Files collected with their stat info — used to rank for the path list. */
+    /**
+     * Files collected with their stat info — used to rank for the path list.
+     * `order` is the file's place in a plain depth-first walk (the readdir
+     * index at each level), so the output keeps today's order although the
+     * walk now visits each level's files before its folders.
+     */
     const collected = [];
-    const byExtension = {};
     let totalFiles = 0;
     let truncated = false;
-    async function walk(dir, relPrefix) {
+    let rootEntries = null;
+    /** One entry of the budget; false (and the walk marked cut) once it is spent. */
+    function spend() {
+        if (entriesLeft <= 0) {
+            walkCut = true;
+            truncated = true;
+            return false;
+        }
+        entriesLeft--;
+        return true;
+    }
+    async function walk(dir, relPrefix, order) {
         if (truncated)
             return;
         let entries;
@@ -88,45 +115,68 @@ export async function indexFiles(cwd) {
         catch {
             return;
         }
-        for (const ent of entries) {
+        // The root listing is kept for the top-level list (one read, not two).
+        if (relPrefix === '')
+            rootEntries = entries;
+        // 1.1.53 item 12 (fix round 3) — this level's files first, then its
+        // folders: one big early folder can no longer spend the entries budget
+        // before a spec or plan file at this level is seen.
+        for (let i = 0; i < entries.length; i++) {
+            const ent = entries[i];
+            if (ent.isDirectory())
+                continue;
             if (truncated)
                 return;
+            if (!spend())
+                return;
+            if (!ent.isFile())
+                continue;
             const relPath = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
-            if (ent.isDirectory()) {
-                if (ALWAYS_SKIPPED_DIRS.has(ent.name))
-                    continue;
-                if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ true))
-                    continue;
-                await walk(path.join(dir, ent.name), relPath);
+            if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ false))
+                continue;
+            if (totalFiles >= MAX_FILES_TRAVERSED) {
+                truncated = true;
+                return;
             }
-            else if (ent.isFile()) {
-                if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ false))
-                    continue;
-                if (totalFiles >= MAX_FILES_TRAVERSED) {
-                    truncated = true;
-                    return;
-                }
-                totalFiles++;
-                const ext = extOf(ent.name);
-                byExtension[ext] = (byExtension[ext] ?? 0) + 1;
-                // Read mtime cheaply; on error use 0 so the file sorts late.
-                let mtime = 0;
-                try {
-                    const s = await fs.stat(path.join(dir, ent.name));
-                    mtime = s.mtimeMs;
-                }
-                catch {
-                    // ignore
-                }
-                collected.push({ path: relPath, ext, mtime });
+            totalFiles++;
+            // Read mtime cheaply; on error use 0 so the file sorts late.
+            let mtime = 0;
+            try {
+                const s = await fs.stat(path.join(dir, ent.name));
+                mtime = s.mtimeMs;
             }
+            catch {
+                // ignore
+            }
+            collected.push({ path: relPath, ext: extOf(ent.name), mtime, order: [...order, i] });
+        }
+        for (let i = 0; i < entries.length; i++) {
+            const ent = entries[i];
+            if (!ent.isDirectory())
+                continue;
+            if (truncated)
+                return;
+            if (!spend())
+                return;
+            if (ALWAYS_SKIPPED_DIRS.has(ent.name))
+                continue;
+            const relPath = relPrefix ? `${relPrefix}/${ent.name}` : ent.name;
+            if (matchesIgnore(ignoreMatchers, relPath, /* isDirectory */ true))
+                continue;
+            await walk(path.join(dir, ent.name), relPath, [...order, i]);
         }
     }
-    await walk(cwd, '');
+    await walk(cwd, '', []);
+    // Back to the plain depth-first order, so the counts and the ranking below
+    // see the files in exactly today's order.
+    collected.sort((a, b) => compareOrder(a.order, b.order));
+    const byExtension = {};
+    for (const f of collected)
+        byExtension[f.ext] = (byExtension[f.ext] ?? 0) + 1;
     // Top-level dirs that survived the walk (i.e. weren't skipped).
     let topLevelDirs = [];
     try {
-        const topLevel = await fs.readdir(cwd, { withFileTypes: true });
+        const topLevel = rootEntries ?? await fs.readdir(cwd, { withFileTypes: true });
         topLevelDirs = topLevel
             .filter((e) => e.isDirectory() && !ALWAYS_SKIPPED_DIRS.has(e.name) && !matchesIgnore(ignoreMatchers, e.name, true))
             .map((e) => e.name)
@@ -144,13 +194,26 @@ export async function indexFiles(cwd) {
         return b.mtime - a.mtime;
     });
     const paths = collected.slice(0, MAX_PATHS_IN_INDEX).map((f) => f.path);
-    return {
+    const index = {
         totalFiles,
         byExtension,
         topLevelDirs,
         paths,
         truncated,
     };
+    // Only a cut walk carries the field, so every other index is the same object as before.
+    if (walkCut)
+        index.walkCut = true;
+    return index;
+}
+/** Lexicographic order of two readdir-index paths (depth-first order). */
+function compareOrder(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    }
+    return a.length - b.length;
 }
 async function loadIgnoreMatchers(cwd) {
     const patterns = [];

package/dist/project-context/index.js

@@ -29,7 +29,7 @@ import { extractCap } from './domain/cap.js';
 import { extractFiori } from './domain/fiori.js';
 import { getGitState } from './git.js';
 import { indexFiles } from './index-files.js';
-export { renderProjectContext } from './render.js';
+export { renderProjectContext, renderProjectContextCapped } from './render.js';
 /**
  * Compute the full project context for a directory. Best-effort: returns
  * null on hard failure (e.g. cwd doesn't exist), otherwise an envelope

package/dist/project-context/render.js

@@ -31,6 +31,12 @@ const CAP_CAP_ENTITIES = 60;
 const CAP_ABAP_OBJECTS = 80;
 const CAP_GIT_COMMITS = 5;
 const CAP_RECENT_OBJECTS = 10;
+/** 1.1.53 item 12 — %TEMP% had ~283,000 top-level folders (a 4.37M-char line). */
+export const CAP_TOP_LEVEL_DIRS = 40;
+export const CAP_NAMING = 20;
+/** Hard ceiling on the whole block, whatever the folder holds. */
+export const PROJECT_CONTEXT_MAX_CHARS = 24_000;
+const CUT_TAIL = '\n  <cut>The folder is very large; this picture was shortened.</cut>\n</project_context>';
 /**
  * Render a ProjectContext as prompt text. The result is a self-contained
  * <project_context> XML-ish block ready to splice into a system prompt.
@@ -38,6 +44,28 @@ const CAP_RECENT_OBJECTS = 10;
  * unconditionally.
  */
 export function renderProjectContext(ctx) {
+    return renderProjectContextCapped(ctx).block;
+}
+/**
+ * The block plus whether it was cut. A block over PROJECT_CONTEXT_MAX_CHARS
+ * is cut at the last line end that keeps it (with the closing note) under
+ * the cap; a block within the cap is returned unchanged.
+ */
+export function renderProjectContextCapped(ctx) {
+    const full = renderFull(ctx);
+    const walkCut = ctx?.index.walkCut === true;
+    if (full.length <= PROJECT_CONTEXT_MAX_CHARS) {
+        if (!walkCut)
+            return { block: full, cut: false };
+        // The walk stopped early: same note, in place of the closing tag.
+        return { block: full.slice(0, full.length - '\n</project_context>'.length) + CUT_TAIL, cut: true };
+    }
+    const room = PROJECT_CONTEXT_MAX_CHARS - CUT_TAIL.length;
+    const lastNl = full.lastIndexOf('\n', room);
+    const head = lastNl > 0 ? full.slice(0, lastNl) : full.slice(0, room);
+    return { block: head + CUT_TAIL, cut: true };
+}
+function renderFull(ctx) {
     if (!ctx)
         return '';
     const parts = [];
@@ -66,13 +94,13 @@ function renderConventions(c) {
     if (c.namingPatterns.classes.length || c.namingPatterns.interfaces.length || c.namingPatterns.cdsViews.length) {
         lines.push('    <naming>');
         if (c.namingPatterns.classes.length) {
-            lines.push(`      <classes>${escapeXml(c.namingPatterns.classes.join(', '))}</classes>`);
+            lines.push(`      <classes>${escapeXml(cappedList(c.namingPatterns.classes, CAP_NAMING))}</classes>`);
         }
         if (c.namingPatterns.interfaces.length) {
-            lines.push(`      <interfaces>${escapeXml(c.namingPatterns.interfaces.join(', '))}</interfaces>`);
+            lines.push(`      <interfaces>${escapeXml(cappedList(c.namingPatterns.interfaces, CAP_NAMING))}</interfaces>`);
         }
         if (c.namingPatterns.cdsViews.length) {
-            lines.push(`      <cds_views>${escapeXml(c.namingPatterns.cdsViews.join(', '))}</cds_views>`);
+            lines.push(`      <cds_views>${escapeXml(cappedList(c.namingPatterns.cdsViews, CAP_NAMING))}</cds_views>`);
         }
         lines.push('    </naming>');
     }
@@ -149,7 +177,7 @@ function renderFileIndex(ctx) {
         `  <file_index total="${idx.totalFiles}"${idx.truncated ? ' truncated="true"' : ''}>`,
     ];
     if (idx.topLevelDirs.length) {
-        lines.push(`    <top_level_dirs>${escapeXml(idx.topLevelDirs.join(', '))}</top_level_dirs>`);
+        lines.push(`    <top_level_dirs>${escapeXml(cappedList(idx.topLevelDirs, CAP_TOP_LEVEL_DIRS))}</top_level_dirs>`);
     }
     const extEntries = Object.entries(idx.byExtension).sort((a, b) => b[1] - a[1]);
     if (extEntries.length) {
@@ -293,6 +321,12 @@ function renderAbapCloud(objects, bdefs) {
     return lines.join('\n');
 }
 /* ── Helpers ───────────────────────────────────────────────────────── */
+/** The first `cap` items joined, then ` (… N more)`; a list within the cap joins as before. */
+function cappedList(items, cap) {
+    if (items.length <= cap)
+        return items.join(', ');
+    return `${items.slice(0, cap).join(', ')} (… ${items.length - cap} more)`;
+}
 function escapeXml(text) {
     return text
         .replace(/&/g, '&amp;')

package/dist/projects/answer-blockers.js

@@ -1,7 +1,7 @@
-import { writeFileSync } from 'node:fs';
+import { renameSync, rmSync, writeFileSync } from 'node:fs';
 import { readProjectFile } from './status.js';
 import { validateEnvelope } from './validate.js';
-import { askYesNo } from './yes-no.js';
+import { askYesNo, isYes } from './yes-no.js';
 /**
  * The still-open BLOCKER-severity questions of a spec-gap envelope, in item
  * order. Returns [] for any non-spec-gap artefact (only spec-gap has gaps with
@@ -59,6 +59,33 @@ export function applyBlockerAnswers(env, answers, answerer, nowIso) {
         lastEditedBy: answerer,
     };
 }
+/**
+ * Task 18 (F-O, 2026-10-26) — the one save step shared by the blocker form
+ * (offerAnswerBlockers) and the spec_answers_record tool: fold the answers in
+ * (applyBlockerAnswers), validate the revised envelope, then write it in
+ * place. Nothing is written when validation fails.
+ */
+export function saveBlockerAnswers(path, env, answers, answerer, nowIso) {
+    const revised = applyBlockerAnswers(env, answers, answerer, nowIso);
+    const check = validateEnvelope(JSON.parse(JSON.stringify(revised)));
+    if (!check.ok)
+        return { ok: false, error: check.error.message };
+    // Fix round 1 (item 6): atomic — a temp file in the same folder, then a
+    // rename over the spec file, so a crash never leaves half a file.
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tmp, JSON.stringify(revised, null, 2), 'utf8');
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch { /* best effort */ }
+        throw err;
+    }
+    return { ok: true, revised };
+}
 function plural(n, word) {
     return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
@@ -66,6 +93,29 @@ function affirmative(reply) {
     const v = reply.trim().toLowerCase();
     return v === 'y' || v === 'yes';
 }
+/**
+ * Task 15 (F-K, 2026-10-26): whether a picked answer is made only of the
+ * blocker's own options (one option, or for a multi-select the ticked
+ * options joined by ", " in any order). Anything else was typed.
+ */
+function isOnlyOptions(answer, options, multiSelect) {
+    if (options.includes(answer))
+        return true;
+    if (!multiSelect)
+        return false;
+    let rest = answer;
+    while (rest.length > 0) {
+        const o = options.find((x) => rest === x || rest.startsWith(`${x}, `));
+        if (!o)
+            return false;
+        rest = rest === o ? '' : rest.slice(o.length + 2);
+    }
+    return true;
+}
+/** A typed reply that ends in "?" reads like a question back to us, not an answer. */
+function readsLikeQuestion(typed) {
+    return typed.trim().endsWith('?');
+}
 /**
  * Offer to answer the open blockers of the just-saved spec-gap file inline.
  * No-op (no prompt) when the file isn't a spec-gap or has no open blockers, so
@@ -95,13 +145,48 @@ export async function offerAnswerBlockers(args) {
     if (!affirmative(reply))
         return null;
     const answers = new Map();
-    for (let i = 0; i < blockers.length; i++) {
+    const outcomes = new Map(blockers.map((b) => [b.id, 'not-asked']));
+    let stop = false;
+    for (let i = 0; i < blockers.length && !stop; i++) {
         const b = blockers[i];
-        // The "Blocker i of n: …" line is printed only on the free-text fallback
-        // below. The picker shows the question itself and leaves its own trace.
+        // The "Blocker i of n: …" line is printed on the free-text fallback
+        // below, and once when a typed question-like reply is not saved (Task 15).
+        // Otherwise the picker shows the question itself and leaves its own trace.
         // The picker first, for every blocker (options or free text).
         // 'write' falls through to the text box; 'skip' leaves the blocker open.
         let askText = true;
+        let shownQuestion = false;
+        outcomes.set(b.id, 'skipped');
+        // A typed reply (not a picked option) that ends in "?" is checked once
+        // before it is saved. On No it stays open: one "Not saved" line, then the
+        // full question once. The Yes/No card answers '' only when cancelled
+        // (Ctrl+C; Enter gives its default, No), which stops the form like the
+        // picker's 'stop'. Without a card (prompt only), '' is Enter = No.
+        const keepTyped = async (typed) => {
+            if (!readsLikeQuestion(typed))
+                return true;
+            const reply = await askYesNo({
+                question: 'That reads like a question, not an answer. Save it as the answer?',
+                confirm: args.confirm,
+                prompt: args.prompt,
+            });
+            if (isYes(reply))
+                return true;
+            if (args.confirm && reply === '') {
+                outcomes.set(b.id, 'stopped');
+                stop = true;
+                return false;
+            }
+            outcomes.set(b.id, 'declined-question');
+            args.log('');
+            args.log('Not saved. The blocker stays open.');
+            if (!shownQuestion) {
+                args.log(`Blocker ${i + 1} of ${blockers.length}: ${b.text}`);
+                shownQuestion = true;
+            }
+            return false;
+        };
+        const save = (a) => { answers.set(b.id, a); outcomes.set(b.id, 'answered'); };
         if (args.choose) {
             const c = await args.choose({
                 question: b.text,
@@ -111,8 +196,10 @@ export async function offerAnswerBlockers(args) {
                 total: blockers.length,
             });
             if (c.kind === 'picked') {
-                if (c.answer.trim().length > 0)
-                    answers.set(b.id, c.answer.trim());
+                const a = c.answer.trim();
+                const typed = !isOnlyOptions(a, b.options ?? [], !!b.multiSelect);
+                if (a.length > 0 && (!typed || await keepTyped(a)))
+                    save(a);
                 askText = false;
             }
             else if (c.kind === 'skip') {
@@ -121,6 +208,7 @@ export async function offerAnswerBlockers(args) {
             else if (c.kind === 'stop') {
                 // Ctrl+C (Task 4, m2): ask none of the rest. Answers already given
                 // are kept and saved below; the others stay open.
+                outcomes.set(b.id, 'stopped');
                 break;
             }
             // c.kind === 'write' → askText stays true
@@ -128,31 +216,34 @@ export async function offerAnswerBlockers(args) {
         if (askText) {
             args.log('');
             args.log(`Blocker ${i + 1} of ${blockers.length}: ${b.text}`);
+            shownQuestion = true;
             const a = (await args.prompt('Your answer (Enter to skip): ')).trim();
-            if (a.length > 0)
-                answers.set(b.id, a);
+            if (a.length > 0 && await keepTyped(a))
+                save(a);
         }
     }
     if (answers.size === 0) {
+        // Typed replies were given but not saved: say "saved", not "entered".
+        const verb = [...outcomes.values()].includes('declined-question') ? 'saved' : 'entered';
         args.log('');
         args.log(blockers.length === 1
-            ? 'No answer entered. The blocker stays open. Answer it later at cspeach.dev/edit.'
-            : `No answers entered. The ${blockers.length} blockers stay open. Answer them later at cspeach.dev/edit.`);
+            ? `No answer ${verb}. The blocker stays open. Answer it later at cspeach.dev/edit.`
+            : `No answers ${verb}. The ${blockers.length} blockers stay open. Answer them later at cspeach.dev/edit.`);
+        args.onOutcomes?.(outcomes);
         return null;
     }
     const nowIso = (args.now ?? (() => new Date().toISOString()))();
-    const revised = applyBlockerAnswers(env, answers, args.identity, nowIso);
-    const check = validateEnvelope(JSON.parse(JSON.stringify(revised)));
-    if (!check.ok) {
-        args.log(`[answer] revision invalid (${check.error.message}) — answers NOT saved.`);
+    const saved = saveBlockerAnswers(args.path, env, answers, args.identity, nowIso);
+    if (!saved.ok) {
+        args.log(`[answer] revision invalid (${saved.error}) — answers NOT saved.`);
         return null;
     }
-    writeFileSync(args.path, JSON.stringify(revised, null, 2), 'utf8');
     const stillOpen = blockers.length - answers.size;
     args.log('');
     args.log(`Recorded ${plural(answers.size, 'answer')} in the file.`
         + (stillOpen === 0 ? ''
             : stillOpen === 1 ? ' 1 blocker is still open. Answer it later at cspeach.dev/edit.'
                 : ` ${stillOpen} blockers are still open. Answer them later at cspeach.dev/edit.`));
+    args.onOutcomes?.(outcomes);
     return answers.size;
 }

package/dist/projects/blocker-answers-note.js

@@ -0,0 +1,89 @@
+import { basename, isAbsolute, relative, sep } from 'node:path';
+import { INJECTED_CONTEXT_TAGS } from '../session/user-prompt.js';
+import { teamWorkRoot } from '../tools/_team-work-path.js';
+import { readProjectFile } from './status.js';
+/**
+ * Task 16 (F-M, 2026-10-26) — the note the model gets on its next call after
+ * the blocker form ran. The form runs after the model's turn and writes only
+ * to the spec file, so without this the model offers to ask the same
+ * blockers again. One short note: each blocker with its answer or "still
+ * open", the spec file's name and folder-relative path (so the model reads it
+ * with the normal read tool, not a shell walk), and how further answers are
+ * recorded. The agent loop wraps it in `<blocker_answers>` inside
+ * `<session_context>` (CLI context: never shown, left out of exports).
+ */
+/** The tool that records further answers (Task 18); loop.ts surfaces it on the note turn. */
+export const SPEC_ANSWERS_RECORD_TOOL = 'spec_answers_record';
+/** The closing sentence. Task 18 adds the spec_answers_record tool and checks this text. */
+export const SPEC_ANSWERS_RECORD_SENTENCE = 'Further answers can be recorded with the spec_answers_record tool, never by editing the file.';
+const QUESTION_MAX = 80;
+const ANSWER_MAX = 200;
+/** One line, clipped to `max` characters with an ellipsis. */
+function clip(text, max) {
+    const one = text.replace(/\s*[\r\n]+\s*/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 1).trimEnd()}…` : one;
+}
+/** Every tag the CLI writes into a prompt (fix round 1, M-2): the shared list plus <playbook>. */
+const CLI_TAG = new RegExp(`<(/?)(${[...INJECTED_CONTEXT_TAGS, 'playbook'].join('|')})(?=[\\s>/])`, 'gi');
+/** A question or answer cannot close the note block or open a block the CLI writes. */
+function neutral(text) {
+    return text.replace(CLI_TAG, '‹$1$2');
+}
+/**
+ * The path as the read tool opens it from `cwd` (fix round 1). In a team
+ * folder a save lands in the seat (<CSPEACH_HOME>/work/<id>/.cspeach), and
+ * file_read maps `.cspeach/<name>.cspeach.json` there (teamReadTarget), so the
+ * path is given relative to the seat root. Otherwise relative to `cwd`.
+ */
+function readToolPath(cwd, file) {
+    const seat = teamWorkRoot(cwd);
+    const fromSeat = seat ? relative(seat, file) : '';
+    const inSeat = fromSeat !== '' && !fromSeat.startsWith('..') && !isAbsolute(fromSeat);
+    return (inSeat ? fromSeat : relative(cwd, file)).split(sep).join('/');
+}
+/** The note text, or null when there is nothing to say (no outcomes, unreadable file). */
+export function blockerAnswersNote(a) {
+    if (a.outcomes.size === 0)
+        return null;
+    let env;
+    try {
+        env = readProjectFile(a.path);
+    }
+    catch {
+        return null;
+    }
+    if (env.artefactType !== 'spec-gap')
+        return null;
+    const gaps = new Map();
+    for (const s of env.content.sections)
+        for (const g of s.gaps)
+            gaps.set(g.id, g);
+    const items = new Map(env.interaction.items.map((it) => [it.id, it]));
+    const lines = [];
+    const open = [];
+    let n = 0;
+    for (const [id, outcome] of a.outcomes) {
+        n++;
+        const q = neutral(clip(gaps.get(id)?.text ?? id, QUESTION_MAX));
+        const item = items.get(id);
+        const answer = outcome === 'answered' && item?.status === 'answered' && typeof item.answer === 'string'
+            ? item.answer : null;
+        // Final review I-1: each line carries the file's id, so spec_answers_record
+        // gets the id the person means (the form's numbers count only the asked blockers).
+        if (answer === null)
+            open.push(`${n} (${id})`);
+        lines.push(`${n}. ${id} — ${q} → ${answer === null ? 'still open' : neutral(clip(answer, ANSWER_MAX))}`);
+    }
+    const name = basename(a.path);
+    const rel = readToolPath(a.cwd, a.path);
+    const where = `${name} (path: ${rel})`;
+    const lead = open.length < n
+        ? `The developer answered spec-gap blockers in the form. The answers are saved in ${where}.`
+        : `The developer saw the spec-gap blockers in the form and saved no answers. The spec file is ${where}.`;
+    return [
+        lead,
+        ...lines,
+        ...(open.length > 0 ? [`Still open: ${open.join(', ')}.`] : []),
+        SPEC_ANSWERS_RECORD_SENTENCE,
+    ].join('\n');
+}

package/dist/projects/change-options.js

@@ -0,0 +1,70 @@
+// cspeach-cli/src/projects/change-options.ts
+//
+// Change options (2026-10-23): /abap-refactor and /abap-impact wrap the change
+// options document in a marker pair, each on its own line:
+//
+//   <!-- csforge:change-options OBJECT=<NAME> -->
+//   ...the document...
+//   <!-- /csforge:change-options -->
+//
+// The CLI saves only the text between the markers (the TL;DR and the level
+// question stay out). Markers inside a fenced code block are quotes, not a
+// document, and are skipped. An opening with no closing (a cut-off answer)
+// finds nothing, so the turn behaves exactly as it does without a marker.
+// The object name is returned as written; file-name cleanup is the caller's
+// (documentFilename).
+const OPEN_RE = /^<!--\s*csforge:change-options\s+OBJECT=(\S+)\s*-->$/;
+const CLOSE_RE = /^<!--\s*\/csforge:change-options\s*-->$/;
+// 1.1.53: the closing marker may be glued to the end of the last text line
+// ("…cache only.<!-- /csforge:change-options -->"). The text before it stays
+// in the document. Only at the very end of the line, and not inside an open
+// inline code span, so a marker quoted in prose stays a quote.
+const GLUED_CLOSE_RE = /<!--\s*\/csforge:change-options\s*-->$/;
+const FENCE_RE = /^(`{3,}|~{3,})/;
+/**
+ * Every complete marked document in the text, in order. A turn where the
+ * developer picks a level in session carries two: the options, then the same
+ * document shown again with the decision (final review C1). An opening with
+ * no closing finds nothing for that one. No marker: an empty list.
+ */
+export function extractChangeOptions(text) {
+    const lines = (text ?? '').split('\n');
+    let fence = null;
+    let object = null;
+    let start = -1;
+    const found = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const f = line.match(FENCE_RE);
+        if (f) {
+            const mark = f[1];
+            if (fence === null)
+                fence = mark;
+            else if (mark[0] === fence[0] && mark.length >= fence.length && line === mark)
+                fence = null;
+            continue;
+        }
+        if (fence !== null)
+            continue;
+        if (object === null) {
+            const m = line.match(OPEN_RE);
+            if (m) {
+                object = m[1];
+                start = i + 1;
+            }
+        }
+        else if (CLOSE_RE.test(line)) {
+            found.push({ object, markdown: lines.slice(start, i).join('\n').trim() });
+            object = null;
+        }
+        else {
+            const g = GLUED_CLOSE_RE.exec(line);
+            const before = g ? line.slice(0, g.index) : '';
+            if (g && (before.match(/`/g) ?? []).length % 2 === 0) {
+                found.push({ object, markdown: [...lines.slice(start, i), before].join('\n').trim() });
+                object = null;
+            }
+        }
+    }
+    return found;
+}