@cspeach/cli 1.1.53 → 1.1.54

package/dist/agent/loop.js

@@ -1,7 +1,9 @@
 import chalk from 'chalk';
-import { basename } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { dispatchTool } from './tool-dispatch.js';
 import { listTools, getTool, isStandalone, toolsForContext, toAnthropicTools } from '../tools/index.js';
+import { toolsForSeat } from '../tools/seat-gate.js';
+import { getSeatKind } from '../licence/seat-state.js';
 import { saveSession } from '../session/store.js';
 import { tagSessionOnSave } from '../session/project-match.js';
 import { recordCompletedToolCall } from '../session/pending.js';
@@ -433,6 +435,19 @@ function localToday() {
  * package) loads only here, inside the catch: a broken docx install costs
  * one line after the save and never the save itself.
  */
+/** A spec gap saved into a team build's shared specs/ folder (merge of main into feat/team-build). */
+async function isSharedSpecSave(cwd, saveSkill, savedPath) {
+    if (saveSkill !== 'abap-spec-gap')
+        return false;
+    try {
+        const { sharedSpecTargetFor, isSharedSpecPath } = await import('../projects/spec-share.js');
+        const shared = sharedSpecTargetFor(cwd, 'spec-gap');
+        return !!shared && isSharedSpecPath(shared.teamDir, savedPath);
+    }
+    catch {
+        return false;
+    }
+}
 async function offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm) {
     try {
         const { offerWordCopyAfterArtifactSave } = await import('../projects/document-save.js');
@@ -590,7 +605,7 @@ export async function maybeOfferSave(p) {
             tokensUsed: p.tokensUsed,
             model: p.model,
             author: getAuthorIdentity(),
-            cwd: process.cwd(),
+            cwd: p.cwd ?? process.cwd(),
             prompt,
             // Piece 2 / Q3 — interactive saves ask a Yes/No card; headless passes
             // no confirm so the blanket-'y' prompt above still answers (B5 contract).
@@ -605,6 +620,7 @@ export async function maybeOfferSave(p) {
             ...(p.latestSkeleton && p.skill === saveSkill ? { latestSkeleton: p.latestSkeleton } : {}),
             onNotSaved: (reason) => { notSaved = reason; },
             ...(p.onProjectId ? { onProjectId: p.onProjectId } : {}),
+            ...(p.sapSystem ? { sapSystem: p.sapSystem } : {}),
             // Never headless: a headless journey queues nothing.
             ...(p.journey && !isHeadless() && p.skill === saveSkill ? { journey: p.journey } : {}),
         });
@@ -612,7 +628,9 @@ export async function maybeOfferSave(p) {
         // is a document (spec gaps, design, estimate, plan, upgrade scan/report)
         // gets the same Word step as a review: `word_copy` decides, headless
         // never asks. The project file itself is untouched. Sub-agent turns: no.
-        if (savedPath && !p.subagent && WORD_AFTER_ARTIFACT_SAVE[saveSkill]) {
+        // A team build shared spec already has its Word copy beside it (save-command.ts).
+        if (savedPath && !p.subagent && WORD_AFTER_ARTIFACT_SAVE[saveSkill]
+            && !(await isSharedSpecSave(p.cwd ?? process.cwd(), saveSkill, savedPath))) {
             await offerWordAfterArtifactSave(p, saveSkill, savedPath, confirm);
         }
         // After a spec-gap file is saved, let a developer answer the open BLOCKER
@@ -624,6 +642,25 @@ export async function maybeOfferSave(p) {
         // its next call (session.blockerAnswersNote, sent by runTurn). Main turns
         // with a session only; declined / not offered / not saved → no note.
         if (savedPath && saveSkill === 'abap-spec-gap') {
+            // Team build (Task 9): a spec in the shared specs/ folder is never
+            // rewritten — each answer is a record of its own, and the spec is read
+            // with the records applied. Found by the folder (R10), never activeProject().
+            const { sharedSpecTargetFor, isSharedSpecPath, composeSpec, readAnswers, writeAnswerRecord, specAuthorFor } = await import('../projects/spec-share.js');
+            const { readProjectFile } = await import('../projects/status.js');
+            const shared = sharedSpecTargetFor(p.cwd ?? process.cwd(), 'spec-gap');
+            const records = shared && isSharedSpecPath(shared.teamDir, savedPath)
+                ? {
+                    // R11: only the answers recorded for this envelope.
+                    readEnvelope: (path) => composeSpec(readProjectFile(path), readAnswers(dirname(path)).filter((a) => a.file === basename(path))),
+                    recordAnswer: (a) => {
+                        const specDir = dirname(savedPath);
+                        writeAnswerRecord(specDir, {
+                            projectId: shared.projectId, slug: basename(specDir), file: basename(savedPath),
+                            gapId: a.gapId, answer: a.answer, by: specAuthorFor(shared.projectId, a.identity.name), at: a.at,
+                        });
+                    },
+                }
+                : {};
             const noteSession = p.session && !p.subagent ? p.session : undefined;
             let outcomes;
             await offerAnswerBlockers({
@@ -633,11 +670,15 @@ export async function maybeOfferSave(p) {
                 confirm: inkAwareConfirm,
                 choose: inkAwareChoose,
                 log: (...lines) => lines.forEach((l) => p.emit(l)),
+                ...records,
                 ...(noteSession ? { onOutcomes: (o) => { outcomes = o; } } : {}),
             });
             if (noteSession && outcomes) {
                 // The path is shown against the read tool's base (ctx.cwd), so the model opens it with file_read.
-                const note = blockerAnswersNote({ path: savedPath, cwd: p.readCwd ?? process.cwd(), outcomes });
+                const note = blockerAnswersNote({
+                    path: savedPath, cwd: p.readCwd ?? process.cwd(), outcomes,
+                    ...('readEnvelope' in records ? { readEnvelope: records.readEnvelope } : {}),
+                });
                 if (note)
                     noteSession.blockerAnswersNote = note;
             }
@@ -1260,7 +1301,9 @@ ${imageExpansion.error}`));
     const hiddenSapTools = connectedTurn
         ? pinHiddenTools(session, params.ctx.sapAlias, listTools(), params.ctx.systemProfile ?? null)
         : [];
-    const contextTools = withoutTools(toolsForContext(listTools(), params.ctx), hiddenSapTools);
+    // Team build Task 6 — a functional seat is not offered the tools it may not
+    // call (dispatch refuses them anyway). Developers: the same array.
+    const contextTools = toolsForSeat(withoutTools(toolsForContext(listTools(), params.ctx), hiddenSapTools), getSeatKind());
     // Task 18 fixes M4 / M5 — no read_agent for an agent_run child, and none
     // when a reader would have no real read tool (standalone, file tools off).
     const readerVisible = params.ctx.subagent || !hasReaderReadTools(new Set(contextTools.map((t) => t.name)))
@@ -2366,6 +2409,8 @@ ${imageExpansion.error}`));
                         model: params.modelOverride ?? resolveModelRole('session_default', cfg) ?? session.model ?? 'unknown',
                         emit,
                         sapSystem: session.sap_system,
+                        // Final review F6: the save and the team build folder follow this turn's folder.
+                        cwd: params.ctx.cwd,
                         ...(params.operator ? { operator: params.operator } : {}),
                         sessionId: session.id,
                         ...(params.ctx.subagent ? { subagent: true } : {}),

package/dist/agent/tool-dispatch.js

@@ -12,6 +12,8 @@ import { riskOf } from './risk-gate.js';
 import { NOT_ON_THIS_RELEASE, gateWithVerify } from '../sap/profile-gate.js';
 import { INTERRUPTED_TOOL_RESULT, STOPPED_BEFORE_START_RESULT } from './repair-partial.js';
 import { WRITE_TOOLS } from '../tools/write-mode.js';
+import { seatRefusal } from '../tools/seat-gate.js';
+import { getSeatKind } from '../licence/seat-state.js';
 const READER_TOOL_SET = new Set(READER_TOOLS);
 /** Chat lane (spec 2026-10-17 D4) — the model-facing reason; names hand_off. */
 export const CHAT_READ_ONLY_REASON = 'This chat reads but never changes SAP. To make this change, call hand_off with the right workflow (for example abap-refactor, abap-generate, abap-transport) and a clear request — the workflow shows its plan and asks before it writes.';
@@ -70,6 +72,15 @@ export async function dispatchTool(name, args, ctx) {
     if (ctx.readerMode && !READER_TOOL_SET.has(name)) {
         return { content: `error: read-only reader — ${name} is not allowed here`, is_error: true };
     }
+    // Team build Task 6 — a functional seat reads SAP and never changes it, in
+    // every lane (skill, chat, and an agent_run child, which shares the process
+    // seat) whatever write_mode, role or /mode says. The refused tools are not
+    // offered (agent/loop.ts toolsForSeat); THIS is the guarantee for a call the
+    // model makes anyway. Before the chat gate and every card below. Developers:
+    // seatRefusal is null, so today's dispatch is untouched.
+    const seat = seatRefusal(getSeatKind(), tool, args);
+    if (seat)
+        return { content: JSON.stringify({ error: 'seat_read_only', tool: name, message: seat }), is_error: true };
     // Chat lane (spec 2026-10-17 D4, §6.3) — chat reads freely and never changes
     // SAP. The prompt says so; THIS is the guarantee: every SAP-mutating tool and
     // request_approval are refused while the session's last turn ran in chat,

package/dist/auth/auth-file.js

@@ -40,6 +40,8 @@ export async function readAuthFile() {
             out.apiKey = parsed.apiKey;
         if (typeof parsed.savedAt === 'string')
             out.savedAt = parsed.savedAt;
+        if (typeof parsed.signedInWith === 'string')
+            out.signedInWith = parsed.signedInWith;
         return out;
     }
     catch {
@@ -54,6 +56,7 @@ export async function writeAuthFile(auth) {
         ...(auth.apiKey !== undefined ? { apiKey: auth.apiKey } : {}),
         customerId: auth.customerId,
         ...(auth.savedAt !== undefined ? { savedAt: auth.savedAt } : {}),
+        ...(auth.signedInWith !== undefined ? { signedInWith: auth.signedInWith } : {}),
     };
     await writeAtomic0600(p, JSON.stringify(body, null, 2));
 }

package/dist/auth/key-resolver.js

@@ -27,6 +27,7 @@ import { promises as fs } from 'node:fs';
 import { cspeachRoot, defaultCspeachRoot } from '../config/paths.js';
 import { readAuthFile, writeAuthFile, deleteAuthFile, authFileMtimeMs, authFileDir } from './auth-file.js';
 import { licenceCachePath } from '../licence/paths.js';
+import { CLI_VERSION } from '../lib/version.js';
 export const KEYCHAIN_SERVICE = 'cspeach';
 export const DEFAULT_ACCOUNT = 'api-key';
 async function defaultIo() {
@@ -181,7 +182,8 @@ export async function migrateSignIn(deps = {}) {
         return auth?.apiKey ? 'store-unavailable' : 'none';
     }
     try {
-        await writeAuthFile({ customerId: auth.customerId, ...(auth.savedAt ? { savedAt: auth.savedAt } : {}) });
+        // Team build: signedInWith stays, so a new sign-in never turns "legacy".
+        await writeAuthFile({ customerId: auth.customerId, ...(auth.savedAt ? { savedAt: auth.savedAt } : {}), ...(auth.signedInWith !== undefined ? { signedInWith: auth.signedInWith } : {}) });
     }
     catch {
         return 'failed'; // the store holds the key; the next start removes the copy ('removed')
@@ -217,12 +219,15 @@ export async function saveSignIn(a, deps = {}) {
     catch {
         stored = false;
     }
+    // Team build: signedInWith marks a sign-in made by this CLI or newer; an
+    // auth.json without it is a pre-release sign-in (a developer seat).
+    const signedInWith = CLI_VERSION;
     if (!stored) {
-        await writeAuthFile({ apiKey: a.apiKey, customerId: a.customerId, savedAt });
+        await writeAuthFile({ apiKey: a.apiKey, customerId: a.customerId, savedAt, signedInWith });
         return 'file';
     }
     await recordStoreWrite(account, savedAt).catch(() => { }); // bookkeeping only, no secret
-    await writeAuthFile({ customerId: a.customerId, savedAt });
+    await writeAuthFile({ customerId: a.customerId, savedAt, signedInWith });
     return 'store';
 }
 /**

package/dist/auth/me.js

@@ -2,6 +2,7 @@
  * Fetch /v1/me — customer profile + entitlements + usage.
  * Result envelope so the REPL doesn't need try/catch.
  */
+import { CLI_VERSION } from '../lib/version.js';
 /** Default /v1/me budget. The panels brand line waits for this call (D5), so a
  *  hung proxy must not mean a blank screen. */
 export const FETCH_ME_TIMEOUT_MS = 5000;
@@ -18,8 +19,11 @@ export async function fetchMe(opts) {
     try {
         return await Promise.race([
             (async () => {
-                // No extra headers → exactly `{ Authorization }`, as before the batch.
-                const r = await fetch(url, { headers: { ...(opts.headers ?? {}), Authorization: `Bearer ${opts.apiKey}` }, signal });
+                // No extra headers → exactly `{ User-Agent, Authorization }`. Team build
+                // (R5): every /v1/me call names this CLI, so the proxy can tell a
+                // current CLI from one too old for a functional seat. Set after the
+                // caller's headers, so no caller can drop it.
+                const r = await fetch(url, { headers: { ...(opts.headers ?? {}), 'User-Agent': `cspeach/${CLI_VERSION}`, Authorization: `Bearer ${opts.apiKey}` }, signal });
                 const serverDate = r.headers.get('date');
                 if (!r.ok) {
                     const body = await r.json().catch(() => ({}));

package/dist/cli.js

@@ -52,6 +52,13 @@ export async function main(argv) {
         printHelp();
         return 0;
     }
+    // Team build (Task 12): `cspeach help team-build` prints the how-to. Above the
+    // one-shot fallback, so the words are never sent to the model as a prompt.
+    if (args[0] === 'help' && args[1] === 'team-build' && args.length === 2) {
+        const { printTeamBuildHelp } = await import('./commands/team-build-help.js');
+        printTeamBuildHelp();
+        return 0;
+    }
     if (args[0] === '--version') {
         console.log(CLI_VERSION);
         return 0;
@@ -248,6 +255,14 @@ export async function main(argv) {
                 const { input } = await import('@inquirer/prompts');
                 return input({ message: question });
             },
+            // Team build (ruling R2, final review F2): the terminal verbs run no
+            // start-up, so the seat is resolved here — the verified record, else one
+            // /v1/me when there is none, else the offline rule. Asked only before a
+            // verb that records work.
+            seat: async () => {
+                const { resolveTerminalSeatNow } = await import('./licence/terminal-seat.js');
+                return resolveTerminalSeatNow();
+            },
         });
     }
     // CAP phase 2 — run the SAP link in the foreground for a local CAP app.
@@ -256,6 +271,11 @@ export async function main(argv) {
         return runSapLinkCommand(args.slice(2), {
             print: (s) => console.log(s),
             defaultAlias: sapAlias,
+            // Final review F3: resolved as the team verbs do; a functional seat's link reads and never writes.
+            seat: async () => {
+                const { resolveTerminalSeatNow } = await import('./licence/terminal-seat.js');
+                return resolveTerminalSeatNow();
+            },
             standalone: async () => {
                 const { loadConfig, resolveStandalone } = await import('./config/loader.js');
                 return resolveStandalone(await loadConfig(), noSap);
@@ -334,10 +354,12 @@ Usage:
   cspeach login azure               Sign in to Microsoft for your company's Azure (--device-code: use a code instead of the browser)
   cspeach logout                    Sign out (removes the CSPeach key from this home)
   cspeach whoami                    Print current account info
+  cspeach help team-build            How two people share one folder: the functional writes the spec, the developer builds it
   cspeach team discover            Read the whole estate from SAP into this folder (read only)
   cspeach team start <packages>     Start a team project in this folder: object list, first check, you own it all
   cspeach team start --for "FI and SD" --developers "James Miller, me"   Lead: set up by name from this folder's discovery; one lane each
   cspeach team init <folder>        Lead: pull the object list from SAP, start a team project
+  cspeach team spec list|ready [<slug>]   Team build: the specs in this folder; mark one ready for the developer
   cspeach team join <folder> [--as "<name>"]   Record your results against a team project (on this laptop only), under the lane owner's name
   cspeach team lane add|list        Lead: who owns which packages
   cspeach team lane move --packages <names> --to <developer>   Lead: move packages by name (lanes of names only)

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