@cspeach/cli 1.1.52 → 1.1.54

package/dist/commands/login.js

@@ -8,8 +8,9 @@
  *   4) Poll /v1/auth/device/poll every interval until verified or maxAttempts
  *   5) Save api_key to the OS credential store (this CSPeach home's account);
  *      auth.json keeps customer_id + savedAt (the key only without a store)
- *   6) Call GET /v1/me — if trial_mode === 'byok', pull the org's Anthropic key,
- *      or prompt for the user's own
+ *   6) Call GET /v1/me — record the seat kind (seat.json, Team build); if
+ *      trial_mode === 'byok', pull the org's Anthropic key, or prompt for the
+ *      user's own
  *   7) Store that key in the OS keychain (cspeach.anthropic/api-key) — never
  *      in auth.json (2026-10-02)
  *   8) GET /v1/me/connection — Azure tenant mode: the company's Azure
@@ -30,6 +31,8 @@ import { getGlyphs } from '../renderer/glyphs.js';
 import { sanitizeControlChars } from '../renderer/sanitize.js';
 import { runConnectionStep } from '../connection/login-step.js';
 import { clientIdConfigured } from '../connection/azure-facts.js';
+import { CLI_VERSION } from '../lib/version.js';
+import { resolveSeatKind, makeSeatRecord, writeSeatRecord } from '../licence/seat-kind.js';
 const ANTHROPIC_KEYCHAIN_SERVICE = 'cspeach.anthropic';
 const ANTHROPIC_KEYCHAIN_ACCOUNT = 'api-key';
 /** Server-supplied text (user code, URL, email, plan) is one line with no control characters. */
@@ -106,11 +109,24 @@ export async function runLoginCommand(deps) {
     deps.print(done(savedTo === 'store'
         ? 'Saved your CSPeach key to your OS credential store'
         : 'Saved your CSPeach key to auth.json in your CSPeach home (no OS credential store is available)'));
-    // 6) /v1/me — figure out if BYOK is required.
+    // 6) /v1/me — the seat kind, and whether BYOK is required. Team build (R5):
+    // the user-agent names this CLI, so the proxy never takes a current CLI for
+    // one too old for a functional seat.
+    // Team build: the seat kind is recorded once, from this answer only. A
+    // failed call, or a word we do not know, records nothing (never a guess).
+    let seatRecorded = false;
     try {
-        const r = await fetch(`${proxy}/v1/me`, { headers: { Authorization: `Bearer ${polled.api_key}` } });
+        const r = await fetch(`${proxy}/v1/me`, { headers: { 'User-Agent': `cspeach/${CLI_VERSION}`, Authorization: `Bearer ${polled.api_key}` } });
         if (r.ok) {
             const me = await r.json();
+            const seat = resolveSeatKind({ fresh: { ok: true, profile: me, serverDate: null }, stored: null, apiKey: polled.api_key, now: new Date(), legacySignIn: false });
+            if (seat.ok) {
+                try {
+                    await writeSeatRecord(makeSeatRecord(polled.api_key, seat.kind, new Date()));
+                    seatRecorded = true;
+                }
+                catch { /* reported by the one line below */ }
+            }
             deps.print(done(`Signed in as ${serverText(me.email)} · ${serverText(me.plan)}`));
             if (me.trial_mode === 'byok' || me.plan === 'byo-key') {
                 // Try to fetch the org's Anthropic key first — non-fatal if unavailable.
@@ -146,6 +162,8 @@ export async function runLoginCommand(deps) {
     catch (err) {
         deps.print(formatInfo(`Could not read your account details (${err instanceof Error ? err.message : String(err)}) · sign-in still worked`).trimEnd());
     }
+    if (!seatRecorded)
+        deps.print(formatInfo('Could not record your seat kind · run cspeach login again when you are online').trimEnd());
     // 8) Azure tenant mode — the company's connection settings (no secrets).
     // { kind: 'none' } changes nothing; an Azure answer is confirmed on screen.
     const step = await (deps.connectionStep ?? runConnectionStep)({

package/dist/commands/plan-chain.js

@@ -34,7 +34,7 @@ import { collectPlannedObjects, plannedObjectFacts } from '../projects/plan-obje
 import { isDeployPhase } from '../projects/plan-lane.js';
 import { askDeployCard } from './deploy-card.js';
 import { decideNextPhaseGate, getAndResetPlanPhaseSubagentDispatches, getAndResetPlanDeviation, } from './plan-gate.js';
-import { applyAuditResult, applyPhaseResolution, buildResumeCommand, offerNextPhaseAutoRun, } from './plan-resume.js';
+import { applyAuditResult, applyPhaseResolution, buildResumeCommand, offerNextPhaseAutoRun, planBuildTransport, } from './plan-resume.js';
 import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
 import { clean } from '../renderer/tool-labels.js';
 import { runBatchAudit, pendingAuditPhaseIds, selectPlanCardAction, } from './plan-batch-audit.js';
@@ -251,7 +251,7 @@ async function postPhaseChain(args) {
             const built = after.content.phases.every((q) => isPhaseSatisfiedForRun(st[q.id], q.audit));
             const nextAfter = computeNextPhaseForRun(after.content.phases, st);
             if (built && !nextAfter) {
-                args.log('', ...planCompletionLines(after.content.phases));
+                args.log('', ...planCompletionLines(after.content.phases, undefined, planBuildTransport(after.content.phases)));
                 // Step 2 (C5): a rebuild whose plan this is now reads "built, not yet checked".
                 await afterPlanComplete(cur);
                 args.log(`Plan file: ${savedLocation(cur, args.cwd)}`);

package/dist/commands/plan-reground.js

@@ -5,6 +5,7 @@ import { SAP_PAUSE_LINE } from './plan-sap-pause.js';
 import { unreachableCode } from '../sap/unreachable.js';
 import { unreachableCodeInText } from '../sap/reachability-state.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
+import { isFunctionalSeat } from '../licence/seat-state.js';
 const LOCK_WAIT_MS = 10_000;
 const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /** Network code when SAP did not answer at all (an HTTP error means it answered). */
@@ -20,6 +21,10 @@ function errText(err) {
  * network failure) — never blocks the step. Unreachable SAP is rethrown.
  */
 async function probeLock(deps, type, name) {
+    // Team build Task 6 (ruling R8 I1) — a functional seat never takes a SAP
+    // lock, not even a probe: 'unknown' never blocks, and SAP is not touched.
+    if (isFunctionalSeat())
+        return 'unknown';
     let l;
     try {
         l = await deps.lock(type, name);

package/dist/commands/plan-resume.js

@@ -521,7 +521,7 @@ export async function preparePlanResume(args) {
             // C2 (D24): a finished UI-less backend stack chains to /abap-fiori-build
             // with the exact binding name — the marketed idea→app story must not
             // silently end at the service binding.
-            args.log(...planCompletionLines(content.phases));
+            args.log(...planCompletionLines(content.phases, undefined, planBuildTransport(content.phases)));
         }
         else {
             const blocked = content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => titleOfId(p.id));
@@ -1102,7 +1102,7 @@ export async function finishPlanResume(args) {
         args.log(renderPlanProgressLine({ content: { ...extract.content, phases: provisionalPhases }, statuses, currentId: null }));
         if (!next && provisionalPhases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit))) {
             // C2 (D24): same chain as preparePlanResume — single source in plan-run.ts.
-            args.log(...planCompletionLines(provisionalPhases));
+            args.log(...planCompletionLines(provisionalPhases, undefined, planBuildTransport(provisionalPhases)));
             // Step 2 (C5): the live run finished — a rebuild whose plan this is reads built.
             // Not at the re-opened complete plan above (preparePlanResume).
             await afterPlanComplete(args.prepared.path);

package/dist/commands/plan-startup.js

@@ -17,7 +17,7 @@ import { basename, dirname } from 'node:path';
 import { readProjectFile } from '../projects/status.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { computeNextPhaseForRun, isPhaseSatisfiedForRun, phaseDisplayTitle, statusesFromItems, } from '../projects/plan-run.js';
-import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
+import { collectPlannedObjects, plannedObjectFacts, planGrantCoversWrites, planGrantFactLines, planTransportFact, } from '../projects/plan-objects.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from './plan-resume.js';
 import { newestPlanFamilyFiles } from '../session/recap.js';
 import { recordCliCard } from '../session/cli-record.js';
@@ -100,8 +100,8 @@ function objectListFacts(objects, transport, grantable) {
     return [
         `It will create or change these ${objects.length} SAP object${objects.length === 1 ? '' : 's'}:`,
         ...plannedObjectFacts(objects).map((r) => `  ${r}`),
-        `Transport: ${transport ?? 'a new one for this build'}`,
-        ...(grantable ? planGrantFactLines() : ['CSPeach asks before each write.']),
+        planTransportFact(transport, objects),
+        ...(grantable && planGrantCoversWrites(transport, objects) ? planGrantFactLines() : ['CSPeach asks before each write.']),
     ];
 }
 const OBJECT_LIST_FAILED = 'The object list could not be approved. Each SAP write asks first.';

package/dist/commands/sap-link.js

@@ -6,6 +6,7 @@
 // only plain registry messages, never raw exception text.
 import { ensureSapLink, stopSapLink, SapLinkError } from '../sap-link/registry.js';
 import { LinkConfigError } from '../sap-link/project.js';
+import { seatSignInMessage } from '../licence/seat-kind.js';
 function waitForSignal() {
     return new Promise((resolve) => {
         const done = () => {
@@ -29,10 +30,22 @@ export async function runSapLinkCommand(argv, deps) {
         deps.print('Name the SAP system: cspeach sap link <alias>');
         return 1;
     }
+    // Asked once, before the link starts. Not confirmed asks to sign in and stops: a developer is
+    // never wrongly locked read-only. Only a functional seat starts the link read-only.
+    const seat = deps.seat ? await deps.seat().catch(() => 'unconfirmed') : undefined;
+    if (seat === 'unconfirmed') {
+        deps.print(seatSignInMessage());
+        return 1;
+    }
+    const linkDeps = seat === undefined
+        ? deps.linkDeps
+        : { ...deps.linkDeps, readOnlySeat: () => seat === 'functional' };
     try {
-        const r = await ensureSapLink(projectDir, alias, deps.linkDeps);
+        const r = await ensureSapLink(projectDir, alias, linkDeps);
         deps.print(`SAP link on: ${r.handle.url} → ${alias}`);
         deps.print(`Services: ${r.services.join(', ')}`);
+        if (r.seatNote)
+            deps.print(r.seatNote);
         if (r.roleNote)
             deps.print(r.roleNote);
         if (r.tlsNote)

package/dist/commands/team-build-help.js

@@ -0,0 +1,19 @@
+/**
+ * Team build (spec 2026-10-25, plan Task 12) — `cspeach help team-build`.
+ * The how-to for two people sharing one folder: the functional writes the
+ * spec, the developer builds it. Copy is fixed by the plan; change it only
+ * together with docs/guide/team-build.md.
+ */
+export const TEAM_BUILD_HOW_TO = Object.freeze([
+    'Team build — two people, one folder.',
+    '1. Make a folder inside your shared OneDrive, SharePoint or network folder.',
+    '2. Right-click it and choose "Open in Terminal".',
+    '3. Type cspeach. That is the only command. CSPeach sets the folder up the first time.',
+    '4. Talk through the requirement. Say when it is ready for the developer.',
+    '5. Tell the developer the folder name. They do steps 2 and 3 on their laptop.',
+    'Your SAP user decides what you may see in SAP. A functional seat reads SAP and never changes it.',
+]);
+export function printTeamBuildHelp(emit = console.log) {
+    for (const line of TEAM_BUILD_HOW_TO)
+        emit(line);
+}

package/dist/commands/team-build.js

@@ -0,0 +1,97 @@
+/**
+ * Team build (spec 2026-10-25 §7) — the `build` project type: a spec made with
+ * the live system, then built from it. No baseline is pulled and nothing is
+ * measured, so the folder is made without a SAP connection.
+ *
+ * A team build folder is `formatVersion: 2`. Clean-core and upgrade folders
+ * stay `formatVersion: 1`, byte for byte; every branch here keys on
+ * `type === 'build' && formatVersion === 2`. A folder made with the old
+ * `build` type (formatVersion 1, a baseline) is a legacy build folder.
+ *
+ * Also here: the guard a functional seat meets on the terminal verbs that
+ * record work (spec §7.2: a functional seat joins any team project read-only).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { RegisterError, TEAM_FILE, defaultRand, projectIdFor, } from '../register/store.js';
+import { writeWhole } from '../register/write-whole.js';
+export const LEGACY_BUILD_LINE = 'This folder was set up with the old build type. The build type changed: start a fresh folder for the team build.';
+/**
+ * The verbs that measure, decide or report on a baseline: clean-core and
+ * upgrade projects only. Not `discover` (ruling R9): it writes to its own
+ * folder (`--out` or the folder you are in), never to the joined project.
+ */
+export const CLEAN_CORE_ONLY_VERBS = [
+    'lane', 'refresh', 'fixed', 'target', 'rebuild', 'decide', 'rule', 'sheet', 'report', 'export', 'focus', 'priority', 'plan', 'transport',
+];
+/** The terminal verbs that record work into a team project. A functional seat runs none of them. */
+export const FUNCTIONAL_RECORDING_VERBS = [
+    'lane', 'refresh', 'fixed', 'target', 'rebuild', 'decide', 'rule', 'transport', 'plan', 'focus', 'priority',
+];
+export const FUNCTIONAL_VERB_LINE = 'Your seat reads the team project and never records work into it. Ask a developer on the project to run this.';
+export function buildVerbRefusal(verb) {
+    return `This is a team build folder: a spec made with the live system, then built from it. "cspeach team ${verb}" belongs to clean-core and upgrade projects.`;
+}
+export function buildJoinLine(project, writerId) {
+    return `✓ Joined the team build "${project.name}" (lead ${project.lead.name}) as ${writerId}.`;
+}
+export function isBuildProject(p) {
+    return p.type === 'build' && p.formatVersion === 2;
+}
+export function isLegacyBuildFolder(p) {
+    return p.type === 'build' && p.formatVersion !== 2;
+}
+/** The `--type` a verb was given (`--type build` or `--type=build`); undefined when none. */
+function typeOption(rest) {
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a.startsWith('--type='))
+            return a.slice('--type='.length);
+        if (a === '--type')
+            return rest[i + 1];
+    }
+    return undefined;
+}
+const hasOption = (rest, name) => rest.some((a) => a === `--${name}` || a.startsWith(`--${name}=`));
+/**
+ * True when a terminal verb records work: every verb in the list, and `init`
+ * and `start` (they pull, measure and write a clean-core or upgrade project)
+ * unless they set up a team build (`--type build`). The read-only forms are
+ * left out: `lane` alone or `lane list`, `lane propose` without `--apply`,
+ * `plan history`, `priority` alone or `priority show`, and `focus list`.
+ */
+export function isRecordingVerb(sub, rest) {
+    if (sub === 'init' || sub === 'start')
+        return typeOption(rest) !== 'build';
+    if (!sub || !FUNCTIONAL_RECORDING_VERBS.includes(sub))
+        return false;
+    const [verb] = rest;
+    switch (sub) {
+        case 'lane': return !(verb === undefined || verb === 'list' || (verb === 'propose' && !hasOption(rest, 'apply')));
+        case 'plan': return verb !== 'history';
+        case 'priority': return !(verb === undefined || verb === 'show');
+        case 'focus': return !(verb === 'list' && rest.length === 1);
+        default: return true;
+    }
+}
+/**
+ * The team build folder: the project file (written whole, then renamed),
+ * `specs/` for the developer and `writers/` for the records.
+ */
+export function createBuildProject(dir, a) {
+    if (fs.existsSync(path.join(dir, TEAM_FILE)))
+        throw new RegisterError('This folder already holds a team project.');
+    const project = {
+        kind: 'team-project',
+        formatVersion: 2,
+        projectId: projectIdFor(a.name, a.rand ?? defaultRand),
+        name: a.name,
+        type: 'build',
+        lead: a.lead.account ? { name: a.lead.name, account: a.lead.account } : { name: a.lead.name },
+        createdAt: a.now.toISOString(),
+    };
+    writeWhole(path.join(dir, TEAM_FILE), `${JSON.stringify(project, null, 2)}\n`);
+    fs.mkdirSync(path.join(dir, 'specs'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'writers'), { recursive: true });
+    return project;
+}

package/dist/commands/team-plan.js

@@ -19,7 +19,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { buildRegister, DEFAULT_WEIGHTS, objectKey, proposeLanes, utcWords, } from '@cspeach/register-core';
-import { RegisterError, collectRecords, readBaseline, readLanes, readProjectFile, writeLanes, } from '../register/store.js';
+import { RegisterError, collectRecords, coreProject, readBaseline, readLanes, readProjectFile, writeLanes, } from '../register/store.js';
 import { diffPlan, readPlanSheet } from '../register/plan-import.js';
 import { writeLeadRecord } from '../register/records.js';
 import { registerFor } from '../register/picture.js';
@@ -531,7 +531,7 @@ async function planImport(args, deps) {
     // not handed in yet: a newer word of the lead's is still newer.
     const folder = collectRecords(lead.projectDir).records;
     const own = path.resolve(lead.outboxDir) !== path.resolve(lead.projectDir) ? collectRecords(lead.outboxDir).records : [];
-    const input = { project: lead.project, baseline: readBaseline(lead.projectDir), lanes: readLanes(lead.projectDir), progress: false };
+    const input = { project: coreProject(lead.project), baseline: readBaseline(lead.projectDir), lanes: readLanes(lead.projectDir), progress: false };
     const register = buildRegister({ ...input, records: folder });
     const atOrBefore = (r) => {
         const at = r?.at;

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'];
 /**
@@ -128,6 +132,27 @@ function matches(pattern, value) {
 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;
+            }
+        }
+        // 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 +176,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 +196,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 +239,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 +270,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 +340,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 +491,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() : '';
@@ -700,6 +765,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 +2564,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/docx/doc-meta.js

@@ -11,6 +11,7 @@ const KIND_TITLE = {
     'spec-gap': 'Spec gaps', design: 'Design', estimate: 'Estimate', plan: 'Plan',
     'upgrade-scan': 'Upgrade scan', 'upgrade-report': 'Upgrade report',
     answer: 'CSPeach answer', conversation: 'CSPeach conversation',
+    'change-options': 'Change options',
 };
 /** Z/Y objects, SAP-style names: ZCL_X, ZFI_DUP_INVOICE_CHECK, Z_REPORT, /NS/ZCL_X. */
 const OBJECT_RE = /(?<![\w/])((?:\/[A-Z0-9]+\/)?[ZY][A-Z0-9_]{2,39})\b/;

package/dist/docx/markdown-to-docx.js

@@ -67,6 +67,8 @@ function titlePage(meta) {
         facts.push(`Session: ${meta.session}`);
     if (meta.person)
         facts.push(`Signed in as: ${meta.person}`);
+    if (meta.preparedFor)
+        facts.push(`Prepared for: ${meta.preparedFor}`);
     return [
         new Paragraph({ text: meta.title, heading: HeadingLevel.TITLE, spacing: { before: 2400 } }),
         ...facts.map((f) => new Paragraph({ text: f })),

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 {