@cspeach/cli 1.1.53 → 1.1.54

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

@@ -0,0 +1,159 @@
+/**
+ * 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+@/;
+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) {
+    if (!PREFIX.test(a.command))
+        return null;
+    const { parseFromFlag } = await import('../skills/promotion-dispatch.js');
+    const { fromPath } = parseFromFlag(a.command);
+    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.
+    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')}` });
+    for (;;) {
+        const qs = openQuestions(env);
+        if (!qs.length)
+            return goOn({ command: a.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: a.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,116 @@
+/**
+ * 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}`);
+        }
+    }
+    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 };
+    }
+}

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

@@ -0,0 +1,178 @@
+/**
+ * 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 }),
+        ...(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 };
+    }
+}