@cspeach/cli 1.1.53 → 1.1.55

package/dist/commands/team-spec.js

@@ -0,0 +1,107 @@
+/**
+ * Team build (spec 2026-10-25) — `cspeach team spec list|ready [<slug>]`.
+ *
+ *   list            every spec in this team build: status, title, author, date, open questions
+ *   ready [<slug>]  mark a draft "ready for build" for the developer
+ *
+ * The same marking runs from the plain phrase "this is ready for the
+ * developer" in the REPL (repl/ready-phrase.ts).
+ *
+ * Ruling R10: the build project is the folder CSPeach runs in, never
+ * `activeProject()` — a developer on a clean-core wave keeps that one active.
+ * Ruling R12: status belongs to the spec folder (slug), an added-only record
+ * in `specs/<slug>/status/`, not to one envelope version.
+ *
+ * Both seats run it: the functional authors the spec, the developer reads it.
+ * `spec` is neither a recording verb nor a clean-core-only verb.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { TEAM_FILE, readProjectFile } from '../register/store.js';
+import { isBuildProject } from './team-build.js';
+import { listSharedSpecs, specAuthorFor, writeStatusRecord } from '../projects/spec-share.js';
+export const NOT_BUILD_SPEC_LINE = 'This folder is not a team build. "cspeach team spec" works in a team build folder.';
+export const NO_DRAFT_LINE = 'No draft spec here yet. Work the requirement through spec gap first, then say when it is ready.';
+export const markedReadyLine = (title) => `Marked ready for the developer: "${title}". They will see it when they open CSPeach in this folder.`;
+const USAGE = 'Usage: cspeach team spec list|ready [<slug>]';
+/**
+ * The team build in exactly this folder, or null. Cheap outside a team
+ * folder: one file-exists check. An unreadable project file is null too.
+ */
+export function buildFolderAt(cwd) {
+    const dir = path.resolve(cwd);
+    if (!fs.existsSync(path.join(dir, TEAM_FILE)))
+        return null;
+    try {
+        const project = readProjectFile(dir);
+        return isBuildProject(project) ? { dir, project } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const draftSpecs = (teamDir) => listSharedSpecs(teamDir).filter((s) => s.status === 'draft');
+/** Add the "ready for build" record to the spec's folder. */
+export function markSpecReady(spec, projectId, by, now, rand) {
+    return writeStatusRecord(spec.specDir, {
+        projectId, slug: spec.slug, file: path.basename(spec.envelopePath), status: 'ready for build', by, at: now.toISOString(),
+    }, rand);
+}
+export async function specCommand(args, deps, cwd = process.cwd()) {
+    const [verb, ...rest] = args;
+    const here = buildFolderAt(cwd);
+    if (!here) {
+        deps.print(NOT_BUILD_SPEC_LINE);
+        return 1;
+    }
+    switch (verb) {
+        case 'list': {
+            const specs = listSharedSpecs(here.dir);
+            if (!specs.length) {
+                deps.print('No specs here yet.');
+                return 0;
+            }
+            for (const s of specs) {
+                deps.print(`${s.status.padEnd(16)} ${s.title}  (${s.author}, ${s.createdAt.slice(0, 10)}) — ${s.openQuestions.length} open`);
+            }
+            return 0;
+        }
+        case 'ready': {
+            const slug = rest[0];
+            const all = listSharedSpecs(here.dir);
+            let spec;
+            if (slug) {
+                spec = all.find((s) => s.slug === slug);
+                if (!spec) {
+                    deps.print(`No spec "${slug}" here. Specs: ${all.length ? all.map((s) => s.slug).join(', ') : 'none yet'}`);
+                    return 1;
+                }
+                if (spec.status !== 'draft') {
+                    deps.print(`"${spec.title}" is already ${spec.status}.`);
+                    return 0;
+                }
+            }
+            else {
+                const drafts = all.filter((s) => s.status === 'draft');
+                if (!drafts.length) {
+                    deps.print(NO_DRAFT_LINE);
+                    return 1;
+                }
+                if (drafts.length > 1) {
+                    deps.print('Say which: cspeach team spec ready <slug>');
+                    for (const s of drafts)
+                        deps.print(`  ${s.slug}  ${s.title}`);
+                    return 1;
+                }
+                spec = drafts[0];
+            }
+            const by = specAuthorFor(here.project.projectId, deps.identity().name);
+            markSpecReady(spec, here.project.projectId, by, (deps.now ?? (() => new Date()))(), deps.rand);
+            deps.print(markedReadyLine(spec.title));
+            return 0;
+        }
+        default:
+            deps.print(USAGE);
+            return 1;
+    }
+}

package/dist/commands/team.js

@@ -23,7 +23,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { decidedCount, decisionWhatOf, isAppLabel, isPatternWord, laneIdFor, levelOf, normalizeRuleId, objectKey, partCounts, proposeLanes, scopeFromWords, targetsOf, viewWords, } from '@cspeach/register-core';
 import { LOCAL_PACKAGE, listCustomPackages, pullBaseline, BaselineError } from '../register/baseline.js';
-import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, defaultOutboxDir, loadState, projectIdFor, readBaseline, readEstate, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
+import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, coreProject, defaultOutboxDir, loadState, projectIdFor, readBaseline, readEstate, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
 import { MAX_API_DOCUMENTS, MAX_SECOND_PASS, measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
 import { measureFromFile, shown, shownUpTo, upToFive } from '../register/atc-file.js';
 import { writeLeadRecord, writeRecord } from '../register/records.js';
@@ -39,7 +39,11 @@ import { lookupVariant, variantLookupLine } from '../register/variant.js';
 import { TRANSPORT_NONE_WORDS, TRANSPORT_REQUEST, notARequestLine, projectTransportWords, writeProjectTransport } from '../register/project-transport.js';
 import { teamDiscover, evidenceRows, EVIDENCE_LINE, OUTSIDE_LINE } from './team-discover.js';
 import { rulesCommand } from './team-rules.js';
+import { specCommand } from './team-spec.js';
 import { focusCommand, laneChangeRecord, laneProposal, nowLine, planCommand, priorityCommand, reasonFrom } from './team-plan.js';
+import { CLEAN_CORE_ONLY_VERBS, FUNCTIONAL_VERB_LINE, buildJoinLine, buildVerbRefusal, createBuildProject, isBuildProject, isRecordingVerb, } from './team-build.js';
+import { seatSignInMessage } from '../licence/seat-kind.js';
+import { getSeatKind } from '../licence/seat-state.js';
 const CLASSIFICATIONS = ['keep', 'fix', 'retire', 'redesign'];
 const TYPES = ['clean-core', 'upgrade', 'build'];
 /**
@@ -125,9 +129,60 @@ function matches(pattern, value) {
     const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i');
     return re.test(value);
 }
+/** Verbs that choose or leave a project themselves: no folder note. */
+const FOLDER_NOTE_SKIP = new Set(['init', 'start', 'join', 'leave', 'help', '--help', '-h']);
+/**
+ * F11 — one line when `cwd` holds a team project other than the active one.
+ * Null when it matches, when the folder is no team project, or on any read
+ * problem (the verb then runs exactly as before).
+ */
+export function folderMismatchLine(cwd) {
+    try {
+        if (!fs.existsSync(path.join(cwd, TEAM_FILE)))
+            return null;
+        const here = readProjectFile(cwd);
+        const active = activeProject();
+        if (!active || active.projectId === here.projectId)
+            return null;
+        const activeName = readProjectFile(active.projectDir).name;
+        return `This folder is the team project "${here.name}", but CSPeach is recording against "${activeName}". To work on "${here.name}": cspeach team join .`;
+    }
+    catch {
+        return null;
+    }
+}
 export async function runTeamCommand(args, deps) {
     const [sub, ...rest] = args;
     try {
+        // Team build (spec §7.2): a functional seat reads a team project and never
+        // records work into it. Read-only verbs never ask for the seat. On by
+        // default (final review F1): without deps.seat the process seat decides
+        // (seat-state.ts — developer unless start-up resolved functional), so a
+        // caller that builds its own TeamDeps (the clean-core journey) is held too.
+        if (isRecordingVerb(sub, rest)) {
+            const seat = await (deps.seat ?? (async () => getSeatKind()))();
+            if (seat === 'functional') {
+                deps.print(FUNCTIONAL_VERB_LINE);
+                return 1;
+            }
+            if (seat === 'unconfirmed') {
+                deps.print(seatSignInMessage());
+                return 1;
+            }
+        }
+        // F11 (2026-10-29 live run): verbs follow the active project (R10). When
+        // the folder they run in is a different team project, say so first — a
+        // status in the ZTEST_LAS folder silently reported another project.
+        if (sub && !FOLDER_NOTE_SKIP.has(sub)) {
+            const note = folderMismatchLine((deps.cwd ?? (() => process.cwd()))());
+            if (note)
+                deps.print(note);
+        }
+        // A team build folder has no baseline: the clean-core verbs are refused in one line.
+        if (sub && CLEAN_CORE_ONLY_VERBS.includes(sub) && activeIsBuild()) {
+            deps.print(buildVerbRefusal(sub));
+            return 1;
+        }
         switch (sub) {
             case 'init': return await init(rest, deps);
             case 'start': return await start(rest, deps);
@@ -151,8 +206,9 @@ export async function runTeamCommand(args, deps) {
             case 'priority': return priorityCommand(rest, deps);
             case 'plan': return await planCommand(rest, deps);
             case 'rebuild': return await rebuildVerb(rest, deps);
+            case 'spec': return await specCommand(rest, deps);
             default:
-                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|target|transport|fixed|sheet|report|export|discover|focus|priority|plan|start|rebuild|rules   (cspeach --help for details)');
+                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|target|transport|fixed|sheet|report|export|discover|focus|priority|plan|start|rebuild|rules|spec   (cspeach --help for details)');
                 return sub ? 1 : 0;
         }
     }
@@ -170,6 +226,28 @@ export async function runTeamCommand(args, deps) {
         return 1;
     }
 }
+/** The joined project is a team build. Unreadable or none: no guard (the verb says why itself). */
+function activeIsBuild() {
+    try {
+        const joined = activeProject();
+        return !!joined && isBuildProject(readProjectFile(joined.projectDir));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The team build folder (Task 7): no SAP connection, nothing pulled or
+ * measured. The lead joins with the outbox in the folder itself.
+ */
+function initBuild(dir, name, lead, deps, asName) {
+    createBuildProject(dir, { name, lead: { name: lead }, now: (deps.now ?? (() => new Date()))(), ...(deps.rand ? { rand: deps.rand } : {}) });
+    const quiet = { ...deps, print: () => { } };
+    join([dir, '--outbox', dir], quiet, asName);
+    deps.print(`✓ Team build "${name}" set up in this folder. Lead: ${lead}.`);
+    deps.print('  Specs save to specs/ for the developer. Start CSPeach here: cspeach');
+    return 0;
+}
 /** True when this seat is the project's lead. The one test: requireLead and team_lane_move both use it. */
 export function isLead(project, deps) {
     return whoAmI(deps).trim().toLowerCase() === project.lead.name.trim().toLowerCase();
@@ -191,6 +269,8 @@ const INIT_USAGE = 'Usage: cspeach team init <folder> --name "<name>" [--lead "<
     + '[--packages ZFI_*,ZSD_*] [--include-local] [--atc-variant <NAME>] [--no-measure] [--no-from-discovery]';
 /** Everything `init` understands. Anything else is a typo, and a typo is refused, never ignored. */
 const INIT_OPTIONS = ['name', 'lead', 'type', 'packages', 'include-local', 'sap-alias', 'atc-variant', 'no-measure', 'from-discovery', 'no-from-discovery'];
+/** What `init --type build` takes: a team build has no packages, no check and no discovery to read. */
+const INIT_BUILD_OPTIONS = ['name', 'lead', 'type'];
 /** The two that take no value, so neither can eat the folder name. */
 const INIT_FLAGS = ['include-local', 'no-measure', 'from-discovery', 'no-from-discovery'];
 /** Typed on `init` out of muscle memory: they choose what to MEASURE, which is another verb. */
@@ -220,7 +300,9 @@ function unknownInitOption(name) {
 }
 const START_USAGE = 'Usage: cspeach team start <packages> | --for "<area words, e.g. FI and SD>" [--developers "<names>, me"] '
     + '[--name "<name>"] [--atc-variant <NAME>] [--transport <REQUEST>] [--folder <folder>] [--no-measure] [--sap-alias <name>]';
-const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias', 'for', 'developers', 'transport'];
+const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias', 'for', 'developers', 'transport', 'type'];
+/** What `start --type build` takes besides the type: a team build has no packages, no check and no transport yet. */
+const START_BUILD_OPTIONS = ['type', 'name', 'folder'];
 /** The check a project measures with when nobody names one. */
 export const DEFAULT_ATC_VARIANT = 'ABAP_CLOUD_READINESS';
 /** I16: `--for` reads the packages from the folder's discovery; without one there is nothing to read them from. */
@@ -288,6 +370,13 @@ async function start(args, deps) {
         if (!START_OPTIONS.includes(name))
             throw new RegisterError(`--${name} is not an option of team start.\n${START_USAGE}`);
     }
+    // Team build (Task 7): the folder you are in, its name, you as the lead. Nothing to pull.
+    if (opts.type !== undefined) {
+        if (opts.type !== 'build' || positional.length || Object.keys(opts).some((o) => !START_BUILD_OPTIONS.includes(o)))
+            throw new RegisterError(START_USAGE);
+        const dir = path.resolve(opts.folder && opts.folder !== 'true' ? opts.folder : process.cwd());
+        return initBuild(dir, opts.name && opts.name !== 'true' ? opts.name : path.basename(dir), deps.identity().name, deps);
+    }
     const typed = positional.join(',').split(',').map((p) => p.trim().toUpperCase()).filter(Boolean);
     if (typed.some(isPatternWord))
         throw new RegisterError(NOT_A_PATTERN);
@@ -432,6 +521,12 @@ async function init(args, deps) {
     const type = (opts.type ?? 'clean-core');
     if (!TYPES.includes(type))
         throw new RegisterError(`--type must be one of: ${TYPES.join(', ')}`);
+    if (type === 'build') {
+        // A team build pulls, measures and discovers nothing: those options are refused, as on `start --type build`.
+        if (Object.keys(opts).some((o) => !INIT_BUILD_OPTIONS.includes(o)))
+            throw new RegisterError(INIT_USAGE);
+        return initBuild(dir, name, lead, deps, given || undefined);
+    }
     // One variant per team project (D6), named here or never. A name SAP could
     // not accept is refused before a folder exists, not after it is written in.
     const atcVariant = opts['atc-variant'] && opts['atc-variant'] !== 'true' ? opts['atc-variant'].trim().toUpperCase() : '';
@@ -691,6 +786,13 @@ function join(args, deps, asName) {
     const state = loadState();
     if (opts.as !== undefined && asName === undefined)
         asName = joinAsName(opts.as, projectDir, project, state.projects[project.projectId]?.name, deps);
+    // F4/F8 — a team build is named by the signed-in account, once (a name
+    // already kept for this project stays).
+    if (asName === undefined && isBuildProject(project) && state.projects[project.projectId]?.name === undefined) {
+        const account = deps.account?.()?.trim();
+        if (account)
+            asName = account;
+    }
     const outboxDir = path.resolve(opts.outbox ?? state.projects[project.projectId]?.outboxDir ?? defaultOutboxDir(project.projectId));
     // A name given once is kept: joining again must not turn the lead back into
     // whatever the machine calls them.
@@ -700,6 +802,11 @@ function join(args, deps, asName) {
     state.projects[project.projectId] = { projectDir, outboxDir, writerId, ...(saved ? { name: saved } : {}) };
     state.active = project.projectId;
     saveState(state);
+    // A team build has no objects to own: one line.
+    if (isBuildProject(project)) {
+        deps.print(buildJoinLine(project, writerId));
+        return 0;
+    }
     deps.print(`✓ Joined "${project.name}" (${objects} objects, lead ${project.lead.name}) as ${writerId}.`);
     // Outbox is the team project folder itself: records land where everyone reads them.
     if (path.relative(projectDir, outboxDir) === '') {
@@ -2494,7 +2601,7 @@ const heldExportLine = (name) => `  ! "${name}" is open in another program, so i
 /** The CSV export of the team project folder, as the team page reads it, into `dir`. */
 export function writeExports(projectDir, project, dir, deps) {
     const { register } = registerFor(projectDir, outboxFor(projectDir));
-    return writeExportFiles(register, project, dir, (deps.now?.() ?? new Date()).toISOString());
+    return writeExportFiles(register, coreProject(project), dir, (deps.now?.() ?? new Date()).toISOString());
 }
 /**
  * `team export [--out <folder>] [--always]` (spec §3.4, D2): the CSV files for

package/dist/journey/chain.js

@@ -15,6 +15,8 @@
  */
 import { estateSummaryOf, viewWords } from '@cspeach/register-core';
 import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, isLead, ruleObject, runTeamCommand, whoAmI } from '../commands/team.js';
+import { FUNCTIONAL_VERB_LINE } from '../commands/team-build.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
 import { activeProject, readBaseline, readEstate, readProjectFile, VARIANT_NAME } from '../register/store.js';
 import { findingsByObject } from '../register/findings.js';
 import { shown, shownUpTo } from '../register/atc-file.js';
@@ -245,6 +247,12 @@ export async function enterJourney(trigger, h) {
         h.emit(trigger.line);
         return;
     }
+    // Final review F1: the clean-core and upgrade steps record work and run
+    // SAP's checks. A functional seat is told so once, before any card or read.
+    if (isFunctionalSeat()) {
+        h.emit(FUNCTIONAL_VERB_LINE);
+        return;
+    }
     startJourneyFlow(h.session, trigger.kind === 'start' ? trigger.packages : []);
     // B8: a start sentence is a new run: its DONE never reads as "nothing left" against an earlier one.
     if (trigger.kind === 'start')

package/dist/journey/clean-core.js

@@ -26,7 +26,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { projectView, provenForTarget as provenForTargetCore } from '@cspeach/register-core';
-import { DISCOVERY_DIR, TEAM_FILE, activeProject, readBaseline, readEstate, readProjectFile } from '../register/store.js';
+import { DISCOVERY_DIR, TEAM_FILE, activeProject, coreProject, readBaseline, readEstate, readProjectFile } from '../register/store.js';
 import { registerFor } from '../register/picture.js';
 import { reportFileNames } from '../register/workbooks.js';
 import { samePath } from '../commands/team-discover.js';
@@ -250,7 +250,7 @@ export function readJourneyFacts(cwd, me, skip) {
         const joined = activeProject();
         // The project file folderRead already read (joined means its folder is this one).
         facts.register = registerFor(joined.projectDir, joined.outboxDir, project).register;
-        facts.view = projectView(facts.register, project, skip?.decide ? { skipped: skip.decide } : {});
+        facts.view = projectView(facts.register, coreProject(project), skip?.decide ? { skipped: skip.decide } : {});
         facts.reportsAt = reportsAt(cwd, folder.name);
     }
     catch {

package/dist/journey/rebuild.js

@@ -36,6 +36,8 @@ import { shown } from '../register/atc-file.js';
 import { cleanReason, OBJECT_NAME, OBJECT_TYPE, objectShown } from './run.js';
 import { clearJourneyFlow } from './flow.js';
 import { whoAmI } from '../commands/team.js';
+import { FUNCTIONAL_VERB_LINE } from '../commands/team-build.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
 import { setRebuildRunActive } from '../commands/plan-gate.js';
 /* ── words ──────────────────────────────────────────────────────────────── */
 export const KIND_WORDS = {
@@ -139,6 +141,9 @@ async function seatName() {
 }
 /** One evidence record: the `rebuild` row on each OLD object's key (additive; older readers drop it). */
 export function writeRebuildRows(joined, keys, row, by, now = new Date()) {
+    // Final review F1: a functional seat records nothing into the project (every caller catches this).
+    if (isFunctionalSeat())
+        throw new Error(FUNCTIONAL_VERB_LINE);
     const at = now.toISOString();
     return writeRecord(joined, 'evidence', keys.map((key) => ({ key, rebuild: { ...(typeof row === 'function' ? row(key) : row), by, at } })), { name: by }, { now });
 }
@@ -262,6 +267,9 @@ export function handOffRebuild(h, g, kind) {
     }
     const now = (h.now ?? (() => new Date()))();
     try {
+        // Final review F1: no brief into the shared folder either, on a functional seat.
+        if (isFunctionalSeat())
+            throw new Error(FUNCTIONAL_VERB_LINE);
         if (kind !== 'class') {
             writeRebuildBrief(joined.projectDir, g.app, rebuildBrief({
                 kind, ...(h.sid ? { sid: h.sid } : {}), target: first.target ?? null,

package/dist/journey/run.js

@@ -14,6 +14,8 @@
 import path from 'node:path';
 import { estateSummaryOf, PART_ORDER, PART_WORDS, provenForTargetWords, usageLineWithWindow } from '@cspeach/register-core';
 import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, NO_CHECK_ALL_LINE, ownerMatch, runTeamCommand, severalLine, whoAmI, writeExports, writeReports } from '../commands/team.js';
+import { FUNCTIONAL_VERB_LINE } from '../commands/team-build.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
 import { EXPORTS_DIR, exportsOff, exportsOn, exportsPresent, setExportsAlways } from '../register/export-files.js';
 import { shown, shownUpTo } from '../register/atc-file.js';
 import { withoutRuleId } from '../register/records.js';
@@ -162,6 +164,11 @@ const IS_PATTERN = /[*?%]/;
  */
 export async function runJourneyStage(stage, ctx) {
     try {
+        // Final review F1: a functional seat reads a team project and never records
+        // into it — no start, no decision, no fix, no check, no report. Said before
+        // any card and before SAP is reached, headless too.
+        if (FUNCTIONAL_STAGES.has(stage) && isFunctionalSeat())
+            return result(stage, [FUNCTIONAL_VERB_LINE], { kind: 'stop' });
         if (ctx.headless)
             return nextStepOnly(stage, ctx);
         // Said before any card: a step that needs SAP, in a session without one.
@@ -189,6 +196,8 @@ export async function runJourneyStage(stage, ctx) {
 }
 const me = (ctx) => whoAmI(ctx.team.deps);
 const facts = (ctx) => readJourneyFacts(ctx.cwd, me(ctx), ctx.skips);
+/** The stages that record work into the project or run SAP's checks: refused on a functional seat. */
+const FUNCTIONAL_STAGES = new Set(['START', 'DECIDE', 'FIX', 'PROVE', 'REPORT']);
 /** Run a team body with its output kept back; `said` holds only this run's lines. */
 async function quiet(ctx, args) {
     const { said } = ctx.team;

package/dist/lane/ready-spec.js

@@ -0,0 +1,32 @@
+export async function readySpecFor(cwd, request) {
+    try {
+        const { buildFolderAt } = await import('../commands/team-spec.js');
+        const here = buildFolderAt(cwd);
+        if (!here)
+            return undefined;
+        const { listSharedSpecs } = await import('../projects/spec-share.js');
+        const all = listSharedSpecs(here.dir);
+        const said = request.toLowerCase();
+        const isNamed = (s) => said.includes(s.title.toLowerCase()) || said.includes(s.slug.replace(/-/g, ' '));
+        const namedAll = all.filter(isNamed);
+        const ready = all.filter((s) => s.status === 'ready for build');
+        const named = ready.filter(isNamed);
+        // S1 — the request names a spec, and it is not one that is ready.
+        if (named.length === 0 && namedAll.length === 1) {
+            return { notReady: { title: namedAll[0].title, status: namedAll[0].status } };
+        }
+        if (!ready.length)
+            return undefined;
+        const one = named.length === 1 ? named[0] : ready.length === 1 && namedAll.length === 0 ? ready[0] : undefined;
+        if (!one)
+            return { ask: ready.map((s) => `"${s.title}"`) };
+        const { chainFromToken } = await import('./chain-token.js');
+        const t = await chainFromToken(here.dir, one.envelopePath);
+        return t ? { command: `/abap-app --from ${t.token}`, title: one.title } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** One plain line for a named spec that is not ready to build. */
+export const notReadyLine = (n) => `"${n.title}" is ${n.status}, not ready for build. The author marks it ready when it is.`;

package/dist/licence/account-name.js

@@ -0,0 +1,31 @@
+/**
+ * Final review S2 (2026-10-29): the signed-in CSPeach account, remembered on
+ * this laptop after a successful start-up (/v1/me), so a team build names a
+ * person by their account on every path — the typed `cspeach team join` and
+ * records written without a join — and two people on one laptop with one
+ * Windows user stay two people. Only the email; never sent anywhere. Kept in
+ * its own file so auth.json (which drives the key logic) is never touched.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+const file = () => path.join(cspeachRoot(), 'account.json');
+export function rememberAccount(email) {
+    const e = email.trim();
+    if (!e)
+        return;
+    try {
+        fs.mkdirSync(cspeachRoot(), { recursive: true });
+        fs.writeFileSync(file(), JSON.stringify({ email: e }) + '\n', 'utf8');
+    }
+    catch { /* best-effort: the Windows name is used instead */ }
+}
+export function signedInAccount() {
+    try {
+        const j = JSON.parse(fs.readFileSync(file(), 'utf8'));
+        return typeof j.email === 'string' && j.email.trim() ? j.email.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/licence/paths.js

@@ -4,3 +4,8 @@ import { cspeachRoot } from '../config/paths.js';
 export function licenceCachePath() {
     return path.join(cspeachRoot(), 'licence.json');
 }
+/** <CSPeach home>/seat.json — the last verified seat kind (Team build). Holds
+ *  no secret: the MAC is keyed by the API key, which is not in the file. */
+export function seatRecordPath() {
+    return path.join(cspeachRoot(), 'seat.json');
+}

package/dist/licence/seat-kind.js

@@ -0,0 +1,110 @@
+/**
+ * Team build — the seat record and the resolution rule.
+ *
+ * A developer is never wrongly locked read-only, and a functional seat never
+ * turns writable:
+ *   1. a fresh /v1/me answer wins (no field = an older proxy = developer);
+ *   2. else the last verified record in seat.json (HMAC over
+ *      `keyPrefix\nkind\nverifiedAt`, keyed by the full API key);
+ *   3. else a pre-release sign-in (auth.json without `signedInWith`) is a
+ *      developer;
+ *   4. else "not signed in" — never a guess.
+ * A record that is present but fails verification is `invalid`, never a
+ * fall-through to the legacy rule.
+ */
+import crypto from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { formatFailure } from '../renderer/notice-shape.js';
+import { keyPrefixOf } from './licence-check.js';
+import { seatRecordPath } from './paths.js';
+const isSeatKind = (v) => v === 'developer' || v === 'functional';
+export function seatMac(apiKey, keyPrefix, kind, verifiedAt) {
+    return crypto.createHmac('sha256', apiKey).update(`${keyPrefix}\n${kind}\n${verifiedAt}`).digest('hex');
+}
+export function makeSeatRecord(apiKey, kind, now) {
+    const keyPrefix = keyPrefixOf(apiKey);
+    const verifiedAt = now.toISOString();
+    return { keyPrefix, kind, verifiedAt, mac: seatMac(apiKey, keyPrefix, kind, verifiedAt) };
+}
+export function verifySeatRecord(raw, apiKey) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const r = raw;
+    if (typeof r.keyPrefix !== 'string' || typeof r.verifiedAt !== 'string' || typeof r.mac !== 'string')
+        return null;
+    if (!isSeatKind(r.kind))
+        return null;
+    if (r.keyPrefix !== keyPrefixOf(apiKey))
+        return null;
+    const expected = Buffer.from(seatMac(apiKey, r.keyPrefix, r.kind, r.verifiedAt), 'utf-8');
+    const given = Buffer.from(r.mac, 'utf-8');
+    // Lengths first: timingSafeEqual throws on unequal lengths.
+    if (given.length !== expected.length || !crypto.timingSafeEqual(given, expected))
+        return null;
+    return { keyPrefix: r.keyPrefix, kind: r.kind, verifiedAt: r.verifiedAt, mac: r.mac };
+}
+/** Ruling R7b: the legacy rule's input. No auth.json (a pasted or env key, or
+ *  a pre-login keytar seat) or an auth.json without `signedInWith` is a
+ *  pre-release sign-in; only a sign-in made by this CLI or newer is not. */
+export function isLegacySignIn(authFile) {
+    return !authFile || authFile.signedInWith === undefined;
+}
+export function resolveSeatKind(a) {
+    if (a.fresh?.ok) {
+        const word = a.fresh.profile.seat_kind;
+        const kind = word === undefined ? 'developer' : isSeatKind(word) ? word : null;
+        if (kind === null)
+            return { ok: false, reason: 'invalid' };
+        return { ok: true, kind, source: 'fresh', write: makeSeatRecord(a.apiKey, kind, a.now) };
+    }
+    if (a.stored !== undefined && a.stored !== null) {
+        const rec = verifySeatRecord(a.stored, a.apiKey);
+        return rec ? { ok: true, kind: rec.kind, source: 'stored', write: null } : { ok: false, reason: 'invalid' };
+    }
+    if (a.legacySignIn)
+        return { ok: true, kind: 'developer', source: 'legacy', write: null };
+    return { ok: false, reason: 'missing' };
+}
+/** seat.json as stored: null when there is no file; `{ corrupt: true }` when
+ *  it cannot be read or parsed, so it resolves `invalid`, never `missing`. */
+export async function readSeatRecord() {
+    let text;
+    try {
+        text = await fs.readFile(seatRecordPath(), 'utf-8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        return { corrupt: true };
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return parsed === null ? { corrupt: true } : parsed;
+    }
+    catch {
+        return { corrupt: true };
+    }
+}
+export async function writeSeatRecord(r) {
+    const p = seatRecordPath();
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    // Only the known fields; temp file + rename, as writeLicenceCache.
+    const body = { keyPrefix: r.keyPrefix, kind: r.kind, verifiedAt: r.verifiedAt, mac: r.mac };
+    const tmp = `${p}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+    try {
+        await fs.writeFile(tmp, JSON.stringify(body, null, 2), 'utf-8');
+        await fs.rename(tmp, p);
+    }
+    finally {
+        await fs.rm(tmp, { force: true }).catch(() => { });
+    }
+}
+export function seatSignInMessage() {
+    return formatFailure({
+        what: 'We could not confirm your seat',
+        detail: ['Your SAP work, sessions and snapshots are untouched.'],
+        next: 'cspeach login',
+    }).trimEnd();
+}
+export const READ_ONLY_SEAT_LINE = 'Read-only seat: CSPeach reads your SAP system and never changes it. Specs, notes and Word documents still save to your folder.';

package/dist/licence/seat-state.js

@@ -0,0 +1,4 @@
+let current = 'developer';
+export function getSeatKind() { return current; }
+export function setSeatKind(k) { current = k; }
+export function isFunctionalSeat() { return current === 'functional'; }

package/dist/licence/terminal-seat.js

@@ -0,0 +1,43 @@
+import { isLegacySignIn, resolveSeatKind, verifySeatRecord } from './seat-kind.js';
+export async function resolveTerminalSeat(d) {
+    try {
+        const apiKey = (await d.resolveApiKey().catch(() => ({ key: null }))).key ?? '';
+        const stored = await d.readSeatRecord().catch(() => ({ corrupt: true }));
+        const authFile = await d.readAuthFile().catch(() => null);
+        const verified = stored !== null && stored !== undefined && apiKey !== '' && verifySeatRecord(stored, apiKey) !== null;
+        let fresh = null;
+        if (apiKey && !verified) {
+            try {
+                fresh = await d.fetchMe({ proxyUrl: await d.proxyUrl(), apiKey });
+            }
+            catch {
+                fresh = null;
+            }
+            if (fresh && !fresh.ok && fresh.status === 401)
+                return 'unconfirmed';
+        }
+        const r = resolveSeatKind({ fresh, stored, apiKey, now: d.now?.() ?? new Date(), legacySignIn: isLegacySignIn(authFile) });
+        if (!r.ok)
+            return 'unconfirmed';
+        if (r.write)
+            await d.writeSeatRecord(r.write).catch(() => { });
+        return r.kind;
+    }
+    catch {
+        return 'unconfirmed';
+    }
+}
+/** The real wiring for cli.ts: the stored key, seat.json, auth.json, the configured proxy. */
+export async function resolveTerminalSeatNow() {
+    const [{ resolveApiKey }, { readAuthFile }, { fetchMe }, { loadConfig }, seat] = await Promise.all([
+        import('../auth/key-resolver.js'), import('../auth/auth-file.js'), import('../auth/me.js'), import('../config/loader.js'), import('./seat-kind.js'),
+    ]);
+    return resolveTerminalSeat({
+        resolveApiKey: () => resolveApiKey(),
+        readSeatRecord: seat.readSeatRecord,
+        writeSeatRecord: seat.writeSeatRecord,
+        readAuthFile: () => readAuthFile(),
+        fetchMe: (a) => fetchMe(a),
+        proxyUrl: async () => (await loadConfig()).proxy_url,
+    });
+}

package/dist/licence/turn-gate.js

@@ -61,6 +61,10 @@ export class LicenceTurnGate {
                 this.lastCheckAtMs = -Infinity;
             return { allow: false, message: d.message };
         }
+        try {
+            await this.o.onSeat?.(d);
+        }
+        catch { /* a seat refresh failure never blocks a turn */ }
         return d.verdict === 'unknown' ? { allow: true, line: d.line } : { allow: true };
     }
 }