@cspeach/cli 1.1.51 → 1.1.53

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;
+}

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;
 }
 /**