@cspeach/cli 1.1.53 → 1.1.55

package/dist/repl/file-picker.js

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

package/dist/repl/mode-cycle.js

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

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

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

package/dist/repl/ready-phrase.js

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

package/dist/repl/startup-account.js

@@ -1,6 +1,24 @@
 import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
+import { resolveSeatKind, seatSignInMessage, isLegacySignIn } from '../licence/seat-kind.js';
 export async function runStartupAccount(deps, io) {
     let licenceCheckedAtMs;
+    let seat;
+    // The seat for this start; false = not confirmed (the caller exits 1).
+    const settleSeat = async (fresh, apiKey, authFile) => {
+        const r = resolveSeatKind({
+            fresh, stored: await deps.readSeatRecord(), apiKey, now: new Date((deps.now ?? Date.now)()), legacySignIn: isLegacySignIn(authFile),
+        });
+        if (!r.ok) {
+            io.closeBrand();
+            io.print(seatSignInMessage());
+            return false;
+        }
+        if (r.write)
+            await deps.writeSeatRecord(r.write).catch(() => { });
+        deps.setSeatKind(r.kind);
+        seat = r.kind;
+        return true;
+    };
     try {
         const cfgEarly = await deps.loadConfig();
         if (cfgEarly.llm.mode === 'managed') {
@@ -14,9 +32,13 @@ export async function runStartupAccount(deps, io) {
                         io.print(formatFailure({ what: 'Your CSPeach sign-in is no longer valid', next: 'cspeach login' }));
                         return { exit: 1 };
                     }
+                    if (!(await settleSeat(meResult, startupKey, authFile)))
+                        return { exit: 1 };
                     io.notice(formatInfo(`Could not refresh your account (${meResult.error})`));
                 }
                 else {
+                    if (!(await settleSeat(meResult, startupKey, authFile)))
+                        return { exit: 1 };
                     io.showProfile(meResult.profile);
                 }
             }
@@ -31,6 +53,11 @@ export async function runStartupAccount(deps, io) {
                     io.print(licence.message);
                     return { exit: 1 };
                 }
+                // The licence check IS the /v1/me call: an ok verdict carries the kind.
+                const fresh = licence.verdict === 'ok' && licence.profile
+                    ? { ok: true, profile: licence.profile, serverDate: null } : null;
+                if (!(await settleSeat(fresh, startupKey, await deps.readAuthFile())))
+                    return { exit: 1 };
                 if (licence.verdict === 'unknown') {
                     io.notice(formatInfo(licence.line));
                 }
@@ -47,5 +74,41 @@ export async function runStartupAccount(deps, io) {
         }
     }
     catch { /* banner is best-effort — never block REPL startup */ }
-    return licenceCheckedAtMs === undefined ? { exit: null } : { exit: null, licenceCheckedAtMs };
+    return {
+        exit: null,
+        ...(licenceCheckedAtMs === undefined ? {} : { licenceCheckedAtMs }),
+        ...(seat === undefined ? {} : { seat }),
+    };
+}
+/**
+ * Team build Task 5, ruling R7a — start-up resolved no seat but a key exists
+ * (managed without auth.json, with a stored key or one pasted just now): one
+ * /v1/me for that key (fetchMe sends the CLI's user-agent itself), then the
+ * stored record, then the legacy rule (R7b). Null = not confirmed (exit 1).
+ * Runs only when start-up made no /v1/me call, so never a second one.
+ */
+export async function settleSeatAfterStartup(deps, a) {
+    let fresh = null;
+    try {
+        fresh = await deps.fetchMe({ proxyUrl: a.proxyUrl, apiKey: a.apiKey });
+    }
+    catch {
+        fresh = null;
+    }
+    let authFile = null;
+    try {
+        authFile = await deps.readAuthFile();
+    }
+    catch {
+        authFile = null;
+    }
+    const r = resolveSeatKind({
+        fresh, stored: await deps.readSeatRecord(), apiKey: a.apiKey, now: new Date((deps.now ?? Date.now)()), legacySignIn: isLegacySignIn(authFile),
+    });
+    if (!r.ok)
+        return null;
+    if (r.write)
+        await deps.writeSeatRecord(r.write).catch(() => { });
+    deps.setSeatKind(r.kind);
+    return r.kind;
 }

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

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ *
+ * Ruling R10: the build folder is the folder CSPeach runs in, never
+ * `activeProject()`. Ruling R12: the status record goes to the spec folder.
+ * Never blocks start-up: a problem is one line.
+ */
+import path from 'node:path';
+const day = (iso) => String(iso ?? '').slice(0, 10);
+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.openQuestions.length) {
+                out.push('  Open questions:');
+                for (const q of s.openQuestions)
+                    out.push(`  - [${q.severity}] ${q.text}`);
+            }
+            else {
+                out.push('  No open questions.');
+            }
+        }
+        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;
+}
+const BUILD = 'Build this spec';
+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 v = await choose({
+        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 }],
+    });
+    if (v === 'build')
+        return { kind: 'build', spec: s };
+    if (v === 'ask')
+        return { kind: 'ask', spec: s };
+    return { kind: 'later' };
+}
+/**
+ * One card per ready spec, developers only. Build or Ask submits one command
+ * and ends the offer (one turn at a time); Later moves to the next spec.
+ * Returns true when a command was submitted.
+ */
+export async function offerBuild(a) {
+    if (a.seat !== 'developer')
+        return false;
+    for (const s of a.specs) {
+        if (s.status !== 'ready for build')
+            continue;
+        const c = await chooseFor(a.choose, s);
+        if (c.kind === 'later')
+            continue;
+        if (c.kind === 'ask') {
+            a.submit(askSentence(s));
+            return true;
+        }
+        const { chainFromToken } = await import('../lane/chain-token.js');
+        const t = await chainFromToken(a.teamDir, s.envelopePath);
+        if (!t) {
+            a.emit(`We could not start the build from specs/${s.slug}/. Run /abap-app --from @specs/${s.slug}/<file> yourself.`);
+            return false;
+        }
+        const { writeStatusRecord } = await import('../projects/spec-share.js');
+        writeStatusRecord(s.specDir, {
+            projectId: a.projectId, slug: s.slug, file: path.basename(s.envelopePath),
+            status: 'being built', by: a.by, at: (a.now ?? (() => new Date()))().toISOString(),
+        });
+        // R14: a Stop at the open-questions gate puts it back to ready for build.
+        const { noteBeingBuiltThisRun } = await import('./open-questions-gate.js');
+        noteBeingBuiltThisRun(s.specDir);
+        a.submit(`/abap-app --from ${t.token}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * The start-up step: the build folder found by cwd (R10), its specs listed,
+ * the offer made. Never throws; at most one line on a problem.
+ */
+export async function runStartScreen(a) {
+    try {
+        const { buildFolderAt } = await import('../commands/team-spec.js');
+        const here = buildFolderAt(a.cwd);
+        if (!here)
+            return { submitted: false };
+        const { listSharedSpecs, specAuthorFor } = await import('../projects/spec-share.js');
+        const specs = listSharedSpecs(here.dir);
+        for (const l of startScreenLines(specs, a.seat))
+            a.emit(l);
+        const submitted = await offerBuild({
+            specs, seat: a.seat, choose: a.choose, teamDir: here.dir, projectId: here.project.projectId,
+            by: specAuthorFor(here.project.projectId, a.identityName),
+            submit: a.submit, emit: a.emit, ...(a.now ? { now: a.now } : {}),
+        });
+        return { submitted };
+    }
+    catch (e) {
+        a.emit(`Could not show the team build specs: ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`);
+        return { submitted: false };
+    }
+}