@cspeach/cli 1.1.54 → 1.1.56

package/dist/agent/loop.js

@@ -1,9 +1,10 @@
 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';
 import { getSeatKind } from '../licence/seat-state.js';
+import { teamBuildContextBlock } from '../projects/team-build-context.js';
 import { saveSession } from '../session/store.js';
 import { tagSessionOnSave } from '../session/project-match.js';
 import { recordCompletedToolCall } from '../session/pending.js';
@@ -53,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';
@@ -63,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';
@@ -105,6 +107,8 @@ import { ChatUnavailableError } from './chat-unavailable.js';
  *
  * Exported for unit testing.
  */
+/** F2 — the read-only seat, told to the model so it never guesses a cause. */
+export const FUNCTIONAL_SEAT_NOTE = '<seat>This is a read-only seat (functional): CSPeach reads the SAP system and never changes it, in every mode; restarting or changing settings does not change that, so never suggest restarting or enabling writes. When the person asks for a change, say what would change and offer to write it up as a request for a developer (in a team build: a spec).</seat>';
 export function getAuthorIdentity() {
     const name = process.env.CSPEACH_AUTHOR_NAME ??
         process.env.USER ??
@@ -448,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');
@@ -645,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, {
@@ -938,7 +986,34 @@ export async function runTurn(params) {
         }
         else {
             clearAppFlow(session);
+            // F9c (2026-10-29): routed here from plain words ("let's start building
+            // it") in a team build folder with a ready spec — build that spec. The
+            // command is queued, so it passes the open-questions gate like a typed
+            // one; no spec-gap rerun on the sentence.
+            if (params.explicitSlash !== true && extractSpecToken(params.userMessage) === undefined && params.ctx.pendingDispatch) {
+                const { readySpecFor, notReadyLine } = await import('../lane/ready-spec.js');
+                const picked = await readySpecFor(params.ctx.cwd ?? process.cwd(), params.userMessage);
+                if (picked && 'notReady' in picked) {
+                    emit(notReadyLine(picked.notReady));
+                    return;
+                }
+                if (picked && 'ask' in picked) {
+                    emit(`More than one spec here is ready to build: ${picked.ask.join(', ')}. Say which one.`);
+                    return;
+                }
+                if (picked) {
+                    emit(`Building the ready spec "${picked.title}".`);
+                    params.ctx.pendingDispatch.set(picked.command, { by: 'app' });
+                    return;
+                }
+            }
             emit(chalk.yellow(spec.line));
+            // F9b (2026-10-29 live run): a slash command — typed, or queued by a
+            // hand-off — that names no usable spec ends here. Running on as
+            // spec-gap let the model improvise a build off the guided route. A
+            // request routed from plain words still gets the spec-gap check.
+            if (params.explicitSlash === true)
+                return;
         }
         params = { ...params, skill: 'abap-spec-gap' };
     }
@@ -990,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,
@@ -999,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.
@@ -1010,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
@@ -1019,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;
         }
@@ -1169,7 +1272,15 @@ ${imageExpansion.error}`));
     const blockerNote = mainTurn && session.blockerAnswersNote
         ? `<blocker_answers>\n${session.blockerAnswersNote}\n</blocker_answers>`
         : '';
-    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote, blockerNote, playbookLine]);
+    // F5 (2026-10-29 live run) — in a team build folder the model is told the
+    // shared specs and the route for each request (hand off), every main turn.
+    // Anywhere else: '' (unchanged).
+    const teamBuildNote = mainTurn && isChatSkill(params.skill) ? teamBuildContextBlock(params.ctx.cwd ?? process.cwd(), getSeatKind()) : '';
+    // F2 (2026-10-29 live run): a functional seat sees no write tools; told
+    // nothing, the model guessed "restart CSPeach with writes enabled". Every
+    // main turn on that seat says why, and the route for a change.
+    const seatNote = mainTurn && getSeatKind() === 'functional' ? FUNCTIONAL_SEAT_NOTE : '';
+    const sessionContextBlock = composeSessionContextBlock([sapSystemBlock, sapProfileBlock, standardsBlock, switchNote, blockerNote, playbookLine, teamBuildNote, seatNote]);
     // Deterministically extract structured facts from the user's prompt
     // (package, transport, object names, environment hint, create intent)
     // and prepend them as an XML `<session_context>` block. The model reads
@@ -1185,7 +1296,7 @@ ${imageExpansion.error}`));
     // Final batch 1 — a caller-enriched message still gets the switch note,
     // inside its own <session_context> block.
     // Stage 1A — the <playbook> line rides the same way ('' ⇒ unchanged).
-    const callerNotes = composeSessionContextBlock([switchNote, blockerNote, playbookLine]);
+    const callerNotes = composeSessionContextBlock([switchNote, blockerNote, playbookLine, teamBuildNote, seatNote]);
     const enriched = userMessageForLLM.startsWith('<session_context>')
         ? (callerNotes ? userMessageForLLM.replace('<session_context>', `<session_context>\n  ${callerNotes}`) : userMessageForLLM)
         : enrichUserMessage(userMessageForLLM, sessionContextBlock);

package/dist/cli.js

@@ -225,9 +225,12 @@ export async function main(argv) {
     if (args[0] === 'team') {
         const { runTeamCommand } = await import('./commands/team.js');
         const { getAuthorIdentity } = await import('./agent/loop.js');
+        const { signedInAccount } = await import('./licence/account-name.js');
         return runTeamCommand(args.slice(1), {
             print: (s) => console.log(s),
             identity: () => getAuthorIdentity(),
+            // S2 — `cspeach team join` of a team BUILD names the person by account.
+            account: () => signedInAccount(),
             noSap,
             // Standalone: no connection is offered at all, so nothing in `team` can reach for one.
             connect: noSap ? undefined : async (alias) => {

package/dist/commands/team.js

@@ -129,6 +129,28 @@ function matches(pattern, value) {
     const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i');
     return re.test(value);
 }
+/** Verbs that choose or leave a project themselves: no folder note. */
+const FOLDER_NOTE_SKIP = new Set(['init', 'start', 'join', 'leave', 'help', '--help', '-h']);
+/**
+ * F11 — one line when `cwd` holds a team project other than the active one.
+ * Null when it matches, when the folder is no team project, or on any read
+ * problem (the verb then runs exactly as before).
+ */
+export function folderMismatchLine(cwd) {
+    try {
+        if (!fs.existsSync(path.join(cwd, TEAM_FILE)))
+            return null;
+        const here = readProjectFile(cwd);
+        const active = activeProject();
+        if (!active || active.projectId === here.projectId)
+            return null;
+        const activeName = readProjectFile(active.projectDir).name;
+        return `This folder is the team project "${here.name}", but CSPeach is recording against "${activeName}". To work on "${here.name}": cspeach team join .`;
+    }
+    catch {
+        return null;
+    }
+}
 export async function runTeamCommand(args, deps) {
     const [sub, ...rest] = args;
     try {
@@ -148,6 +170,14 @@ export async function runTeamCommand(args, deps) {
                 return 1;
             }
         }
+        // F11 (2026-10-29 live run): verbs follow the active project (R10). When
+        // the folder they run in is a different team project, say so first — a
+        // status in the ZTEST_LAS folder silently reported another project.
+        if (sub && !FOLDER_NOTE_SKIP.has(sub)) {
+            const note = folderMismatchLine((deps.cwd ?? (() => process.cwd()))());
+            if (note)
+                deps.print(note);
+        }
         // A team build folder has no baseline: the clean-core verbs are refused in one line.
         if (sub && CLEAN_CORE_ONLY_VERBS.includes(sub) && activeIsBuild()) {
             deps.print(buildVerbRefusal(sub));
@@ -756,6 +786,13 @@ function join(args, deps, asName) {
     const state = loadState();
     if (opts.as !== undefined && asName === undefined)
         asName = joinAsName(opts.as, projectDir, project, state.projects[project.projectId]?.name, deps);
+    // F4/F8 — a team build is named by the signed-in account, once (a name
+    // already kept for this project stays).
+    if (asName === undefined && isBuildProject(project) && state.projects[project.projectId]?.name === undefined) {
+        const account = deps.account?.()?.trim();
+        if (account)
+            asName = account;
+    }
     const outboxDir = path.resolve(opts.outbox ?? state.projects[project.projectId]?.outboxDir ?? defaultOutboxDir(project.projectId));
     // A name given once is kept: joining again must not turn the lead back into
     // whatever the machine calls them.

package/dist/lane/ready-spec.js

@@ -0,0 +1,34 @@
+export async function readySpecFor(cwd, request) {
+    try {
+        const { buildFolderAt } = await import('../commands/team-spec.js');
+        const here = buildFolderAt(cwd);
+        if (!here)
+            return undefined;
+        const { listSharedSpecs } = await import('../projects/spec-share.js');
+        const all = listSharedSpecs(here.dir);
+        const said = request.toLowerCase();
+        const isNamed = (s) => said.includes(s.title.toLowerCase()) || said.includes(s.slug.replace(/-/g, ' '));
+        const namedAll = all.filter(isNamed);
+        // 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) {
+            return { notReady: { title: namedAll[0].title, status: namedAll[0].status } };
+        }
+        if (!ready.length)
+            return undefined;
+        const one = named.length === 1 ? named[0] : ready.length === 1 && namedAll.length === 0 ? ready[0] : undefined;
+        if (!one)
+            return { ask: ready.map((s) => `"${s.title}"`) };
+        const { chainFromToken } = await import('./chain-token.js');
+        const t = await chainFromToken(here.dir, one.envelopePath);
+        return t ? { command: `/abap-app --from ${t.token}`, title: one.title } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One plain line for a named spec that is not ready to build. */
+export const notReadyLine = (n) => `"${n.title}" is ${n.status}, not ready for build. The author marks it ready when it is.`;

package/dist/licence/account-name.js

@@ -0,0 +1,31 @@
+/**
+ * Final review S2 (2026-10-29): the signed-in CSPeach account, remembered on
+ * this laptop after a successful start-up (/v1/me), so a team build names a
+ * person by their account on every path — the typed `cspeach team join` and
+ * records written without a join — and two people on one laptop with one
+ * Windows user stay two people. Only the email; never sent anywhere. Kept in
+ * its own file so auth.json (which drives the key logic) is never touched.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+const file = () => path.join(cspeachRoot(), 'account.json');
+export function rememberAccount(email) {
+    const e = email.trim();
+    if (!e)
+        return;
+    try {
+        fs.mkdirSync(cspeachRoot(), { recursive: true });
+        fs.writeFileSync(file(), JSON.stringify({ email: e }) + '\n', 'utf8');
+    }
+    catch { /* best-effort: the Windows name is used instead */ }
+}
+export function signedInAccount() {
+    try {
+        const j = JSON.parse(fs.readFileSync(file(), 'utf8'));
+        return typeof j.email === 'string' && j.email.trim() ? j.email.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -30,7 +30,33 @@ import { writeWhole } from '../register/write-whole.js';
 import { fileStamp } from '../register/records.js';
 import { writeNoClobber, writeDocxNextTo } from '../docx/write-docx.js';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { signedInAccount } from '../licence/account-name.js';
 export const SPECS_DIR = 'specs';
+/** Per question: the latest answer, when it replaced one given by someone else. */
+export function changedAnswersOf(env, answers) {
+    if (env.artefactType !== 'spec-gap')
+        return [];
+    const question = new Map();
+    for (const s of env.content.sections)
+        for (const g of s.gaps)
+            question.set(g.id, g.text);
+    const byGap = new Map();
+    for (const a of [...answers].sort((x, y) => (x.at < y.at ? -1 : x.at > y.at ? 1 : 0))) {
+        byGap.set(a.gapId, [...(byGap.get(a.gapId) ?? []), a]);
+    }
+    const out = [];
+    for (const [gapId, list] of byGap) {
+        if (list.length < 2)
+            continue;
+        const last = list[list.length - 1];
+        const prev = list[list.length - 2];
+        const samePerson = last.by.writer === prev.by.writer && last.by.name === prev.by.name;
+        if (samePerson || last.answer.trim() === prev.answer.trim())
+            continue;
+        out.push({ gapId, question: question.get(gapId) ?? gapId, answer: last.answer, by: last.by.name, at: last.at, was: prev.answer, wasBy: prev.by.name });
+    }
+    return out;
+}
 const STATUSES = ['draft', 'ready for build', 'being built'];
 /** Same instant: the later step in the life of a spec wins. */
 const STATUS_RANK = { draft: 0, 'ready for build': 1, 'being built': 2 };
@@ -78,7 +104,8 @@ export function specAuthorFor(projectId, fallbackName) {
     catch {
         saved = undefined;
     }
-    const name = saved ?? fallbackName;
+    // S2 — no name kept for this project: the signed-in account, else the fallback.
+    const name = saved ?? signedInAccount() ?? fallbackName;
     return { name, writer: writerIdFor(name) };
 }
 const statusSlug = (s) => s.replace(/\s+/g, '-');
@@ -134,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);
@@ -196,7 +233,8 @@ export function listSharedSpecs(teamDir) {
             continue;
         // R11: answers apply only to the envelope they were recorded for.
         const bestFile = path.basename(best.path);
-        const composed = composeSpec(best.env, readAnswers(specDir).filter((a) => a.file === bestFile));
+        const answersHere = readAnswers(specDir).filter((a) => a.file === bestFile);
+        const composed = composeSpec(best.env, answersHere);
         if (composed.artefactType !== 'spec-gap')
             continue;
         const open = new Set(composed.interaction.items.filter((i) => i.status === 'open').map((i) => i.id));
@@ -213,13 +251,16 @@ export function listSharedSpecs(teamDir) {
             specDir,
             envelopePath: best.path,
             title: best.env.title,
-            author: best.env.createdBy.name,
+            // F4: the person who shared it (first status record, the account in a
+            // team build), else the file's author.
+            author: st.history[0]?.by.name ?? best.env.createdBy.name,
             createdAt: best.env.createdAt,
             summary: `${best.env.content.inputType} · ${best.env.content.inferredDomain}`,
             openQuestions,
             status: st.current,
             statusBy: st.record?.by.name ?? null,
             statusAt: st.record?.at ?? null,
+            changedAnswers: changedAnswersOf(best.env, answersHere),
         });
     }
     return out;

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

@@ -0,0 +1,50 @@
+/**
+ * F5 (2026-10-29 live run) — the conversation in a team build folder.
+ *
+ * The model did not know the folder's shared specs: asked for a spec it wrote
+ * Markdown itself (refused in specs/, then saved to cspeach-out/), and asked
+ * to build it read the spec files one by one and tried a script to parse
+ * them. Every turn in a build folder now carries one <team_build> fact: the
+ * specs, their state, and the route for each request. CSPeach code writes and
+ * reads specs/; the model only hands off.
+ *
+ * The folder is the one CSPeach runs in (R10). Never throws: a folder it
+ * cannot read gives no block.
+ */
+import { buildFolderAt } from '../commands/team-spec.js';
+import { listSharedSpecs } from './spec-share.js';
+function questionsLine(open) {
+    if (!open.length)
+        return 'no open questions';
+    const blockers = open.filter((q) => q.severity === 'BLOCKER').length;
+    const n = `${open.length} open question${open.length === 1 ? '' : 's'}`;
+    return blockers ? `${n} (${blockers} blocker${blockers === 1 ? '' : 's'})` : n;
+}
+export function teamBuildContextBlock(cwd, seat) {
+    try {
+        const here = buildFolderAt(cwd);
+        if (!here)
+            return '';
+        const specs = listSharedSpecs(here.dir);
+        const lines = [
+            '<team_build>',
+            `This folder is the team build "${here.project.name}". A functional colleague writes specs here and a developer builds them.`,
+            specs.length ? 'Specs in this folder:' : 'No specs yet.',
+            ...specs.map((s) => `- "${s.title}" — ${s.status} — ${questionsLine(s.openQuestions)}`),
+            'CSPeach keeps these specs and their answers: never read, parse or write the files under specs/ yourself.',
+            'To write a new spec or change one: hand_off with skill "abap-spec-gap" and what the spec is about.',
+        ];
+        if (seat === 'functional') {
+            lines.push('When the person says a spec is ready for the developer, CSPeach records it; this seat does not build.');
+        }
+        else {
+            // 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');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/renderer/routing-line.js

@@ -12,3 +12,14 @@ export function formatRoutingLine(e) {
         case 'cancelled': return formatInfo('Cancelled');
     }
 }
+/**
+ * F6 (2026-10-29 live run) — a slash command the person typed starts its
+ * skill without a word on screen; a routed one says "· Using /<skill>". Same
+ * line for the typed one. A queued command (hand-off, app chain) and a plan
+ * phase already have their own line: null.
+ */
+export function typedSkillLine(a) {
+    if (!a.skill || a.queued || a.planPhase)
+        return null;
+    return formatRoutingLine({ kind: 'using', skill: a.skill });
+}

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

@@ -13,6 +13,8 @@
  */
 import path from 'node:path';
 const PREFIX = /^\/abap-app\s+--from\s+@/;
+/** F10 — `/abap-app @…` with no --from. */
+const TYPED_SPEC = /^\/abap-app\s+@/;
 export const ANSWER = 'Answer them now';
 export const GO_AHEAD = 'Go ahead with them open';
 export const STOP = 'Stop';
@@ -25,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 [];
@@ -48,10 +68,30 @@ 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) {
-    if (!PREFIX.test(a.command))
-        return null;
-    const { parseFromFlag } = await import('../skills/promotion-dispatch.js');
-    const { fromPath } = parseFromFlag(a.command);
+    // 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 @
+    // (a document, a Markdown copy) is left for step 1, as before.
+    let command = a.command;
+    let fromPath;
+    if (PREFIX.test(command)) {
+        const { parseFromFlag } = await import('../skills/promotion-dispatch.js');
+        fromPath = parseFromFlag(command).fromPath ?? undefined;
+    }
+    else if (TYPED_SPEC.test(command)) {
+        const { extractSpecToken, cleanSpecToken } = await import('../lane/app-chain.js');
+        const raw = extractSpecToken(command);
+        const tok = raw === undefined ? '' : cleanSpecToken(raw);
+        if (!tok.endsWith('.cspeach.json'))
+            return null;
+        fromPath = tok;
+        // Final review M3: words typed after the spec ("use RAP") ride along.
+        const rest = /^\/abap-app\s+@(?:"[^"\r\n]*"|'[^'\r\n]*'|\S+)\s*([\s\S]*)$/.exec(command)?.[1]?.trim() ?? '';
+        command = `/abap-app --from @${/\s/.test(tok) ? `"${tok}"` : tok}${rest ? ` ${rest}` : ''}`;
+    }
     if (!fromPath)
         return null;
     const { buildFolderAt } = await import('../commands/team-spec.js');
@@ -72,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);
@@ -88,12 +127,33 @@ export async function openQuestionsGate(a) {
         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')}` });
+    // F10 — the build really starts here: a spec still "ready for build" (typed
+    // by hand, or handed off from the conversation) is recorded "being built" by
+    // this developer. The start screen records it itself, before the gate.
+    const markBeingBuilt = () => {
+        try {
+            if (share.readSpecStatus(specDir).current !== 'ready for build')
+                return;
+            share.writeStatusRecord(specDir, {
+                projectId: here.project.projectId, slug: path.basename(specDir), file, status: 'being built',
+                by: share.specAuthorFor(here.project.projectId, a.identity.name),
+                at: (a.now ?? (() => new Date().toISOString()))(),
+            });
+        }
+        catch { /* the build still goes on */ }
+    };
+    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);
         if (!qs.length)
-            return goOn({ command: a.command });
+            return goOn({ command });
         if (a.headless)
             return carried(qs);
         for (const q of qs)
@@ -130,7 +190,7 @@ export async function openQuestionsGate(a) {
             env = read(abs);
         }
         catch {
-            return goOn({ command: a.command });
+            return goOn({ command });
         }
     }
 }

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,21 +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(`  - "${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 };
@@ -60,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')
@@ -75,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/team-build-start.js

@@ -104,6 +104,7 @@ async function joinHere(dir, a) {
     const deps = {
         print: (l) => said.push(l),
         identity: () => ({ name: a.identity.name }),
+        account: () => a.identity.account,
         ...(a.now ? { now: a.now } : {}),
     };
     const code = await runTeamCommand(['join', dir, '--outbox', dir], deps);

package/dist/repl.js

@@ -14,7 +14,7 @@ import { startEarlyBrand, aliasSourceNote, panelsHintLine, panelsResumeLine, pan
 import { formatAttention, formatFailure, formatInfo } from './renderer/notice-shape.js';
 import { formatPanel } from './renderer/panel-rows.js';
 import { sanitizeControlChars } from './renderer/sanitize.js';
-import { formatRoutingLine } from './renderer/routing-line.js';
+import { formatRoutingLine, typedSkillLine } from './renderer/routing-line.js';
 import { handleUiLook, handleUiRendering } from './repl/ui-look-command.js';
 import { handleStyleCommand, pickStyleClassic, pickStyleInk } from './repl/style-command.js';
 import { handleLevelCommand, pickLevelClassic, pickLevelInk } from './repl/level-command.js';
@@ -456,6 +456,9 @@ export async function runRepl(opts) {
     let signedInAs;
     const showProfile = (profile) => {
         signedInAs = profile.email;
+        // S2 — remember the account so a team build names this person by it.
+        if (profile.email)
+            void import('./licence/account-name.js').then((m) => m.rememberAccount(profile.email)).catch(() => { });
         const banner = formatLoginBanner(profile);
         if (getLook() === 'panels') {
             signIn = signInFragment(profile);
@@ -1596,7 +1599,8 @@ export async function runRepl(opts) {
             }
             // Team build Task 11 — a shared spec's open questions travel with it
             // into the build. Anything not under the shared specs/ goes on unchanged.
-            if (/^\/abap-app\s+--from\b/.test(effectiveInput)) {
+            // F10 — a typed `/abap-app @<saved spec-gap>` goes through the gate too.
+            if (/^\/abap-app\s+(?:--from\b|@)/.test(effectiveInput)) {
                 try {
                     const { openQuestionsGate, gateChooser, STOPPED_LINE } = await import('./repl/open-questions-gate.js');
                     const { inkStartupChooser } = await import('./commands/plan-startup.js');
@@ -1604,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');
@@ -2199,6 +2203,10 @@ export async function runRepl(opts) {
                 }
                 // 2026-10-04 — the phase's expert skill rides along in the system prompt.
                 const planPhaseDelegate = planPhaseCtx?.nextDelegateTo;
+                // F6 — a slash command the person typed says which skill started.
+                const typedLine = typedSkillLine({ skill: parsed.skill, queued: !!submitOpts?.queued, planPhase: !!planPhaseCtx });
+                if (typedLine)
+                    chunkEmitter.emit('chunk', typedLine);
                 lastTurnBy = submitOpts?.queued?.by ?? 'person'; // Task 3
                 await runTurn({
                     provider,
@@ -2871,6 +2879,14 @@ export async function runRepl(opts) {
         // sits in this folder. Best-effort: never blocks the prompt.
         if (!isHeadless()) {
             void (async () => {
+                // F3 (2026-10-29 live run): wait until the screen listens. Without
+                // this the team-build lines vanished and its cards resolved
+                // "cancelled" before the screen had subscribed. Never hangs.
+                try {
+                    const { whenInkReady } = await import('./ui/when-listening.js');
+                    await whenInkReady(chunkEmitter);
+                }
+                catch { /* best-effort: carry on as before */ }
                 // Team build Task 8 — the folder sets itself up (spec 2026-10-25 §7.2):
                 // first, so its question never overlaps the offers below. The seat is
                 // settled by now (runStartupAccount / settleSeatAfterStartup above).
@@ -3921,7 +3937,8 @@ export async function runRepl(opts) {
                 continue;
         }
         // Team build Task 11 — the open-questions gate (classic mirror of the Ink path).
-        if (/^\/abap-app\s+--from\b/.test(resolvedTrimmed)) {
+        // F10 — a typed `/abap-app @<saved spec-gap>` goes through the gate too.
+        if (/^\/abap-app\s+(?:--from\b|@)/.test(resolvedTrimmed)) {
             try {
                 const { openQuestionsGate, gateChooser, STOPPED_LINE } = await import('./repl/open-questions-gate.js');
                 const { classicStartupChooser } = await import('./commands/plan-startup.js');
@@ -3930,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);
@@ -4464,6 +4481,10 @@ export async function runRepl(opts) {
             }
             // 2026-10-04 — the phase's expert skill rides along in the system prompt.
             const planPhaseDelegate = planPhaseCtx?.nextDelegateTo;
+            // F6 — a slash command the person typed says which skill started.
+            const typedLine = typedSkillLine({ skill: parsed.skill, queued: classicLineBy !== 'person', planPhase: !!planPhaseCtx });
+            if (typedLine)
+                console.log(typedLine.trimEnd());
             lastTurnBy = classicLineBy; // Task 3
             await runTurn({
                 provider,

package/dist/tools/_team-work-path.js

@@ -150,6 +150,30 @@ export function isTeamOwnedRel(rel) {
 }
 /** The refusal for a model write to one of the team project's own files. */
 export const TEAM_FILE_REFUSAL = 'This file belongs to the project and CSPeach writes it. Say what you want changed instead.';
+/**
+ * F5 — a write into a team build's shared specs/ folder: the refusal names
+ * the route, so the model takes it on the same turn instead of saving the
+ * spec somewhere else.
+ */
+export const SPECS_REFUSAL = 'Specs in this folder are written and shared by CSPeach, never by a file write. For a new or changed spec, hand_off with skill "abap-spec-gap"; to build a ready spec, hand_off with skill "abap-app".';
+/** The refusal for a team-owned target: the specs/ route, or today's line. */
+export function teamFileRefusalFor(cwd, realTarget) {
+    const root = teamWorkRoot(cwd);
+    if (root === null)
+        return TEAM_FILE_REFUSAL;
+    const realOf = (p) => { try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return p;
+    } };
+    for (const specs of new Set([path.join(path.resolve(cwd), 'specs'), realOf(path.join(path.resolve(cwd), 'specs'))])) {
+        const rel = path.relative(specs, realTarget);
+        if (rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel))
+            return SPECS_REFUSAL;
+    }
+    return TEAM_FILE_REFUSAL;
+}
 /**
  * True when `cwd` is a team folder and the REAL landing path of a write lies
  * on one of its own files (isTeamOwnedRel), whatever spelling, link or short

package/dist/tools/filesystem/file-edit.js

@@ -15,7 +15,7 @@ import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, blockedExecutableExtension, } from '../_filesystem-shared.js';
-import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamFileRefusalFor, teamWorkTarget } from '../_team-work-path.js';
 export async function fileEditHandler(args, ctx) {
     // 1. Validate args before any IO
     if (args.old_string === args.new_string) {
@@ -79,7 +79,7 @@ export async function fileEditHandler(args, ctx) {
     //     write. Judged on the real landing path. A folder without a team
     //     project never gets here.
     if (pointsAtTeamFile(ctx.cwd, realAbs)) {
-        return { content: `error: ${TEAM_FILE_REFUSAL}`, is_error: true };
+        return { content: `error: ${teamFileRefusalFor(ctx.cwd, realAbs)}`, is_error: true };
     }
     // 5. Read the file
     let content;

package/dist/tools/filesystem/file-write.js

@@ -19,7 +19,7 @@ import { promises as fs, readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, realPathForWrite, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, blockedExecutableExtension, } from '../_filesystem-shared.js';
-import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamFileRefusalFor, teamWorkTarget } from '../_team-work-path.js';
 /**
  * 2026-09-23 (Glenn's first run) — a standalone run writes GUIDE.md and said
  * nothing about it. He opened it in a text editor, then tried to drop it into
@@ -112,7 +112,7 @@ export async function fileWriteHandler(args, ctx) {
     //     write. Judged on the real landing path. A folder without a team
     //     project never gets here.
     if (pointsAtTeamFile(ctx.cwd, target)) {
-        return { content: `error: ${TEAM_FILE_REFUSAL}`, is_error: true };
+        return { content: `error: ${teamFileRefusalFor(ctx.cwd, target)}`, is_error: true };
     }
     // 4. Ensure parent directory exists (no-op if it already does)
     try {

package/dist/tools/hand-off.js

@@ -107,7 +107,22 @@ registerTool({
         if (request.length > HAND_OFF_REQUEST_MAX) {
             return bad('HAND_OFF_INVALID', `request is too long (${request.length} chars; at most ${HAND_OFF_REQUEST_MAX}). Say it in one short sentence with the object names.`);
         }
-        const command = buildHandOffCommand(skill, request);
+        let command = buildHandOffCommand(skill, request);
+        // F9a (2026-10-29 live run): in a team build folder a hand-off to the
+        // build workflow carries the ready spec, so the app flow starts at the
+        // lane step instead of refusing for want of an @file.
+        if (skill === 'abap-app' && !request.includes('@')) {
+            const { readySpecFor, notReadyLine } = await import('../lane/ready-spec.js');
+            const picked = await readySpecFor(ctx.cwd ?? process.cwd(), request);
+            if (picked && 'notReady' in picked) {
+                return bad('HAND_OFF_SPEC_NOT_READY', `${notReadyLine(picked.notReady)} Tell the person; do not build another spec instead.`);
+            }
+            if (picked && 'ask' in picked) {
+                return bad('HAND_OFF_SPEC_NEEDED', `more than one spec here is ready to build: ${picked.ask.join('; ')}. Ask which one, then hand off with its title in the request.`);
+            }
+            if (picked)
+                command = picked.command;
+        }
         if (isPlanResumeCommand(command)) {
             return bad('PLAN_RESUME_HARNESS_OWNED', 'Plan continuation is owned by CSPeach; never hand off "/abap-plan --resume".');
         }

package/dist/ui/when-listening.js

@@ -0,0 +1,34 @@
+/** Resolves true once `event` has a listener on `emitter`, false after `timeoutMs`. */
+export function whenListening(emitter, event, timeoutMs = 3000) {
+    if (emitter.listenerCount(event) > 0)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let timer;
+        const onNew = (name) => {
+            if (name !== event)
+                return;
+            done(true);
+        };
+        const done = (ok) => {
+            emitter.off('newListener', onNew);
+            if (timer)
+                clearTimeout(timer);
+            // 'newListener' fires just before the listener is added: settle on the
+            // next turn so an emit made after awaiting this reaches it.
+            setImmediate(() => resolve(ok));
+        };
+        timer = setTimeout(() => done(false), timeoutMs);
+        emitter.on('newListener', onNew);
+    });
+}
+/** The Ink screen is ready for start-up output: it takes lines, cards and questions. */
+export async function whenInkReady(chunkEmitter, timeoutMs = 3000) {
+    const { cardSlotEmitter } = await import('./card-slot.js');
+    const { askQuestionEmitter } = await import('./ask-question-emitter.js');
+    const ready = await Promise.all([
+        whenListening(chunkEmitter, 'chunk', timeoutMs),
+        whenListening(cardSlotEmitter, 'confirm', timeoutMs),
+        whenListening(askQuestionEmitter, 'request', timeoutMs),
+    ]);
+    return ready.every(Boolean);
+}

package/package.json

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