@cspeach/cli 1.1.55 → 1.1.56

package/dist/agent/loop.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { basename, dirname } from 'node:path';
+import { basename, dirname, relative, resolve as resolvePath, sep } from 'node:path';
 import { dispatchTool } from './tool-dispatch.js';
 import { listTools, getTool, isStandalone, toolsForContext, toAnthropicTools } from '../tools/index.js';
 import { toolsForSeat } from '../tools/seat-gate.js';
@@ -54,7 +54,7 @@ import { planLaneBlockForTurn } from '../projects/plan-lane.js';
 import { DOCUMENT_SKILLS, WORD_AFTER_ARTIFACT_SAVE } from '../projects/document-skills.js';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
 import { bindCliCardSession, documentOffersFor, markCliMessage, CONTINUE_LINE, WATCHDOG_LINE } from '../session/cli-record.js';
-import { clearAppFlow, getAppFlow, setGapConfirmed, startAppFlow } from '../lane/app-flow.js';
+import { clearAppFlow, getAppFlow, setGapConfirmed, setSpecGap, startAppFlow } from '../lane/app-flow.js';
 import { getLatestSkeletonDecision } from '../rap/skeleton-session.js';
 import { afterRebuildTurn } from '../journey/rebuild.js';
 import { afterJourneyTurn, gateJourneyForTurn, journeyAsk, journeyCardConfirm, journeyStoppedOnError, journeyTurnBlock, pauseJourneyForInterruptedTurn } from '../journey/chain.js';
@@ -64,6 +64,7 @@ import { shownToken } from '../lane/card.js';
 import { parseFromFlag, coerceDocFromFlagToAttachment } from '../skills/promotion-dispatch.js';
 import { input } from '@inquirer/prompts';
 import { withInquirer } from '../repl/inquirer-guard.js';
+import { takeGateGoAhead } from '../repl/open-questions-gate.js';
 import { expandTextFileAttachments } from '../projects/workspace.js';
 import { expandImageAttachments, buildUserContent, trimHistoryImages } from '../projects/image-attachments.js';
 import { expandImageChips } from '../ui/clipboard-image.js';
@@ -451,6 +452,51 @@ async function isSharedSpecSave(cwd, saveSkill, savedPath) {
         return false;
     }
 }
+/**
+ * F14 — the spec text the lane step quotes from: the Markdown copy next to the
+ * shared spec-gap (`<slug>.md`, else the one .md there), cwd-relative. The
+ * lane tool holds the model to the flow's spec, and the spec-gap file is never
+ * that spec. Undefined when there is none.
+ */
+async function sharedSpecText(cwd, gapAbs) {
+    const { readdir } = await import('node:fs/promises');
+    const dir = dirname(gapAbs);
+    const mds = (await readdir(dir).catch(() => [])).filter((f) => f.toLowerCase().endsWith('.md'));
+    const pick = mds.find((f) => f === `${basename(dir)}.md`) ?? (mds.length === 1 ? mds[0] : undefined);
+    return pick === undefined ? undefined : relative(cwd, resolvePath(dir, pick)).split(sep).join('/');
+}
+/**
+ * F14 (2026-10-30 live retest) — `/abap-app --from @specs/<slug>/<file>` in a
+ * team build folder with no flow for that file: start the flow at the lane
+ * step, so the lane tool queues `/abap-plan --from @specs/<slug>/<file>`.
+ * A flow already at the lane step for the same real file is kept as it is.
+ * True when the source is a shared spec here. Never throws: a folder it
+ * cannot read starts nothing.
+ */
+async function startSharedSpecFlow(session, cwd, token, source, yes) {
+    try {
+        const { buildFolderAt } = await import('../commands/team-spec.js');
+        const here = buildFolderAt(cwd);
+        if (!here)
+            return false;
+        const abs = resolvePath(cwd, source);
+        const { isSharedSpecPath } = await import('../projects/spec-share.js');
+        if (!isSharedSpecPath(here.dir, abs))
+            return false;
+        const flow = getAppFlow(session);
+        if (flow?.expect === 'lane' && flow.specGapPath && await sameRealFile(flow.specGapPath, abs))
+            return true;
+        startAppFlow(session, await sharedSpecText(cwd, abs) ?? token);
+        setSpecGap(session, abs);
+        if (yes !== undefined && await sameRealFile(yes, abs))
+            setGapConfirmed(session, abs);
+        return true;
+    }
+    catch {
+        // no flow: the lane step says no plan was queued, as before
+        return false;
+    }
+}
 async function offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm) {
     try {
         const { offerWordCopyAfterArtifactSave } = await import('../projects/document-save.js');
@@ -648,13 +694,12 @@ export async function maybeOfferSave(p) {
             // Team build (Task 9): a spec in the shared specs/ folder is never
             // rewritten — each answer is a record of its own, and the spec is read
             // with the records applied. Found by the folder (R10), never activeProject().
-            const { sharedSpecTargetFor, isSharedSpecPath, composeSpec, readAnswers, writeAnswerRecord, specAuthorFor } = await import('../projects/spec-share.js');
-            const { readProjectFile } = await import('../projects/status.js');
+            const { sharedSpecTargetFor, isSharedSpecPath, readComposedSpec, writeAnswerRecord, specAuthorFor } = await import('../projects/spec-share.js');
             const shared = sharedSpecTargetFor(p.cwd ?? process.cwd(), 'spec-gap');
             const records = shared && isSharedSpecPath(shared.teamDir, savedPath)
                 ? {
                     // R11: only the answers recorded for this envelope.
-                    readEnvelope: (path) => composeSpec(readProjectFile(path), readAnswers(dirname(path)).filter((a) => a.file === basename(path))),
+                    readEnvelope: readComposedSpec,
                     recordAnswer: (a) => {
                         const specDir = dirname(savedPath);
                         writeAnswerRecord(specDir, {
@@ -1020,6 +1065,13 @@ export async function runTurn(params) {
             // (plan step) skips it when it promotes the same real file.
             const flowNow = !params.ctx.subagent ? getAppFlow(session) : undefined;
             const confirmedGap = flowNow?.gapConfirmed;
+            // F12 (2026-10-30 live retest) — the open-questions gate's go-ahead on a
+            // shared spec was the yes: this turn's /abap-app promote of that same
+            // real file asks nothing more. It counts for the plan step too.
+            const gateYes = !params.ctx.subagent && params.skill === 'abap-app' ? takeGateGoAhead(session) : undefined;
+            // F14 (2026-10-30 live retest) — the yes given this turn, kept for a flow
+            // this promote starts (a shared spec built with no flow yet).
+            let yesThisTurn;
             const result = await runPromoteCommand({
                 sourcePath: fromPath,
                 targetSkill: params.skill,
@@ -1029,9 +1081,22 @@ export async function runTurn(params) {
                 // Final residual 4 — the same folder gateAppFlowForTurn resolves @X against.
                 cwd: params.ctx.cwd,
                 ...(flowNow?.expect === 'lane' && params.skill === 'abap-app'
-                    ? { onOpenWarningsConfirmed: (p) => setGapConfirmed(session, p) } : {}),
+                    ? { onOpenWarningsConfirmed: (p) => setGapConfirmed(session, p) }
+                    : !params.ctx.subagent && params.skill === 'abap-app'
+                        ? { onOpenWarningsConfirmed: (p) => { yesThisTurn = p; } } : {}),
                 ...(flowNow?.expect === 'plan' && params.skill === 'abap-plan' && confirmedGap
                     ? { skipOpenWarnings: (p) => sameRealFile(p, confirmedGap) } : {}),
+                ...(gateYes
+                    ? {
+                        skipOpenWarnings: async (p) => {
+                            const same = await gateYes(p);
+                            if (same && getAppFlow(session)?.expect === 'lane')
+                                setGapConfirmed(session, p);
+                            if (same)
+                                yesThisTurn = p;
+                            return same;
+                        },
+                    } : {}),
             });
             if (!result) {
                 // User declined, source invalid, or unsupported target — skip the turn.
@@ -1040,6 +1105,12 @@ export async function runTurn(params) {
             }
             promotedFromForSave = result.promotedFrom;
             promotedFromPathForSave = result.sourcePath;
+            // F14 (2026-10-30 live retest) — a build started from a shared spec
+            // (start screen, gate, F9c hand-off or typed) had no app flow, so the
+            // lane step queued no plan. Start one here, at the lane step, as after a
+            // chained spec-gap save. Team build folders only; the gate above has run.
+            const sharedSpec = !params.ctx.subagent && params.skill === 'abap-app' && result.promotedFrom.artefactType === 'spec-gap'
+                && await startSharedSpecFlow(session, params.ctx.cwd ?? process.cwd(), fromPath, result.sourcePath, yesThisTurn);
             // 2026-05-08: thread the original @<filename> token into the LLM
             // prompt so skills that need to dispatch a follow-up command (e.g.
             // dispatch_skill calling /abap-rap --from @<same-file>) can use the
@@ -1049,7 +1120,9 @@ export async function runTurn(params) {
             // "foo-v1"), producing "no file matching" auto-routes. Use basename
             // so absolute / relative paths normalise to the workspace @<token>
             // form the picker resolves.
-            const sourceToken = `@${basename(fromPath)}`;
+            // F14: a shared spec keeps the path as typed (`specs/<slug>/<file>`); its
+            // bare name resolves against the seat's work folder and fails.
+            const sourceToken = sharedSpec ? `@${/\s/.test(fromPath) ? `"${fromPath}"` : fromPath}` : `@${basename(fromPath)}`;
             userMessageForLLM = `Source file: ${sourceToken}\n${result.extendedSkillInput}\n\n---\n\n${rest}`;
             userMessageForSave = rest;
         }

package/dist/lane/ready-spec.js

@@ -9,7 +9,9 @@ export async function readySpecFor(cwd, request) {
         const said = request.toLowerCase();
         const isNamed = (s) => said.includes(s.title.toLowerCase()) || said.includes(s.slug.replace(/-/g, ' '));
         const namedAll = all.filter(isNamed);
-        const ready = all.filter((s) => s.status === 'ready for build');
+        // F13 (2026-10-30 live retest): a spec being built stays buildable, so a
+        // build stopped after the gate, or a closed window, can be continued.
+        const ready = all.filter((s) => s.status === 'ready for build' || s.status === 'being built');
         const named = ready.filter(isNamed);
         // S1 — the request names a spec, and it is not one that is ready.
         if (named.length === 0 && namedAll.length === 1) {

package/dist/projects/plan-sources.js

@@ -22,7 +22,6 @@
 // continuous run) calls resolvePlanSources + renderPlanSourcesBlock.
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { readProjectFile } from './status.js';
 import { buildPromotedFromSnapshot } from './promote.js';
 import { assertRealPathContained } from '../tools/_filesystem-shared.js';
 import { laneRootFor, workspaceFolderFor } from '../lane/roots.js';
@@ -92,7 +91,9 @@ async function readLiveSpecGap(cwd, content, promotedFrom, laneRecord, planPath)
                 continue;
             let env;
             try {
-                env = readProjectFile(abs);
+                // F12 — a shared spec's answer records reach the phase too.
+                const { readComposedSpec } = await import('./spec-share.js');
+                env = readComposedSpec(abs);
             }
             catch {
                 continue;

package/dist/projects/promote-command.js

@@ -1,5 +1,4 @@
 import { realpathSync } from 'node:fs';
-import { readProjectFile } from './status.js';
 import { buildPromotedFromSnapshot, buildReviewDecisionsBlock, buildDetailPathHint, validatePromotionSource } from './promote.js';
 import { resolveAtTokenAsync, formatProjectFileList } from './workspace.js';
 import { askYesNo } from './yes-no.js';
@@ -105,9 +104,12 @@ export async function runPromoteCommand(args) {
         args.log(`--from: ${resolvedPath} is inside CSPeach's own folder and cannot be read.`);
         return null;
     }
+    // 2026-10-30 live retest F12: a shared spec is read with its answer
+    // records applied, so answered questions do not count as open.
+    const { readComposedSpec } = await import('./spec-share.js');
     let env;
     try {
-        env = readProjectFile(resolvedPath);
+        env = readComposedSpec(resolvedPath);
     }
     catch (e) {
         args.log(`--from source error: ${String(e instanceof Error ? e.message : e)}`);

package/dist/projects/spec-share.js

@@ -161,6 +161,16 @@ export function composeSpec(env, answers) {
     }
     return out;
 }
+/**
+ * The spec at `absPath` as people read it: the file with the answers recorded
+ * for it applied (R11). A folder with no `answers/` gives the plain file.
+ * 2026-10-30 live retest F12: `--from` read the raw file and saw 25 answered
+ * questions as open.
+ */
+export function readComposedSpec(absPath) {
+    const file = path.basename(absPath);
+    return composeSpec(readEnvelopeFile(absPath), readAnswers(path.dirname(absPath)).filter((a) => a.file === file));
+}
 export async function writeSharedSpec(a) {
     const slug = specSlug(a.env.title);
     const specDir = path.join(a.teamDir, SPECS_DIR, slug);

package/dist/projects/team-build-context.js

@@ -38,7 +38,8 @@ export function teamBuildContextBlock(cwd, seat) {
             lines.push('When the person says a spec is ready for the developer, CSPeach records it; this seat does not build.');
         }
         else {
-            lines.push('To build a ready spec: hand_off with skill "abap-app" and the spec\'s title in the request. CSPeach attaches the spec and shows its open questions first.');
+            // F13 (2026-10-30 live retest): a spec being built can be continued.
+            lines.push('To build a ready spec, or continue one being built: hand_off with skill "abap-app" and the spec\'s title in the request. CSPeach attaches the spec and shows its open questions first.');
         }
         lines.push('</team_build>');
         return lines.join('\n');

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

@@ -27,6 +27,24 @@ export const STOPPED_LINE = 'Stopped. The spec stays ready for the developer.';
 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)); }
+/**
+ * 2026-10-30 live retest F12 — the gate letting the build go on ("Go ahead",
+ * answered, or nothing open) is the developer's yes to the open items. The
+ * spec file is kept per session, and the promote in that same turn takes it
+ * (once) so it does not ask "still open … Promote anyway?" again.
+ */
+const goAhead = new WeakMap();
+/** The gate's yes for this session, taken once: a check that the promote source is the same real file. */
+export function takeGateGoAhead(session) {
+    const abs = goAhead.get(session);
+    if (abs === undefined)
+        return undefined;
+    goAhead.delete(session);
+    return async (p) => {
+        const { sameRealFile } = await import('../lane/app-chain.js');
+        return sameRealFile(p, abs);
+    };
+}
 function openQuestions(env) {
     if (env.artefactType !== 'spec-gap')
         return [];
@@ -50,6 +68,9 @@ export function gateChooser(choose) {
 }
 const cardTitle = (n) => (n === 1 ? '1 open question travels with this spec.' : `${n} open questions travel with this spec.`);
 export async function openQuestionsGate(a) {
+    // F12: a yes from an earlier gate never carries over to this command.
+    if (a.session)
+        goAhead.delete(a.session);
     // F10 (2026-10-29): a typed `/abap-app @<saved spec-gap>` (no --from) is
     // the same request — the spec is already analysed — so it goes to the lane
     // step as `--from`, never back through step 1. Anything else typed with @
@@ -91,11 +112,10 @@ export async function openQuestionsGate(a) {
     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)));
+    const read = share.readComposedSpec;
     let env;
     try {
         env = read(abs);
@@ -122,7 +142,13 @@ export async function openQuestionsGate(a) {
         }
         catch { /* the build still goes on */ }
     };
-    const goOn = (r) => { markedThisRun.delete(dirKey(specDir)); markBeingBuilt(); return r; };
+    const goOn = (r) => {
+        markedThisRun.delete(dirKey(specDir));
+        markBeingBuilt();
+        if (a.session)
+            goAhead.set(a.session, abs);
+        return r;
+    };
     const carried = (qs) => goOn({ command: `${command}\nOpen questions carried as assumptions:\n${qs.map((q) => `- ${q.id}: ${q.text}`).join('\n')}` });
     for (;;) {
         const qs = openQuestions(env);

package/dist/repl/team-build-screen.js

@@ -2,10 +2,11 @@
  * Team build (spec 2026-10-25) — the developer start screen.
  *
  * When CSPeach starts in a team build folder, it says what sits in the shared
- * `specs/` folder: each spec ready for build with its summary and open
- * questions, and one line for each draft or spec being built. A developer is
- * then offered each ready spec: build it, ask about it first, or later. A
- * functional seat sees the same lines and is never offered a build.
+ * `specs/` folder: each spec ready for build or being built with its summary
+ * and open questions, and one line for each draft. A developer is then
+ * offered each ready spec (build it, ask about it first, or later) and each
+ * spec being built (continue building it, F13). A functional seat sees the
+ * same lines and is never offered a build.
  *
  * Ruling R10: the build folder is the folder CSPeach runs in, never
  * `activeProject()`. Ruling R12: the status record goes to the spec folder.
@@ -13,12 +14,18 @@
  */
 import path from 'node:path';
 const day = (iso) => String(iso ?? '').slice(0, 10);
+const trimQuestion = (q) => (q.length > 100 ? `${q.slice(0, 100)}…` : q);
 export function startScreenLines(specs, _seat) {
     const out = [];
     for (const s of specs) {
         const who = `"${s.title}" — ${s.author}, ${day(s.createdAt)}`;
-        if (s.status === 'ready for build') {
-            out.push(`Ready to build: ${who}`, `  ${s.summary}`);
+        if (s.status === 'ready for build' || s.status === 'being built') {
+            // F13 (2026-10-30 live retest): a spec being built reads like a ready
+            // one, with who started it, so the developer can continue it.
+            const head = s.status === 'ready for build'
+                ? `Ready to build: ${who}`
+                : `Being built: ${who}${s.statusBy ? ` · started by ${s.statusBy}, ${day(s.statusAt ?? '')}` : ''}`;
+            out.push(head, `  ${s.summary}`);
             if (s.openQuestions.length) {
                 out.push('  Open questions:');
                 for (const q of s.openQuestions)
@@ -29,29 +36,32 @@ export function startScreenLines(specs, _seat) {
             }
         }
         else {
-            out.push(`${s.status === 'draft' ? 'Draft' : 'Being built'}: ${who}`);
+            out.push(`Draft: ${who}`);
         }
         // Owner, 2026-10-29: an answer someone else replaced is said, so the
         // spec's author learns the developer overrode it.
         const changed = s.changedAnswers ?? [];
         if (changed.length) {
             out.push('  Answers changed by someone else:');
+            // M7 (2026-10-30 live retest): a long question took 6 lines; cut at 100.
             for (const c of changed)
-                out.push(`  - "${c.question}" now "${c.answer}" (${c.by}, ${day(c.at)}), was "${c.was}" (${c.wasBy})`);
+                out.push(`  - "${trimQuestion(c.question)}" now "${c.answer}" (${c.by}, ${day(c.at)}), was "${c.was}" (${c.wasBy})`);
         }
     }
     return out;
 }
 const BUILD = 'Build this spec';
+const CONTINUE = 'Continue building';
 const ASK = 'Ask about it first';
 const LATER = 'Later';
 export const askSentence = (s) => `Tell me about the spec "${s.title}" in specs/${s.slug}/ before we build it.`;
 async function chooseFor(choose, s) {
     const n = s.openQuestions.length;
+    const going = s.status === 'being built';
     const v = await choose({
-        title: `Ready to build: "${s.title}"`,
+        title: going ? `Continue building: "${s.title}"` : `Ready to build: "${s.title}"`,
         facts: [`${s.author}, ${day(s.createdAt)}`, n === 0 ? 'No open questions.' : n === 1 ? '1 open question.' : `${n} open questions.`],
-        choices: [{ value: 'build', label: BUILD }, { value: 'ask', label: ASK }, { value: 'later', label: LATER }],
+        choices: [{ value: 'build', label: going ? CONTINUE : BUILD }, { value: 'ask', label: ASK }, { value: 'later', label: LATER }],
     });
     if (v === 'build')
         return { kind: 'build', spec: s };
@@ -68,7 +78,7 @@ export async function offerBuild(a) {
     if (a.seat !== 'developer')
         return false;
     for (const s of a.specs) {
-        if (s.status !== 'ready for build')
+        if (s.status !== 'ready for build' && s.status !== 'being built')
             continue;
         const c = await chooseFor(a.choose, s);
         if (c.kind === 'later')
@@ -83,6 +93,12 @@ export async function offerBuild(a) {
             a.emit(`We could not start the build from specs/${s.slug}/. Run /abap-app --from @specs/${s.slug}/<file> yourself.`);
             return false;
         }
+        // F13: continuing a spec already being built writes no record, and it is
+        // not marked for this run, so a Stop at the gate leaves it being built.
+        if (s.status === 'being built') {
+            a.submit(`/abap-app --from ${t.token}`);
+            return true;
+        }
         const { writeStatusRecord } = await import('../projects/spec-share.js');
         writeStatusRecord(s.specDir, {
             projectId: a.projectId, slug: s.slug, file: path.basename(s.envelopePath),

package/dist/repl.js

@@ -1608,7 +1608,7 @@ export async function runRepl(opts) {
                     const g = await openQuestionsGate({
                         cwd: process.cwd(), command: effectiveInput, identity: getAuthorIdentity(),
                         emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
-                        choose: gateChooser(inkStartupChooser()), answer: inkAwareChoose, prompt: inkAwarePrompt, headless: isHeadless(),
+                        choose: gateChooser(inkStartupChooser()), answer: inkAwareChoose, prompt: inkAwarePrompt, headless: isHeadless(), session,
                     });
                     if (g && 'stop' in g) {
                         chunkEmitter.emit('chunk', STOPPED_LINE + '\n');
@@ -3947,7 +3947,7 @@ export async function runRepl(opts) {
                     cwd: process.cwd(), command: resolvedTrimmed, identity: getAuthorIdentity(),
                     emit: (line) => console.log(line),
                     choose: gateChooser(classicStartupChooser(inkAwarePrompt, (...l) => l.forEach((x) => console.log(x)))),
-                    answer: inkAwareChoose, prompt: inkAwarePrompt, headless: isHeadless(),
+                    answer: inkAwareChoose, prompt: inkAwarePrompt, headless: isHeadless(), session,
                 });
                 if (g && 'stop' in g) {
                     console.log(STOPPED_LINE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.55",
+  "version": "1.1.56",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",