@cspeach/cli 1.1.52 → 1.1.54

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 };
+    }
+}