@cspeach/cli 1.1.53 → 1.1.55

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

@@ -0,0 +1,179 @@
+/**
+ * Team build (spec 2026-10-25 §7.2) — the folder sets itself up when someone
+ * types `cspeach`. Nobody types a team command:
+ *
+ *   - a functional seat in a folder that is not a team project gets a team
+ *     build, with one line. A folder that already holds files asks first
+ *     (default No), so opening CSPeach in Documents by mistake changes nothing.
+ *   - a developer is offered a team build once per folder (default No), never
+ *     in the home folder. The answer is remembered, so a scratch folder sees
+ *     the question once and nothing changes.
+ *   - anyone in a team build folder they have not joined is joined, one line.
+ *   - an old build folder gets the one "build type changed" line.
+ *   - clean-core and upgrade folders: nothing at all, as today.
+ *
+ * Runs at start-up only in an interactive run, after the seat is settled.
+ * Never throws: a problem is one line, and CSPeach starts as usual.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { TEAM_FILE, activeProject, readProjectFile, } from '../register/store.js';
+import { LEGACY_BUILD_LINE, createBuildProject, isBuildProject, isLegacyBuildFolder } from '../commands/team-build.js';
+import { runTeamCommand } from '../commands/team.js';
+import { resolveProjectFolderSync } from '../projects/project-folder.js';
+import { normDir } from '../session/project-match.js';
+import { cspeachRoot } from '../config/paths.js';
+import { writeWhole } from '../register/write-whole.js';
+export const SETUP_LINE = 'Set up as a team build folder. Your specs save here for the developer.';
+export const FILES_QUESTION = 'This folder already has files in it. Set it up as a team build folder?';
+export const NOT_SET_UP_LINE = 'Not set up. Start CSPeach in an empty folder for the team build.';
+export const DEVELOPER_OFFER = 'Set this folder up as a team build (one shared folder for the spec and the build)?';
+export const joinedLine = (name, lead) => `Joined the team build "${name}" (lead ${lead}).`;
+/** What CSPeach itself leaves in a folder: none of it means "this folder holds files". */
+const OURS = new Set(['.cspeach', 'cspeach-out', '.git', '.gitignore']);
+export function folderState(cwd) {
+    const dir = path.resolve(cwd);
+    if (!fs.existsSync(path.join(dir, TEAM_FILE))) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch { /* unreadable folder: treat as empty of files */ }
+        return { kind: 'not-team', hasFiles: entries.some((e) => !OURS.has(e)), isHome: resolveProjectFolderSync(dir).kind === 'home' };
+    }
+    let project;
+    try {
+        project = readProjectFile(dir);
+    }
+    catch (e) {
+        return { kind: 'unreadable', line: e instanceof Error ? e.message : String(e) };
+    }
+    if (isBuildProject(project)) {
+        const joined = activeProject();
+        return { kind: 'build', project, joined: !!joined && joined.projectId === project.projectId && normDir(joined.projectDir) === normDir(dir) };
+    }
+    if (isLegacyBuildFolder(project))
+        return { kind: 'legacy-build' };
+    return { kind: 'other-team' };
+}
+const offersFile = () => path.join(cspeachRoot(), 'team-build-offers.json');
+function readOffered() {
+    try {
+        const raw = fs.readFileSync(offersFile(), 'utf8');
+        const j = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
+        return Array.isArray(j?.offered) ? j.offered.filter((x) => typeof x === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** `<CSPEACH_HOME>/team-build-offers.json`: `{ offered: [normDir, …] }`. */
+export function fileOfferMemory() {
+    return {
+        wasOffered: async (dir) => readOffered().includes(normDir(dir)),
+        markOffered: async (dir) => {
+            const offered = readOffered();
+            const k = normDir(dir);
+            if (offered.includes(k))
+                return;
+            writeWhole(offersFile(), `${JSON.stringify({ offered: [...offered, k] }, null, 2)}\n`);
+        },
+    };
+}
+/**
+ * Ruling R10: CSPeach joins a team build by itself only when no project is
+ * active, or the active one is a team build too. A clean-core or upgrade
+ * project this laptop works on stays the active one: the journey and the team
+ * tools read `activeProject()`. An active project we cannot read is left
+ * alone as well.
+ */
+export function mayAutoJoin() {
+    try {
+        const active = activeProject();
+        if (!active)
+            return true;
+        return isBuildProject(readProjectFile(active.projectDir));
+    }
+    catch {
+        return false;
+    }
+}
+/** Join through the same route as `cspeach team join`, quietly. Failure: its own line(s). */
+async function joinHere(dir, a) {
+    const said = [];
+    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);
+    if (code !== 0)
+        for (const l of said)
+            a.emit(l);
+    return code === 0;
+}
+async function setUp(dir, a) {
+    const lead = a.identity.account ? { name: a.identity.name, account: a.identity.account } : { name: a.identity.name };
+    const project = createBuildProject(dir, {
+        name: path.basename(dir) || 'Team build',
+        lead,
+        now: (a.now ?? (() => new Date()))(),
+        ...(a.rand ? { rand: a.rand } : {}),
+    });
+    if (mayAutoJoin() && !(await joinHere(dir, a)))
+        return null;
+    a.emit(SETUP_LINE);
+    return project;
+}
+export async function startTeamBuildFolder(a) {
+    const dir = path.resolve(a.cwd);
+    try {
+        const state = folderState(dir);
+        switch (state.kind) {
+            case 'other-team': return { project: null };
+            case 'unreadable':
+                a.emit(state.line);
+                return { project: null };
+            case 'legacy-build':
+                a.emit(LEGACY_BUILD_LINE);
+                return { project: null };
+            case 'build': {
+                if (state.joined || !mayAutoJoin())
+                    return { project: state.project };
+                if (!(await joinHere(dir, a)))
+                    return { project: null };
+                a.emit(joinedLine(state.project.name, state.project.lead.name));
+                return { project: state.project };
+            }
+            case 'not-team': {
+                if (a.seat === 'functional') {
+                    // The home folder is never a team build: it is where CSPeach keeps its own files.
+                    if (state.isHome) {
+                        a.emit(NOT_SET_UP_LINE);
+                        return { project: null };
+                    }
+                    if (state.hasFiles && (await a.confirm(FILES_QUESTION, { default: 'n' })) !== 'y') {
+                        a.emit(NOT_SET_UP_LINE);
+                        return { project: null };
+                    }
+                    return { project: await setUp(dir, a) };
+                }
+                if (state.isHome || (await a.memory.wasOffered(dir)))
+                    return { project: null };
+                const answer = await a.confirm(DEVELOPER_OFFER, { default: 'n' });
+                try {
+                    await a.memory.markOffered(dir);
+                }
+                catch { /* a failed offer write says nothing */ }
+                if (answer !== 'y')
+                    return { project: null };
+                return { project: await setUp(dir, a) };
+            }
+        }
+    }
+    catch (e) {
+        a.emit(e instanceof Error ? e.message.split('\n')[0] : String(e));
+        return { project: null };
+    }
+}

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';
@@ -39,9 +39,11 @@ import { getStore } from './auth/api-key.js';
 import { readAuthFile } from './auth/auth-file.js';
 import { resolveApiKey } from './auth/key-resolver.js';
 import { fetchMe } from './auth/me.js';
+import { resolveSeatKind, readSeatRecord, writeSeatRecord, seatSignInMessage, isLegacySignIn, READ_ONLY_SEAT_LINE } from './licence/seat-kind.js';
+import { setSeatKind, isFunctionalSeat, getSeatKind } from './licence/seat-state.js';
 import { runLicenceCheck, licenceCheckHeaders } from './licence/licence-check.js';
 import { LicenceTurnGate } from './licence/turn-gate.js';
-import { runStartupAccount } from './repl/startup-account.js';
+import { runStartupAccount, settleSeatAfterStartup } from './repl/startup-account.js';
 import { startSkillsCacheWarmup } from './skills/source-authed.js';
 import { formatLoginBanner, signInFragment } from './ui/login-banner.js';
 import { printStartupBanner, printKeytarFallbackBanner, keychainFallbackNotice } from './renderer/banners.js';
@@ -70,6 +72,7 @@ import { createProviderForMode } from './agent/providers/factory.js';
 import { startUsageFlushAtStartup } from './usage/usage-reporter.js';
 import { assertModeLicensed, CspeachLicenseError } from './agent/providers/license-gate.js';
 import { runTurn } from './agent/loop.js';
+import { isReadyForDeveloperPhrase } from './repl/ready-phrase.js';
 import { IdleKeepalive } from './agent/cache-keepalive.js';
 import { renderTurnError } from './agent/turn-error-ux.js';
 import { runRerouteTurn } from './repl/reroute-turn.js';
@@ -453,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);
@@ -469,6 +475,8 @@ export async function runRepl(opts) {
         loadConfig, readAuthFile, resolveApiKey: () => resolveApiKey(), fetchMe, runLicenceCheck, licenceCheckHeaders,
         // Final review finding 1 — fill the skills cache for offline use. Fire-and-forget.
         startSkillsWarmup: (c, verdict) => { void startSkillsCacheWarmup(c, verdict); },
+        // Team build Task 5 — the seat kind for this run.
+        readSeatRecord, writeSeatRecord, setSeatKind,
     }, {
         print: (line) => console.log(line),
         notice: (note) => {
@@ -496,6 +504,7 @@ export async function runRepl(opts) {
         else
             printKeytarFallbackBanner();
     }
+    let seat = startupAccount.seat ?? 'developer';
     if (!apiKey) {
         const entered = await promptPassword({
             message: 'Paste your CSPeach API key (from invite email):',
@@ -504,6 +513,17 @@ export async function runRepl(opts) {
         await store.set(entered);
         apiKey = entered;
     }
+    // Team build Task 5, ruling R7a — a key and no seat yet (managed without
+    // auth.json: a stored key, or one pasted just now): settle it here. Only
+    // when start-up resolved nothing, so it never repeats start-up's /v1/me.
+    if (startupAccount.seat === undefined && apiKey) {
+        const settled = await settleSeatAfterStartup({ fetchMe, readAuthFile, readSeatRecord, writeSeatRecord, setSeatKind }, { proxyUrl: (await loadConfig()).proxy_url, apiKey });
+        if (settled === null) {
+            console.log(seatSignInMessage());
+            return 1;
+        }
+        seat = settled;
+    }
     let cfg = await loadConfig();
     setLook(cfg.ui.look);
     // Chat lane (spec 2026-10-17 D1/D2/D5/D9) — the process lane and talking
@@ -515,6 +535,10 @@ export async function runRepl(opts) {
     applyLaneTools(laneSetting, !!process.stdin.isTTY);
     setAssistantStyle(cfg.assistant.style);
     setAssistantLevel(cfg.assistant.level);
+    // Team build Task 5 — the developer default follows a functional seat; an
+    // explicit level stays, and /level still works for the session.
+    if (seat === 'functional' && cfg.assistant.level === 'developer')
+        setAssistantLevel('functional');
     // Apply the rendering mode BEFORE any shouldUseInk() call. This is the
     // interactive entry point, so it is never one-shot whatever argv holds. A
     // stored `classic` is retiring: read as auto, rewritten once, one dim notice
@@ -670,7 +694,18 @@ export async function runRepl(opts) {
         // The config hint only makes sense when config CAUSED advisory.
         next: capped === '' ? 'cspeach config set write_mode approval-gated' : undefined,
     });
-    if (!anyRoleConfigured) {
+    // Team build Task 6 — a functional seat gets the seat line once, instead of
+    // the write-mode banner and its `cspeach config set` hint (config cannot
+    // lift it); both the no-role path here and the role path below skip it.
+    const functionalSeat = isFunctionalSeat();
+    if (functionalSeat) {
+        const seatLine = formatInfo(READ_ONLY_SEAT_LINE);
+        if (getLook() === 'panels')
+            startupNotices.push(seatLine);
+        else
+            console.log(seatLine);
+    }
+    else if (!anyRoleConfigured) {
         if (cfg.write_mode === 'advisory-only') {
             if (getLook() === 'panels')
                 startupNotices.push(advisoryNotice(''));
@@ -747,7 +782,7 @@ export async function runRepl(opts) {
     // byte-identical to pre-role behavior).
     const aliasRole = cfg.sap[selectedAlias]?.role;
     const startupWriteMode = getEffectiveWriteMode(cfg.write_mode, aliasRole);
-    if (anyRoleConfigured) {
+    if (anyRoleConfigured && !functionalSeat) {
         const capped = startupWriteMode !== cfg.write_mode
             ? ` (capped by sap.${selectedAlias}.role = ${aliasRole})`
             : '';
@@ -871,6 +906,24 @@ export async function runRepl(opts) {
         // No start-up check ran (no key yet, e.g. pasted at the prompt below):
         // non-managed checks on the very first turn. Managed never reads it.
         lastCheckAtMs: licenceCheckedAtMs ?? (cfg.llm.mode === 'managed' ? Date.now() : -Infinity),
+        // Team build Task 5 — the seat refreshes with the licence every 4 hours: a
+        // fresh answer wins (a developer→functional flip applies at the next
+        // turn; a fresh developer lifts a stale functional lock), else the stored
+        // record. An unconfirmed seat mid-session changes nothing.
+        onSeat: async (d) => {
+            const key = await store.get();
+            if (!key)
+                return;
+            const r = resolveSeatKind({
+                fresh: d.allow && d.verdict === 'ok' && d.profile ? { ok: true, profile: d.profile, serverDate: null } : null,
+                stored: await readSeatRecord(), apiKey: key, now: new Date(), legacySignIn: isLegacySignIn(await readAuthFile()),
+            });
+            if (!r.ok)
+                return;
+            if (r.write)
+                await writeSeatRecord(r.write).catch(() => { });
+            setSeatKind(r.kind);
+        },
         ...(cfg.llm.mode === 'azure' ? {
             extra: async () => (await import('./connection/azure-gate.js')).azureGateCheck(),
             // Plan D13 — never a prompt between turns (no inquirer inside the Ink
@@ -1326,6 +1379,9 @@ export async function runRepl(opts) {
                     if (result.kind === 'command') {
                         chunkEmitter.emit('chunk', formatInfo(result.command));
                     }
+                    else if (result.kind === 'info') {
+                        chunkEmitter.emit('chunk', result.text + '\n');
+                    }
                     else if (result.kind === 'empty') {
                         // Empty workspace — print the listing so the user sees the
                         // workspace path and the "drop something here" hint. Skipped
@@ -1529,6 +1585,42 @@ export async function runRepl(opts) {
                     effectiveInput = expansion.text;
                 }
             }
+            // Team build Task 10 — "this is ready for the developer" in a team build
+            // folder marks the spec ready for build; no model turn. The phrase is
+            // checked first (no file read); anything else goes on exactly as before.
+            if (isReadyForDeveloperPhrase(trimmed)) {
+                const { readyForDeveloperDoor, inkSpecChooser } = await import('./repl/ready-phrase.js');
+                const { getAuthorIdentity } = await import('./agent/loop.js');
+                if (await readyForDeveloperDoor(trimmed, {
+                    cwd: process.cwd(), identityName: getAuthorIdentity().name,
+                    emit: (line) => chunkEmitter.emit('chunk', line + '\n'), choose: inkSpecChooser(),
+                }))
+                    return;
+            }
+            // 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.
+            // 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');
+                    const { getAuthorIdentity, inkAwareChoose, inkAwarePrompt } = await import('./agent/loop.js');
+                    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(),
+                    });
+                    if (g && 'stop' in g) {
+                        chunkEmitter.emit('chunk', STOPPED_LINE + '\n');
+                        return;
+                    }
+                    if (g)
+                        effectiveInput = g.command;
+                }
+                catch (e) {
+                    chunkEmitter.emit('chunk', `${(e instanceof Error ? e.message : String(e)).split('\n')[0]}\n`);
+                }
+            }
             // Guided runs — the one front door for Ink, classic and one-shot:
             // the /run verb (rewritten to its alias), then today's trigger. The
             // trigger still decides (spec §4 step 2); the dispatch below is unchanged.
@@ -2111,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,
@@ -2783,6 +2879,49 @@ 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).
+                try {
+                    const { startTeamBuildFolder, fileOfferMemory } = await import('./repl/team-build-start.js');
+                    const { inkAwareConfirm, getAuthorIdentity } = await import('./agent/loop.js');
+                    await startTeamBuildFolder({
+                        cwd: process.cwd(),
+                        seat: getSeatKind(),
+                        identity: { name: getAuthorIdentity().name, ...(signedInAs ? { account: signedInAs } : {}) },
+                        confirm: inkAwareConfirm,
+                        emit: (l) => chunkEmitter.emit('chunk', l + '\n'),
+                        memory: fileOfferMemory(),
+                    });
+                }
+                catch { /* the folder step is best-effort */ }
+                // Team build Task 11 — the start screen: the shared specs of the build
+                // folder CSPeach runs in (R10), and the build offer (developers only).
+                // A submitted build or question is the next turn: the offers below wait.
+                try {
+                    const { runStartScreen } = await import('./repl/team-build-screen.js');
+                    const { inkStartupChooser } = await import('./commands/plan-startup.js');
+                    const { getAuthorIdentity } = await import('./agent/loop.js');
+                    const screen = await runStartScreen({
+                        cwd: process.cwd(),
+                        seat: getSeatKind(),
+                        identityName: getAuthorIdentity().name,
+                        choose: inkStartupChooser(),
+                        submit: (cmd) => { void handleSubmit(cmd); },
+                        emit: (l) => chunkEmitter.emit('chunk', l + '\n'),
+                    });
+                    if (screen.submitted)
+                        return;
+                }
+                catch { /* the start screen is best-effort */ }
                 // 2026-10-08 — one-time offer to retire the old `workspace_folder`
                 // setting, before the plan offer so the two never overlap.
                 try {
@@ -3112,16 +3251,50 @@ export async function runRepl(opts) {
     }, { input: pasteInput });
     // 2026-10-08: one-time offer to retire the old `workspace_folder` setting
     // (files now save in the folder you start in). Best-effort, never blocks.
+    // Team build Task 11 — a build or question the start screen queued is the
+    // next line; the retire and plan offers then stay quiet.
+    let teamBuildSubmitted = false;
     if (!isHeadless()) {
+        // Team build Task 8 — the folder step, first (same as the Ink path).
         try {
-            const { maybeOfferWorkspaceRetire } = await import('./projects/workspace-retire.js');
-            const { inkAwareConfirm } = await import('./agent/loop.js');
-            await maybeOfferWorkspaceRetire({
-                confirm: async (q) => (await inkAwareConfirm(q, { default: 'y' })) === 'y',
-                log: (line) => console.log(chalk.dim(line)),
+            const { startTeamBuildFolder, fileOfferMemory } = await import('./repl/team-build-start.js');
+            const { inkAwareConfirm, getAuthorIdentity } = await import('./agent/loop.js');
+            await startTeamBuildFolder({
+                cwd: process.cwd(),
+                seat: getSeatKind(),
+                identity: { name: getAuthorIdentity().name, ...(signedInAs ? { account: signedInAs } : {}) },
+                confirm: inkAwareConfirm,
+                emit: (l) => console.log(l),
+                memory: fileOfferMemory(),
             });
         }
         catch { /* best-effort */ }
+        // Team build Task 11 — the start screen (same as the Ink path).
+        try {
+            const { runStartScreen } = await import('./repl/team-build-screen.js');
+            const { classicStartupChooser } = await import('./commands/plan-startup.js');
+            const { getAuthorIdentity, inkAwarePrompt } = await import('./agent/loop.js');
+            const screen = await runStartScreen({
+                cwd: process.cwd(),
+                seat: getSeatKind(),
+                identityName: getAuthorIdentity().name,
+                choose: classicStartupChooser(inkAwarePrompt, (...l) => l.forEach((x) => console.log(x))),
+                submit: (cmd) => pendingDispatchAccessor.set(cmd),
+                emit: (l) => console.log(l),
+            });
+            teamBuildSubmitted = screen.submitted;
+        }
+        catch { /* best-effort */ }
+        if (!teamBuildSubmitted)
+            try {
+                const { maybeOfferWorkspaceRetire } = await import('./projects/workspace-retire.js');
+                const { inkAwareConfirm } = await import('./agent/loop.js');
+                await maybeOfferWorkspaceRetire({
+                    confirm: async (q) => (await inkAwareConfirm(q, { default: 'y' })) === 'y',
+                    log: (line) => console.log(chalk.dim(line)),
+                });
+            }
+            catch { /* best-effort */ }
     }
     // 2026-06-15: one-time output-namespace migration. The customer-output
     // root was renamed from the dead-brand `.abapforge/` to `.cspeach/`.
@@ -3146,7 +3319,7 @@ export async function runRepl(opts) {
     }
     // 2026-10-04 (spec §3.5) — "Continue '<plan>'?" (classic: numbered
     // choices, Enter = the first). Continue queues the resume for the loop.
-    if (!isHeadless()) {
+    if (!isHeadless() && !teamBuildSubmitted) {
         try {
             const { offerContinueAtStartup, classicStartupChooser } = await import('./commands/plan-startup.js');
             const { inkAwarePrompt } = await import('./agent/loop.js');
@@ -3460,6 +3633,9 @@ export async function runRepl(opts) {
                     console.log(formatInfo('Picked · press Enter to run, or edit first').trimEnd());
                     pendingPrefill = result.command;
                 }
+                else if (result.kind === 'info') {
+                    console.log(result.text);
+                }
                 else if (result.kind === 'empty') {
                     // Empty workspace — print the listing so the user sees the
                     // workspace path and the "drop something here" hint. Skipped
@@ -3740,6 +3916,9 @@ export async function runRepl(opts) {
         // UX-5 #2 (2026-06-12) — numbered-menu expansion (classic mirror of the
         // Ink block above). Bare `2` after a plain-text numbered menu expands
         // to that item's text with a dim echo; everything else passes through.
+        // Team build Task 10 — the ready door checks what was typed, before a
+        // menu number is expanded (the same text as the Ink door's `trimmed`).
+        const typedText = resolvedTrimmed;
         {
             const expansion = maybeExpandNumberSelection(resolvedTrimmed, lastAssistantText(session.messages));
             if (expansion) {
@@ -3747,6 +3926,40 @@ export async function runRepl(opts) {
                 resolvedTrimmed = expansion.text;
             }
         }
+        // Team build Task 10 — the ready phrase (classic mirror of the Ink door).
+        if (isReadyForDeveloperPhrase(typedText)) {
+            const { readyForDeveloperDoor, classicSpecChooser } = await import('./repl/ready-phrase.js');
+            const { getAuthorIdentity, inkAwarePrompt } = await import('./agent/loop.js');
+            if (await readyForDeveloperDoor(typedText, {
+                cwd: process.cwd(), identityName: getAuthorIdentity().name,
+                emit: (line) => console.log(line), choose: classicSpecChooser(inkAwarePrompt, (line) => console.log(line)),
+            }))
+                continue;
+        }
+        // Team build Task 11 — the open-questions gate (classic mirror of the Ink path).
+        // 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');
+                const { getAuthorIdentity, inkAwareChoose, inkAwarePrompt } = await import('./agent/loop.js');
+                const g = await openQuestionsGate({
+                    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(),
+                });
+                if (g && 'stop' in g) {
+                    console.log(STOPPED_LINE);
+                    continue;
+                }
+                if (g)
+                    resolvedTrimmed = g.command;
+            }
+            catch (e) {
+                console.log((e instanceof Error ? e.message : String(e)).split('\n')[0]);
+            }
+        }
         // Guided runs — the same front door as the Ink path: the /run verb
         // (rewritten to its alias), then today's trigger. The trigger still
         // decides (spec §4 step 2); the dispatch below is unchanged.
@@ -4268,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/sap-link/policy.js

@@ -112,6 +112,8 @@ export function writesBlockedMessage(alias, role) {
     const now = role === undefined ? 'has no role set' : `has role ${role}`;
     return `Writes to ${alias} need role dev. ${alias} ${now}. Set it with: cspeach config set sap.${alias}.role dev`;
 }
+/** Team build (final review F3): the one line a read-only seat's link says, at start and on every refused write. */
+export const READ_ONLY_LINK_LINE = 'Read-only seat: the SAP link reads and never writes.';
 export function decideRequest(input) {
     const m = effectiveMethod(input.method, input.headers);
     if ('error' in m)
@@ -178,6 +180,8 @@ export function decideRequest(input) {
         };
     }
     const write = verbIsWrite || isBatchPath(url.pathname);
+    if (write && input.seatReadOnly)
+        return { allow: false, status: 403, message: READ_ONLY_LINK_LINE };
     if (write && input.role !== 'dev') {
         return { allow: false, status: 403, message: writesBlockedMessage(input.alias, input.role) };
     }

package/dist/sap-link/registry.js

@@ -26,6 +26,8 @@ import { readLinkTargets } from './project.js';
 import { startSapLink, SapLinkStartError } from './server.js';
 import { UpstreamSession } from './upstream.js';
 import { registerShutdownHook } from '../lib/shutdown-hooks.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
+import { READ_ONLY_LINK_LINE } from './policy.js';
 /** A registry error. Its message is always a fixed, plain, secret-free sentence. */
 export class SapLinkError extends Error {
 }
@@ -113,6 +115,7 @@ async function ensureUnlocked(projectDir, alias, partial) {
         password: (a, s) => resolveSapPassword(a, s, { headless: () => true }),
         readCa: (p) => readFileSync(p),
         start: startSapLink,
+        readOnlySeat: isFunctionalSeat,
         ...partial,
     };
     // package.json first: its errors are plain LinkConfigErrors and need no SAP settings.
@@ -134,7 +137,9 @@ async function ensureUnlocked(projectDir, alias, partial) {
             await stopUnlocked(projectDir);
         throw new SapLinkError(`No SAP system named ${alias}. Add it with: cspeach config add-sap`);
     }
-    const roleNote = roleNoteFor(alias, sys.role);
+    // A read-only seat: one line of its own; the role note would point at a setting that changes nothing.
+    const seatNote = deps.readOnlySeat() ? READ_ONLY_LINK_LINE : undefined;
+    const roleNote = seatNote ? undefined : roleNoteFor(alias, sys.role);
     const fingerprint = fingerprintFor(sys);
     const existing = links.get(k);
     if (existing && existing.alias === alias && existing.fingerprint === fingerprint &&
@@ -142,7 +147,7 @@ async function ensureUnlocked(projectDir, alias, partial) {
         // A link whose upstream got a 401 refuses every send: start means restart (new session, new password).
         !existing.upstream.isLoginRejected()) {
         // TLS/http notes describe the running link; the role is read fresh (the server does too).
-        return { handle: existing.handle, reused: true, services, ...existing.postureNotes, ...(roleNote ? { roleNote } : {}) };
+        return { handle: existing.handle, reused: true, services, ...existing.postureNotes, ...(roleNote ? { roleNote } : {}), ...(seatNote ? { seatNote } : {}) };
     }
     // Another alias, connection, auth type, TLS posture, port or service list, or a rejected login: the old link goes first.
     if (existing)
@@ -199,6 +204,7 @@ async function ensureUnlocked(projectDir, alias, partial) {
             upstream,
             secret: { password, username: sys.username },
             writeLogFile: writeLogFileFor(projectDir),
+            readOnlySeat: () => deps.readOnlySeat(),
         });
     }
     catch (e) {
@@ -213,7 +219,7 @@ async function ensureUnlocked(projectDir, alias, partial) {
     const postureNotes = postureNotesFor(alias, sys);
     links.set(k, { projectDir: path.resolve(projectDir), alias, prefixes, requestedPort: targets.port, fingerprint, postureNotes, handle, upstream });
     installSapLinkExitHandler();
-    return { handle, reused: false, services, ...postureNotes, ...(roleNote ? { roleNote } : {}) };
+    return { handle, reused: false, services, ...postureNotes, ...(roleNote ? { roleNote } : {}), ...(seatNote ? { seatNote } : {}) };
 }
 export function stopSapLink(projectDir) {
     return serial(() => stopUnlocked(projectDir));

package/dist/sap-link/server.js

@@ -39,7 +39,7 @@
  *     failed pass-through never says "OK".
  */
 import * as http from 'node:http';
-import { decideRequest, writesBlockedMessage } from './policy.js';
+import { decideRequest, READ_ONLY_LINK_LINE, writesBlockedMessage } from './policy.js';
 import { appendWriteRow } from './write-log.js';
 export class SapLinkStartError extends Error {
     code;
@@ -210,6 +210,7 @@ export async function startSapLink(opts) {
             method: req.method ?? 'GET', rawUrl: req.url ?? '/',
             headers: req.headers,
             allowedPrefixes: opts.allowedPrefixes, alias: opts.alias, role,
+            ...(opts.readOnlySeat?.() ? { seatReadOnly: true } : {}),
         });
         if (!d.allow)
             return plain(res, d.status, d.message);
@@ -233,6 +234,8 @@ export async function startSapLink(opts) {
             catch {
                 return plain(res, 503, SETTINGS_UNREADABLE);
             }
+            if (opts.readOnlySeat?.())
+                return plain(res, 403, READ_ONLY_LINK_LINE);
             if (again !== 'dev')
                 return plain(res, 403, writesBlockedMessage(opts.alias, again));
         }