@cspeach/cli 1.1.52 → 1.1.54

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/builtin-commands.js

@@ -34,6 +34,7 @@ export const BUILTIN_ENTRIES = [
     { name: '/usage', get description() { return usageCommandDescription(); } },
     { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
     { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy: of the last answer (/export docx, or /export docx <name>), of the whole conversation (/export docx conversation) or of a Markdown file (/export docx <file>.md)' },
+    { name: '/files', description: 'Pick a saved project file and what to do with it' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
     { name: '/quit', description: 'Exit CSPeach (alias)' },
@@ -56,9 +57,9 @@ export const BUILTIN_ENTRIES = [
 ];
 /**
  * Builtin command heads for routing checks. Superset of BUILTIN_ENTRIES:
- * `/files` is a real REPL builtin (repl.tsx handles it in both paths) and
- * `/cancel` is still handled by the classic loop, but neither is listed in the
- * picker catalogue, so both are added here.
+ * `/cancel` is still handled by the classic loop but is not listed in the
+ * picker catalogue, so it is added here. (`/files` is listed since 2026-10-27;
+ * it stays here too, harmlessly.)
  */
 const BUILTIN_HEADS = new Set([
     ...BUILTIN_ENTRIES.map((e) => e.name),

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/file-picker.js

@@ -4,7 +4,7 @@
  * UX:
  *   1. Search-as-you-type list of files (filename + artefactType + version)
  *   2. Action menu tailored to the picked artefactType — pick one of:
- *        spec-gap → --status, --from /abap-design
+ *        spec-gap → answer the questions (viewer steps), --from /abap-design, --status
  *        design   → --status, --from /abap-estimate
  *        estimate → --status only
  *        unknown  → all --status variants
@@ -16,10 +16,15 @@
  * slash-picker.ts so cancellation in either step doesn't drop the user
  * back to the parent shell.
  */
+import path from 'node:path';
 import { search, select } from '@inquirer/prompts';
 import { withInquirer } from './inquirer-guard.js';
 import { listProjectFiles, detectDesignShape } from '../projects/workspace.js';
+import { editorLabel } from '../projects/saved-lines.js';
+import { resolveProjectFolderSync } from '../projects/project-folder.js';
 const CANCEL_VALUE = '__cspeach_cancel__';
+/** Spec gap "answer the questions" (2026-10-27): prints the viewer steps, runs nothing. */
+const ANSWER_VALUE = '__cspeach_answer__';
 /**
  * Compute the menu of valid actions for an envelope of a given
  * artefactType. Order: most-common first.
@@ -35,7 +40,8 @@ const CANCEL_VALUE = '__cspeach_cancel__';
 function envelopeActionsFor(type, designShape = 'unknown') {
     if (type === 'spec-gap') {
         return [
-            { label: '/abap-design --from         (promote → design)', command: '/abap-design --from' },
+            { label: 'Answer the questions        (open in cspeach.dev/edit)', command: ANSWER_VALUE },
+            { label: '/abap-design --from         (use the answers → design)', command: '/abap-design --from' },
             { label: '/abap-spec-gap --status     (inspect)', command: '/abap-spec-gap --status' },
         ];
     }
@@ -153,6 +159,46 @@ function textActionsFor() {
  * then dumped the full file list every time the user cancelled. This
  * tagged result removes the conflation.
  */
+/**
+ * The steps printed for "Answer the questions" (2026-10-27): a standalone
+ * customer did not know how to enter answers. The viewer's own button names
+ * (Pick folder, Save back to folder, Download updated file).
+ */
+export function answerStepsText(file, workDir = workFolder()) {
+    const full = path.resolve(file.path);
+    // A file from an earlier location is read-only: its answers go to today's folder.
+    if (file.earlier) {
+        return [
+            'To answer the questions:',
+            `  1. Open ${editorLabel()} and drop ${full} on the page.`,
+            '  2. Type each answer and mark it answered.',
+            `  3. Choose Download updated file and put that file in ${workDir}`,
+            'Then type /files and pick the new version to go on from your answers.',
+        ].join('\n');
+    }
+    const dir = path.dirname(full);
+    return [
+        'To answer the questions:',
+        `  1. Open ${editorLabel()}, choose Pick folder and pick ${dir}`,
+        `  2. Open ${file.filename}, type each answer and mark it answered.`,
+        '  3. Choose Save back to folder. It saves a new version next to this one.',
+        'Then type /files and pick the new version to go on from your answers.',
+        `No Pick folder button (it needs Edge or Chrome)? Drop ${full} on the page instead, choose Download updated file and put that file in ${dir}.`,
+    ].join('\n');
+}
+/** Picked action → result: the answer action prints steps, every other one is a command. */
+function resultFor(action, file) {
+    if (action === ANSWER_VALUE)
+        return { kind: 'info', text: answerStepsText(file) };
+    return { kind: 'command', command: `${action} @${file.filename}` };
+}
+/**
+ * This project's file folder, where saves go — not a file's folder: the list
+ * can hold files from earlier locations (marked `earlier`) after today's.
+ */
+function workFolder() {
+    return path.resolve(resolveProjectFolderSync(process.cwd()).workDir);
+}
 /** Action menu for a picked file (shared by the inquirer and Ink paths). */
 function actionsForFile(file) {
     const designShape = file.artefactType === 'design' ? detectDesignShape(file.path) : 'unknown';
@@ -185,7 +231,7 @@ export async function openFilePicker(opts = {}) {
         return await withInquirer(async () => {
             // Step 1 — pick a file.
             const fileResult = await search({
-                message: 'Pick a project file',
+                message: `Pick a project file (in ${workFolder()})`,
                 source: async (input) => {
                     const filter = (input ?? '').toLowerCase();
                     const filtered = filter.length === 0
@@ -223,7 +269,7 @@ export async function openFilePicker(opts = {}) {
             });
             if (action === CANCEL_VALUE)
                 return { kind: 'cancelled' };
-            return { kind: 'command', command: `${action} @${pickedFile.filename}` };
+            return resultFor(action, pickedFile);
         });
     }
     catch {
@@ -238,6 +284,7 @@ async function openFilePickerInk(files) {
     const picked = await withFocusClaim(() => filesCardEmitter.requestPick({
         id: 'files',
         title: 'Pick a project file',
+        folder: workFolder(),
         items: files.map((f) => ({ value: f.filename, label: f.filename, detail: `${f.artefactType} v${f.version ?? '?'}` })),
     }));
     if (picked.value == null)
@@ -257,5 +304,5 @@ async function openFilePickerInk(files) {
     }, { trace: false });
     if (res.value == null || res.value === CANCEL_VALUE)
         return { kind: 'cancelled' };
-    return { kind: 'command', command: `${res.value} @${pickedFile.filename}` };
+    return resultFor(res.value, pickedFile);
 }

package/dist/repl/mode-cycle.js

@@ -1,4 +1,5 @@
 import { clampToCeiling, modeCeiling, WRITE_MODE_ORDER, } from './mode-ceiling.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
 /**
  * Session-scoped effective write mode + cycling core (UX Wave 1, Task 2).
  *
@@ -29,14 +30,23 @@ export function getSessionWriteMode() {
 }
 /** cfgMode overlaid by session override, then clamped to the alias role's ceiling. */
 export function getEffectiveWriteMode(cfgMode, role) {
+    // Team build Task 6 — a functional seat is pinned at advisory whatever the
+    // config, the role or a session override says.
+    if (isFunctionalSeat())
+        return 'advisory-only';
     return clampToCeiling(sessionWriteMode ?? cfgMode, role);
 }
+/** Team build Task 6 — the /mode answer on a functional seat, for any argument. */
+export const SEAT_MODE_LINE = 'mode stays advisory on this seat — it reads SAP and never changes it';
 /**
  * Cycle to the next mode the role allows (wraps). Sets the session override
  * so the new mode takes effect immediately. Returns the new mode AND whether
  * the requested step was capped (for the refusal line).
  */
 export function cycleWriteMode(cfgMode, role) {
+    // Functional seat: pinned; the session override is left alone.
+    if (isFunctionalSeat())
+        return { mode: 'advisory-only', capped: true };
     const ceilingIdx = WRITE_MODE_ORDER.indexOf(modeCeiling(role));
     // Modes at or below the ceiling, in cycling order (most→least restricted).
     const allowed = WRITE_MODE_ORDER.slice(0, ceilingIdx + 1);
@@ -77,6 +87,8 @@ function refusalLine(clamped, role, alias) {
  * mode (caller pushes it into the SapStateStore so the statusline is live).
  */
 export function runModeCommand(arg, cfgMode, role, alias) {
+    if (isFunctionalSeat())
+        return { line: SEAT_MODE_LINE, mode: 'advisory-only' };
     const prev = getEffectiveWriteMode(cfgMode, role);
     const normalized = arg?.trim().toLowerCase() ?? '';
     if (normalized === '') {

package/dist/repl/open-questions-gate.js

@@ -0,0 +1,159 @@
+/**
+ * Team build (spec 2026-10-25) — open questions travel with a shared spec.
+ *
+ * Before `/abap-app --from @specs/<slug>/<file>` runs in a team build folder,
+ * the spec's open questions (the author's file with the answer records
+ * applied, R11) are shown, BLOCKER first, with one card: answer them now (each
+ * answer a record of its own; the author's file is never rewritten), go ahead
+ * with them open (they ride in the command as assumptions), or stop.
+ *
+ * Anything that is not `/abap-app --from @…` naming a file under the shared
+ * `specs/` returns null: the command goes on exactly as before. The build
+ * folder is the folder CSPeach runs in (R10).
+ */
+import path from 'node:path';
+const PREFIX = /^\/abap-app\s+--from\s+@/;
+export const ANSWER = 'Answer them now';
+export const GO_AHEAD = 'Go ahead with them open';
+export const STOP = 'Stop';
+export const STOPPED_LINE = 'Stopped. The spec stays ready for the developer.';
+/**
+ * R14 — the specs this run marked "being built" from the start screen. A Stop
+ * at the gate puts such a spec back to "ready for build" (a new record, same
+ * `by`), so the Stopped line is true and the spec is offered again.
+ */
+const markedThisRun = new Set();
+const dirKey = (d) => (process.platform === 'win32' ? path.resolve(d).toLowerCase() : path.resolve(d));
+export function noteBeingBuiltThisRun(specDir) { markedThisRun.add(dirKey(specDir)); }
+function openQuestions(env) {
+    if (env.artefactType !== 'spec-gap')
+        return [];
+    const open = new Set(env.interaction.items.filter((i) => i.status === 'open').map((i) => i.id));
+    const qs = [];
+    for (const s of env.content.sections)
+        for (const g of s.gaps)
+            if (open.has(g.id))
+                qs.push({ id: g.id, severity: g.severity, text: g.text });
+    return [...qs.filter((q) => q.severity === 'BLOCKER'), ...qs.filter((q) => q.severity !== 'BLOCKER')];
+}
+/** The start-up card (Ink or classic) as the gate's card: a choice index, or null. */
+export function gateChooser(choose) {
+    return async (q) => {
+        const v = await choose({ title: q.title, facts: q.facts, choices: q.choices.map((label, i) => ({ value: String(i), label })) });
+        if (v === null)
+            return null;
+        const n = Number(v);
+        return Number.isInteger(n) ? n : null;
+    };
+}
+const cardTitle = (n) => (n === 1 ? '1 open question travels with this spec.' : `${n} open questions travel with this spec.`);
+export async function openQuestionsGate(a) {
+    if (!PREFIX.test(a.command))
+        return null;
+    const { parseFromFlag } = await import('../skills/promotion-dispatch.js');
+    const { fromPath } = parseFromFlag(a.command);
+    if (!fromPath)
+        return null;
+    const { buildFolderAt } = await import('../commands/team-spec.js');
+    const here = buildFolderAt(a.cwd);
+    if (!here)
+        return null;
+    const { resolveAtTokenAsync } = await import('../projects/workspace.js');
+    let abs;
+    try {
+        const r = await resolveAtTokenAsync(fromPath, a.cwd);
+        if (r.kind !== 'path')
+            return null;
+        abs = path.resolve(a.cwd, r.path);
+    }
+    catch {
+        return null;
+    }
+    const share = await import('../projects/spec-share.js');
+    if (!share.isSharedSpecPath(here.dir, abs) || !abs.endsWith('.cspeach.json'))
+        return null;
+    const { readProjectFile } = await import('../projects/status.js');
+    const specDir = path.dirname(abs);
+    const file = path.basename(abs);
+    // R11: only the answers recorded for this envelope.
+    const read = (p) => share.composeSpec(readProjectFile(p), share.readAnswers(path.dirname(p)).filter((x) => x.file === path.basename(p)));
+    let env;
+    try {
+        env = read(abs);
+    }
+    catch {
+        return null;
+    }
+    if (env.artefactType !== 'spec-gap')
+        return null;
+    // Final review F5: every return that lets the build go on forgets this run's
+    // "being built" mark, so a later hand-typed Stop on the same spec puts nothing back.
+    const goOn = (r) => { markedThisRun.delete(dirKey(specDir)); return r; };
+    const carried = (qs) => goOn({ command: `${a.command}\nOpen questions carried as assumptions:\n${qs.map((q) => `- ${q.id}: ${q.text}`).join('\n')}` });
+    for (;;) {
+        const qs = openQuestions(env);
+        if (!qs.length)
+            return goOn({ command: a.command });
+        if (a.headless)
+            return carried(qs);
+        for (const q of qs)
+            a.emit(`  - [${q.severity}] ${q.text}`);
+        // Only blockers can be answered here: with none open, the card leaves that choice out.
+        const choices = qs.some((q) => q.severity === 'BLOCKER') ? [ANSWER, GO_AHEAD, STOP] : [GO_AHEAD, STOP];
+        const pick = await a.choose({ title: cardTitle(qs.length), facts: [], choices });
+        const label = pick === null ? undefined : choices[pick];
+        if (label === GO_AHEAD)
+            return carried(qs);
+        if (label !== ANSWER) {
+            putBackReady(share, specDir, a.now);
+            return { stop: true };
+        }
+        const { offerAnswerBlockers } = await import('../projects/answer-blockers.js');
+        await offerAnswerBlockers({
+            path: abs,
+            identity: a.identity,
+            prompt: a.prompt ?? (async () => ''),
+            // "Answer them now" was the yes: the flow does not ask it again.
+            confirm: async () => 'y',
+            ...(a.answer ? { choose: a.answer } : {}),
+            log: (...lines) => lines.forEach((l) => a.emit(l)),
+            ...(a.now ? { now: a.now } : {}),
+            readEnvelope: read,
+            recordAnswer: (r) => {
+                share.writeAnswerRecord(specDir, {
+                    projectId: here.project.projectId, slug: path.basename(specDir), file,
+                    gapId: r.gapId, answer: r.answer, by: share.specAuthorFor(here.project.projectId, r.identity.name), at: r.at,
+                });
+            },
+        });
+        try {
+            env = read(abs);
+        }
+        catch {
+            return goOn({ command: a.command });
+        }
+    }
+}
+/**
+ * R14 — Stop on a spec this run marked "being built": add a "ready for build"
+ * record back (records stay add-only), with the same `by`. A spec typed by
+ * hand, or marked by an earlier run, is left as it is.
+ */
+function putBackReady(share, specDir, now) {
+    const k = dirKey(specDir);
+    if (!markedThisRun.has(k))
+        return;
+    try {
+        const st = share.readSpecStatus(specDir);
+        if (st.current !== 'being built' || !st.record)
+            return;
+        const r = st.record;
+        // Later than the "being built" record: at the same instant the later step would win.
+        const t = Math.max(Date.parse((now ?? (() => new Date().toISOString()))()), Date.parse(r.at) + 1);
+        share.writeStatusRecord(specDir, {
+            projectId: r.projectId, slug: r.slug, file: r.file, status: 'ready for build', by: r.by, at: new Date(t).toISOString(),
+        });
+        markedThisRun.delete(k);
+    }
+    catch { /* the Stop still stops */ }
+}

package/dist/repl/ready-phrase.js

@@ -0,0 +1,108 @@
+// No static imports beyond types: repl.tsx imports this module at start-up,
+// and the folder code loads only when the phrase matches.
+const PHRASE = /\bready\s+for\s+(?:the\s+)?(?:developer|dev|build)\b|\bmark\s+(?:it|this|the\s+spec)\s+(?:as\s+)?ready\b/i;
+const QUESTION_START = /^(?:is|are|can|could|should|when|what|do|does|how|why|will|would|has|have|if|whether|once|after|until)\b/i;
+/** R13: "tell me when it is ready for build" asks to be told; it marks nothing. */
+const ASK_START = /^(?:tell|let)\s+me\s+(?:know\s+)?when\b/i;
+/**
+ * R13: a negation anywhere ("not ready", "don't mark it", "isn't ready") marks
+ * nothing — typed with no apostrophe too ("cant", "isnt", "dont", final review F5).
+ */
+const NEGATION = /\b(?:not|never|no|cannot|cant|isnt|dont|wont|arent|aint)\b|n['’]t\b/i;
+/** Final review F5: a leading "please" changes nothing; the checks read what follows it. */
+const PLEASE = /^please\b[\s,]*/i;
+export function isReadyForDeveloperPhrase(input) {
+    const typed = String(input ?? '').trim();
+    if (!typed || typed.length > 200)
+        return false;
+    if (typed.startsWith('/') || typed.endsWith('?'))
+        return false;
+    const s = typed.replace(PLEASE, '');
+    if (QUESTION_START.test(s) || ASK_START.test(s))
+        return false;
+    if (NEGATION.test(s))
+        return false;
+    return PHRASE.test(s);
+}
+export async function markReadyFlow(a) {
+    const { NO_DRAFT_LINE, buildFolderAt, draftSpecs, markSpecReady, markedReadyLine } = await import('../commands/team-spec.js');
+    const here = buildFolderAt(a.cwd);
+    if (!here)
+        return false;
+    const drafts = draftSpecs(here.dir);
+    if (!drafts.length) {
+        a.emit(NO_DRAFT_LINE);
+        return true;
+    }
+    let pick = 0;
+    if (drafts.length > 1) {
+        const i = await a.choose(drafts.map((s) => s.title));
+        if (i === null || !Number.isInteger(i) || i < 0 || i >= drafts.length) {
+            a.emit('Nothing marked.');
+            return true;
+        }
+        pick = i;
+    }
+    const spec = drafts[pick];
+    try {
+        markSpecReady(spec, here.project.projectId, a.by, (a.now ?? (() => new Date()))(), a.rand);
+    }
+    catch (e) {
+        a.emit(couldNotMarkLine(e));
+        return true;
+    }
+    a.emit(markedReadyLine(spec.title));
+    return true;
+}
+/**
+ * The REPL front door. False = not ours: the text goes on to the model as
+ * before. Ordinary text never reads the folder.
+ */
+export async function readyForDeveloperDoor(input, a) {
+    if (!isReadyForDeveloperPhrase(input))
+        return false;
+    const { buildFolderAt } = await import('../commands/team-spec.js');
+    const here = buildFolderAt(a.cwd);
+    if (!here)
+        return false;
+    // From here the phrase is ours: any failure is one plain line, never a throw.
+    try {
+        const { specAuthorFor } = await import('../projects/spec-share.js');
+        return await markReadyFlow({
+            cwd: here.dir, by: specAuthorFor(here.project.projectId, a.identityName), emit: a.emit, choose: a.choose,
+            ...(a.now ? { now: a.now } : {}), ...(a.rand ? { rand: a.rand } : {}),
+        });
+    }
+    catch (e) {
+        a.emit(couldNotMarkLine(e));
+        return true;
+    }
+}
+function couldNotMarkLine(e) {
+    const reason = (e instanceof Error ? e.message : String(e)).split('\n')[0];
+    return `Could not mark it ready: ${reason}`;
+}
+const CHOOSE_TITLE = 'Which spec is ready for the developer?';
+/** Ink: a question card, one choice per spec title. Cancelled = null. */
+export function inkSpecChooser() {
+    return async (titles) => {
+        const { askConfirm } = await import('../ui/confirm-request.js');
+        const r = await askConfirm({
+            id: 'spec-ready', tag: 'QUESTION', title: CHOOSE_TITLE,
+            choices: titles.map((t, i) => ({ value: String(i), label: t })), initial: 0,
+        });
+        if (r.cancelled || r.value === null)
+            return null;
+        const n = Number(r.value);
+        return Number.isInteger(n) ? n : null;
+    };
+}
+/** Classic: numbered lines and one typed answer. Anything else = null. */
+export function classicSpecChooser(prompt, log) {
+    return async (titles) => {
+        log(CHOOSE_TITLE);
+        titles.forEach((t, i) => log(`  ${i + 1}. ${t}`));
+        const n = Number((await prompt(`Choose 1-${titles.length}: `)).trim());
+        return Number.isInteger(n) && n >= 1 && n <= titles.length ? n - 1 : null;
+    };
+}