@cspeach/cli 1.1.54 → 1.1.55

package/dist/agent/loop.js

@@ -4,6 +4,7 @@ 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';
@@ -105,6 +106,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 ??
@@ -938,7 +941,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' };
     }
@@ -1169,7 +1199,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 +1223,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,32 @@
+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);
+        const ready = all.filter((s) => s.status === 'ready for build');
+        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/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, '-');
@@ -196,7 +223,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 +241,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,49 @@
+/**
+ * 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 {
+            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.');
+        }
+        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';
@@ -48,10 +50,27 @@ 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);
+    // 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');
@@ -88,12 +107,27 @@ 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(); 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 +164,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

@@ -31,6 +31,14 @@ export function startScreenLines(specs, _seat) {
         else {
             out.push(`${s.status === 'draft' ? 'Draft' : 'Being built'}: ${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:');
+            for (const c of changed)
+                out.push(`  - "${c.question}" now "${c.answer}" (${c.by}, ${day(c.at)}), was "${c.was}" (${c.wasBy})`);
+        }
     }
     return out;
 }

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');
@@ -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');
@@ -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.55",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",