@cspeach/cli 1.1.53 → 1.1.55

package/dist/one-shot.js

@@ -28,6 +28,10 @@ import { resolveRenderingMode } from './renderer/rendering-mode.js';
 import { setLook, setBackground } from './renderer/look.js';
 import { setAssistantStyle } from './agent/style-state.js';
 import { setAssistantLevel } from './agent/level-state.js';
+import { readAuthFile } from './auth/auth-file.js';
+import { fetchMe } from './auth/me.js';
+import { resolveSeatKind, readSeatRecord, writeSeatRecord, seatSignInMessage, isLegacySignIn } from './licence/seat-kind.js';
+import { setSeatKind } from './licence/seat-state.js';
 import { alwaysDeclinePreviewHook } from './repl/update-method-preview-hook.js';
 import { createClassicOutputEmitter } from './renderer/notices.js';
 import { AnswerTrim } from './renderer/answer-trim.js';
@@ -170,6 +174,31 @@ export async function runOneShot(prompt, opts) {
         console.error('No API key configured. Run `cspeach` (interactive) first to set one.');
         return 1;
     }
+    // Team build Task 5 — the seat kind, set before the turn. A fresh answer
+    // wins (managed: one /v1/me for the seat, ruling R7a; other modes: the
+    // licence check below), else the verified seat.json, else a pre-release
+    // sign-in — no auth.json, or one without signedInWith (R7b) — is a
+    // developer, else the sign-in message and exit 1 — never a guess.
+    const settleSeat = async (fresh) => {
+        const r = resolveSeatKind({
+            fresh, stored: await readSeatRecord(), apiKey: (await store.get()) ?? '', now: new Date(),
+            legacySignIn: isLegacySignIn(await readAuthFile()),
+        });
+        if (!r.ok) {
+            console.error(seatSignInMessage());
+            return false;
+        }
+        if (r.write)
+            await writeSeatRecord(r.write).catch(() => { });
+        setSeatKind(r.kind);
+        // The developer default follows a functional seat; an explicit level stays.
+        const level = cfg.assistant?.level ?? 'developer';
+        setAssistantLevel(r.kind === 'functional' && level === 'developer' ? 'functional' : level);
+        return true;
+    };
+    if (cfg.llm.mode === 'managed'
+        && !(await settleSeat(await fetchMe({ proxyUrl: cfg.proxy_url, apiKey: (await store.get()) ?? '' }))))
+        return 1;
     // Security batch item 1 — licence check at one-shot start, byok / ai-hub /
     // local only. Managed makes no new call: the proxy checks every request.
     if (cfg.llm.mode !== 'managed') {
@@ -178,6 +207,9 @@ export async function runOneShot(prompt, opts) {
             console.error(licence.message);
             return 1;
         }
+        // The licence check IS the /v1/me call: an ok verdict carries the kind.
+        if (!(await settleSeat(licence.verdict === 'ok' && licence.profile ? { ok: true, profile: licence.profile, serverDate: null } : null)))
+            return 1;
         if (licence.verdict === 'unknown')
             console.error(formatInfo(licence.line).trimEnd());
         // Azure tenant mode — one-shot never asks: a changed endpoint, removed

package/dist/projects/answer-blockers.js

@@ -127,7 +127,7 @@ function readsLikeQuestion(typed) {
 export async function offerAnswerBlockers(args) {
     let env;
     try {
-        env = readProjectFile(args.path);
+        env = (args.readEnvelope ?? readProjectFile)(args.path);
     }
     catch {
         return null;
@@ -226,19 +226,43 @@ export async function offerAnswerBlockers(args) {
         // Typed replies were given but not saved: say "saved", not "entered".
         const verb = [...outcomes.values()].includes('declined-question') ? 'saved' : 'entered';
         args.log('');
+        // Record mode (team build): the spec is answered in CSPeach, not at cspeach.dev/edit.
+        const later = args.recordAnswer ? ''
+            : blockers.length === 1 ? ' Answer it later at cspeach.dev/edit.' : ' Answer them later at cspeach.dev/edit.';
         args.log(blockers.length === 1
-            ? `No answer ${verb}. The blocker stays open. Answer it later at cspeach.dev/edit.`
-            : `No answers ${verb}. The ${blockers.length} blockers stay open. Answer them later at cspeach.dev/edit.`);
+            ? `No answer ${verb}. The blocker stays open.${later}`
+            : `No answers ${verb}. The ${blockers.length} blockers stay open.${later}`);
         args.onOutcomes?.(outcomes);
         return null;
     }
     const nowIso = (args.now ?? (() => new Date().toISOString()))();
-    const saved = saveBlockerAnswers(args.path, env, answers, args.identity, nowIso);
-    if (!saved.ok) {
-        args.log(`[answer] revision invalid (${saved.error}) — answers NOT saved.`);
-        return null;
+    if (args.recordAnswer) {
+        // Team build (Task 9): check the revision, but never write the author's file.
+        const check = validateEnvelope(JSON.parse(JSON.stringify(applyBlockerAnswers(env, answers, args.identity, nowIso))));
+        if (!check.ok) {
+            args.log(`[answer] revision invalid (${check.error.message}) — answers NOT saved.`);
+            return null;
+        }
+    }
+    else {
+        const saved = saveBlockerAnswers(args.path, env, answers, args.identity, nowIso);
+        if (!saved.ok) {
+            args.log(`[answer] revision invalid (${saved.error}) — answers NOT saved.`);
+            return null;
+        }
     }
     const stillOpen = blockers.length - answers.size;
+    if (args.recordAnswer) {
+        for (const [gapId, answer] of answers)
+            args.recordAnswer({ gapId, answer, identity: args.identity, at: nowIso });
+        args.log('');
+        args.log(`Recorded ${plural(answers.size, 'answer')} for the developer.`
+            + (stillOpen === 0 ? ''
+                : stillOpen === 1 ? ' 1 blocker is still open.'
+                    : ` ${stillOpen} blockers are still open.`));
+        args.onOutcomes?.(outcomes);
+        return answers.size;
+    }
     args.log('');
     args.log(`Recorded ${plural(answers.size, 'answer')} in the file.`
         + (stillOpen === 0 ? ''

package/dist/projects/blocker-answers-note.js

@@ -47,7 +47,7 @@ export function blockerAnswersNote(a) {
         return null;
     let env;
     try {
-        env = readProjectFile(a.path);
+        env = (a.readEnvelope ?? readProjectFile)(a.path);
     }
     catch {
         return null;

package/dist/projects/save-command.js

@@ -24,6 +24,12 @@ import { checkLaneConsistency, checkRequiredDeploy, LANE_CHANGED_AT_CREATE, read
 import { specGapRefForSave } from './plan-sources.js';
 import { checkSkeletonDecision, hasSkeletonPhase } from './plan-skeleton.js';
 import { laneRootFor } from '../lane/roots.js';
+import { sharedSpecTargetFor, specAuthorFor, writeSharedSpec } from './spec-share.js';
+/** YYYY-MM-DD in local time (the Word copy's date). */
+function localDate(d) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
 const SKILL_REGISTRY = {
     'abap-spec-gap': {
         artefactType: 'spec-gap',
@@ -489,9 +495,9 @@ export async function runSaveCommand(args) {
             try {
                 // Project view Task 5: the view is built once here and answers each card's target.
                 const { registerFor } = await import('../register/picture.js');
-                const { readProjectFile } = await import('../register/store.js');
+                const { coreProject, readProjectFile } = await import('../register/store.js');
                 const { projectView } = await import('@cspeach/register-core');
-                const view = projectView(registerFor(project.projectDir, project.outboxDir).register, readProjectFile(project.projectDir));
+                const view = projectView(registerFor(project.projectDir, project.outboxDir).register, coreProject(readProjectFile(project.projectDir)));
                 targets = (key) => view.object(key.trim().toUpperCase())?.target;
             }
             catch {
@@ -552,6 +558,35 @@ export async function runSaveCommand(args) {
             promotedFrom: args.promotedFrom ?? null,
         });
     }
+    // Team build (Task 9) — a spec-gap saved in a team build folder goes to the
+    // shared specs/<slug>/ folder, for the developer. Found by the folder
+    // CSPeach runs in, never by activeProject() (R10). There is no baseline and
+    // nothing to record into a register: the record block below is skipped, so
+    // a clean-core project that is active elsewhere is never touched.
+    // Final review F6: the caller's folder (args.cwd), never process.cwd().
+    const shared = sharedSpecTargetFor(args.cwd, spec.artefactType);
+    if (shared) {
+        try {
+            args.onProjectId?.(shared.projectId);
+        }
+        catch { /* tagging is best-effort */ }
+        const now = new Date();
+        const r = await writeSharedSpec({
+            teamDir: shared.teamDir,
+            projectId: shared.projectId,
+            env,
+            markdown: args.skillOutput,
+            by: specAuthorFor(shared.projectId, args.author.name),
+            ...(args.sapSystem ? { sapSystem: args.sapSystem } : {}),
+            today: localDate(now),
+            now,
+        });
+        const slug = basename(r.specDir);
+        args.log(`Saved: specs/${slug}/${basename(r.jsonPath)} (in the shared team folder, for the developer)`);
+        if (r.docxPath)
+            args.log(`Word copy: specs/${slug}/${basename(r.docxPath)}`);
+        return r.jsonPath;
+    }
     // Saves land in the workspace folder, not cwd — created only NOW, after
     // the user confirmed (declined saves and conversational turns leave no
     // mkdir/.gitignore side effects). Falls back to args.cwd if the workspace

package/dist/projects/saved-lines.js

@@ -5,14 +5,15 @@
  * below the line" block (subject, body, review steps, sign-off). It looked
  * cluttered and signed itself with the OS account name ("Admin"). Now:
  *
- *   Saved: <file name> (in this project's .cspeach folder)
+ *   Saved: <full path> (in this project's .cspeach folder)
  *   To review or share: open cspeach.dev/edit and drop the file in.
  *
  * Never prints a user name.
  */
-import { basename, dirname, resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { resolveProjectFolderSync } from './project-folder.js';
-function editorLabel() {
+import { isSharedSpecPath } from './spec-share.js';
+export function editorLabel() {
     const url = process.env.CSPEACH_EDITOR_URL?.trim();
     return url ? url : 'cspeach.dev/edit';
 }
@@ -24,23 +25,24 @@ function sameDir(a, b) {
     return norm(a) === norm(b);
 }
 /**
- * `<file name> (in <where>)` — names the folder kind (2026-10-08): this
- * project's .cspeach folder (solo), your own working folder (team), or the
- * home fallback folder with a hint. Anywhere else: the folder itself.
+ * `<full path> (in <where>)` — names the folder kind (2026-10-08): this
+ * project's .cspeach folder (solo), the shared team folder (a team spec),
+ * your own working folder (team), or the home fallback folder with a hint. Anywhere else: the full path alone.
+ * 2026-10-27 — the full path, not the bare file name: a standalone customer
+ * could not find the file (it sits in .cspeach, the Word copy in cspeach-out).
  */
 export function savedLocation(savedPath, cwd) {
-    const dir = dirname(savedPath);
+    const full = resolve(savedPath);
     const pf = resolveProjectFolderSync(cwd);
-    let where = dir;
-    if (sameDir(dir, pf.workDir)) {
-        if (pf.kind === 'solo')
-            where = "this project's .cspeach folder";
-        else if (pf.kind === 'team')
-            where = 'your own working folder for this team project, not shared';
-        else
-            where = `${dir} — start CSPeach in a project folder to keep projects apart`;
-    }
-    return `${basename(savedPath)} (in ${where})`;
+    if (pf.kind === 'team' && isSharedSpecPath(pf.projectDir, savedPath))
+        return `${full} (in the shared team folder, for the developer)`;
+    if (!sameDir(dirname(full), pf.workDir))
+        return full;
+    if (pf.kind === 'solo')
+        return `${full} (in this project's .cspeach folder)`;
+    if (pf.kind === 'team')
+        return `${full} (in your own working folder for this team project, not shared)`;
+    return `${full} (start CSPeach in a project folder to keep projects apart)`;
 }
 export function formatSavedLines(savedPath, cwd) {
     return [

package/dist/projects/spec-share.js

@@ -0,0 +1,270 @@
+/**
+ * Team build (spec 2026-10-25) — the spec lands in the shared team folder.
+ *
+ * A spec-gap saved in a team build folder goes to `<team>/specs/<slug>/`, for
+ * the developer, instead of the seat's private `.cspeach` folder:
+ *
+ *   specs/<slug>/<envelope>.cspeach.json   the author's file, never rewritten
+ *   specs/<slug>/<slug>.md (+ .docx)       the spec as people read it
+ *   specs/<slug>/status/<stamp>-<status>-<rand>.json   added-only status records
+ *   specs/<slug>/answers/<stamp>-<gap>-<rand>.json     added-only answer records
+ *   specs/<slug>/files/                    room for the files that go with it
+ *
+ * One writer per file, records only added: a second save of the same title
+ * lands beside the first (`-2`), an answer is a record of its own, and the
+ * spec people read is composed at read time (composeSpec). The model's file
+ * tools never write `specs/` (tools/_team-work-path.ts TEAM_OWNED_DIRS).
+ *
+ * Ruling R10: the build project is found by the folder CSPeach runs in, never
+ * by `activeProject()` (a developer on a clean-core wave keeps that active).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readProjectFile as readEnvelopeFile } from './status.js';
+import { saveProject } from './save.js';
+import { applyBlockerAnswers } from './answer-blockers.js';
+import { resolveProjectFolderSync, key } from './project-folder.js';
+import { isBuildProject } from '../commands/team-build.js';
+import { readProjectFile, loadState, writerIdFor, defaultRand, stripBom } from '../register/store.js';
+import { writeWhole } from '../register/write-whole.js';
+import { fileStamp } from '../register/records.js';
+import { writeNoClobber, writeDocxNextTo } from '../docx/write-docx.js';
+import { metaFromMarkdown } from '../docx/doc-meta.js';
+import { signedInAccount } from '../licence/account-name.js';
+export const SPECS_DIR = 'specs';
+/** Per question: the latest answer, when it replaced one given by someone else. */
+export function changedAnswersOf(env, answers) {
+    if (env.artefactType !== 'spec-gap')
+        return [];
+    const question = new Map();
+    for (const s of env.content.sections)
+        for (const g of s.gaps)
+            question.set(g.id, g.text);
+    const byGap = new Map();
+    for (const a of [...answers].sort((x, y) => (x.at < y.at ? -1 : x.at > y.at ? 1 : 0))) {
+        byGap.set(a.gapId, [...(byGap.get(a.gapId) ?? []), a]);
+    }
+    const out = [];
+    for (const [gapId, list] of byGap) {
+        if (list.length < 2)
+            continue;
+        const last = list[list.length - 1];
+        const prev = list[list.length - 2];
+        const samePerson = last.by.writer === prev.by.writer && last.by.name === prev.by.name;
+        if (samePerson || last.answer.trim() === prev.answer.trim())
+            continue;
+        out.push({ gapId, question: question.get(gapId) ?? gapId, answer: last.answer, by: last.by.name, at: last.at, was: prev.answer, wasBy: prev.by.name });
+    }
+    return out;
+}
+const STATUSES = ['draft', 'ready for build', 'being built'];
+/** Same instant: the later step in the life of a spec wins. */
+const STATUS_RANK = { draft: 0, 'ready for build': 1, 'being built': 2 };
+/** A folder name for a spec title: lower-case, `[^a-z0-9]+` → `-`, ≤ 60 chars, `spec` when empty. */
+export function specSlug(title) {
+    const s = String(title ?? '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60)
+        .replace(/-+$/, '');
+    return s || 'spec';
+}
+/**
+ * The team build folder a spec-gap save goes to, by the folder CSPeach runs
+ * in (R10). Null for any other artefact, folder kind or team project type.
+ */
+export function sharedSpecTargetFor(cwd, artefactType) {
+    if (artefactType !== 'spec-gap')
+        return null;
+    try {
+        const pf = resolveProjectFolderSync(cwd);
+        if (pf.kind !== 'team')
+            return null;
+        const project = readProjectFile(pf.projectDir);
+        if (!isBuildProject(project))
+            return null;
+        return { teamDir: pf.projectDir, projectId: project.projectId };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Who writes a spec record: the name this laptop records under for the build
+ * project (`team join --as`, kept in the register state by project id — not
+ * the active project, R10), else the author name; the writer id is
+ * `writerIdFor(name)`, as `cspeach team join` derives it.
+ */
+export function specAuthorFor(projectId, fallbackName) {
+    let saved;
+    try {
+        saved = loadState().projects[projectId]?.name;
+    }
+    catch {
+        saved = undefined;
+    }
+    // S2 — no name kept for this project: the signed-in account, else the fallback.
+    const name = saved ?? signedInAccount() ?? fallbackName;
+    return { name, writer: writerIdFor(name) };
+}
+const statusSlug = (s) => s.replace(/\s+/g, '-');
+const safePart = (s) => s.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'x';
+export function writeStatusRecord(specDir, rec, rand = defaultRand) {
+    const full = { kind: 'spec-status', formatVersion: 1, ...rec };
+    const file = path.join(specDir, 'status', `${fileStamp(new Date(rec.at))}-${statusSlug(rec.status)}-${rand(2)}.json`);
+    writeWhole(file, `${JSON.stringify(full, null, 2)}\n`);
+    return file;
+}
+export function writeAnswerRecord(specDir, rec, rand = defaultRand) {
+    const full = { kind: 'spec-answer', formatVersion: 1, ...rec };
+    const file = path.join(specDir, 'answers', `${fileStamp(new Date(rec.at))}-${safePart(rec.gapId)}-${rand(2)}.json`);
+    writeWhole(file, `${JSON.stringify(full, null, 2)}\n`);
+    return file;
+}
+/** Every `*.json` in `dir`, parsed; unreadable files are skipped. */
+function readJsonDir(dir) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names.sort()) {
+        if (!n.endsWith('.json'))
+            continue;
+        try {
+            out.push(JSON.parse(stripBom(fs.readFileSync(path.join(dir, n), 'utf8'))));
+        }
+        catch { /* skipped */ }
+    }
+    return out;
+}
+const isBy = (b) => !!b && typeof b.name === 'string' && typeof b.writer === 'string';
+export function readSpecStatus(specDir) {
+    const history = readJsonDir(path.join(specDir, 'status')).filter((r) => r?.kind === 'spec-status' && STATUSES.includes(r.status) && typeof r.at === 'string' && isBy(r.by));
+    history.sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : STATUS_RANK[a.status] - STATUS_RANK[b.status]));
+    const record = history.length ? history[history.length - 1] : null;
+    return { current: record?.status ?? 'draft', record, history };
+}
+export function readAnswers(specDir) {
+    return readJsonDir(path.join(specDir, 'answers')).filter((r) => r?.kind === 'spec-answer' && typeof r.gapId === 'string' && typeof r.answer === 'string' && typeof r.at === 'string' && isBy(r.by));
+}
+/** The spec as people read it: the author's envelope with every answer record applied, in time order. */
+export function composeSpec(env, answers) {
+    const ordered = [...answers].sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : 0));
+    let out = env;
+    for (const a of ordered) {
+        out = applyBlockerAnswers(out, new Map([[a.gapId, a.answer]]), { name: a.by.name, role: 'consultant' }, a.at);
+    }
+    return out;
+}
+export async function writeSharedSpec(a) {
+    const slug = specSlug(a.env.title);
+    const specDir = path.join(a.teamDir, SPECS_DIR, slug);
+    fs.mkdirSync(path.join(specDir, 'files'), { recursive: true });
+    fs.mkdirSync(path.join(specDir, 'answers'), { recursive: true });
+    // saveProject never overwrites: a taken name gets -2, -3 … beside it.
+    const jsonPath = await saveProject(a.env, { cwd: specDir });
+    const mdPath = await writeNoClobber(path.join(specDir, `${slug}.md`), a.markdown);
+    let docxPath = null;
+    try {
+        docxPath = await writeDocxNextTo(mdPath, a.markdown, metaFromMarkdown(a.markdown, {
+            date: a.today, kind: 'document', ...(a.sapSystem ? { system: a.sapSystem } : {}),
+        }));
+    }
+    catch {
+        docxPath = null;
+    }
+    const statusPath = writeStatusRecord(specDir, {
+        projectId: a.projectId, slug, file: path.basename(jsonPath), status: 'draft', by: a.by, at: a.now.toISOString(),
+    }, a.rand);
+    return { specDir, jsonPath, mdPath, docxPath, statusPath };
+}
+export function listSharedSpecs(teamDir) {
+    const root = path.join(teamDir, SPECS_DIR);
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const d of dirs.sort((x, y) => (x.name < y.name ? -1 : x.name > y.name ? 1 : 0))) {
+        if (!d.isDirectory())
+            continue;
+        const specDir = path.join(root, d.name);
+        let names;
+        try {
+            names = fs.readdirSync(specDir);
+        }
+        catch {
+            continue;
+        }
+        let best = null;
+        for (const n of names) {
+            if (!n.endsWith('.cspeach.json'))
+                continue;
+            const p = path.join(specDir, n);
+            try {
+                const env = readEnvelopeFile(p);
+                if (env.artefactType !== 'spec-gap')
+                    continue;
+                const mtime = fs.statSync(p).mtimeMs;
+                if (!best || env.version > best.env.version || (env.version === best.env.version && mtime > best.mtime))
+                    best = { path: p, env, mtime };
+            }
+            catch { /* unreadable envelope: skipped */ }
+        }
+        if (!best || best.env.artefactType !== 'spec-gap')
+            continue;
+        // R11: answers apply only to the envelope they were recorded for.
+        const bestFile = path.basename(best.path);
+        const answersHere = readAnswers(specDir).filter((a) => a.file === bestFile);
+        const composed = composeSpec(best.env, answersHere);
+        if (composed.artefactType !== 'spec-gap')
+            continue;
+        const open = new Set(composed.interaction.items.filter((i) => i.status === 'open').map((i) => i.id));
+        const questions = [];
+        for (const s of composed.content.sections) {
+            for (const g of s.gaps)
+                if (open.has(g.id))
+                    questions.push({ id: g.id, severity: g.severity, text: g.text });
+        }
+        const openQuestions = [...questions.filter((q) => q.severity === 'BLOCKER'), ...questions.filter((q) => q.severity !== 'BLOCKER')];
+        const st = readSpecStatus(specDir);
+        out.push({
+            slug: d.name,
+            specDir,
+            envelopePath: best.path,
+            title: best.env.title,
+            // F4: the person who shared it (first status record, the account in a
+            // team build), else the file's author.
+            author: st.history[0]?.by.name ?? best.env.createdBy.name,
+            createdAt: best.env.createdAt,
+            summary: `${best.env.content.inputType} · ${best.env.content.inferredDomain}`,
+            openQuestions,
+            status: st.current,
+            statusBy: st.record?.by.name ?? null,
+            statusAt: st.record?.at ?? null,
+            changedAnswers: changedAnswersOf(best.env, answersHere),
+        });
+    }
+    return out;
+}
+/** True when `p`, links followed, is inside `<teamDir>/specs/`. */
+export function isSharedSpecPath(teamDir, p) {
+    try {
+        const root = key(path.join(teamDir, SPECS_DIR));
+        // A file not written yet: its folder, links followed, decides.
+        const target = fs.existsSync(p) ? key(p) : path.join(key(path.dirname(p)), process.platform === 'win32' ? path.basename(p).toLowerCase() : path.basename(p));
+        const rel = path.relative(root, target);
+        return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/projects/team-build-context.js

@@ -0,0 +1,49 @@
+/**
+ * F5 (2026-10-29 live run) — the conversation in a team build folder.
+ *
+ * The model did not know the folder's shared specs: asked for a spec it wrote
+ * Markdown itself (refused in specs/, then saved to cspeach-out/), and asked
+ * to build it read the spec files one by one and tried a script to parse
+ * them. Every turn in a build folder now carries one <team_build> fact: the
+ * specs, their state, and the route for each request. CSPeach code writes and
+ * reads specs/; the model only hands off.
+ *
+ * The folder is the one CSPeach runs in (R10). Never throws: a folder it
+ * cannot read gives no block.
+ */
+import { buildFolderAt } from '../commands/team-spec.js';
+import { listSharedSpecs } from './spec-share.js';
+function questionsLine(open) {
+    if (!open.length)
+        return 'no open questions';
+    const blockers = open.filter((q) => q.severity === 'BLOCKER').length;
+    const n = `${open.length} open question${open.length === 1 ? '' : 's'}`;
+    return blockers ? `${n} (${blockers} blocker${blockers === 1 ? '' : 's'})` : n;
+}
+export function teamBuildContextBlock(cwd, seat) {
+    try {
+        const here = buildFolderAt(cwd);
+        if (!here)
+            return '';
+        const specs = listSharedSpecs(here.dir);
+        const lines = [
+            '<team_build>',
+            `This folder is the team build "${here.project.name}". A functional colleague writes specs here and a developer builds them.`,
+            specs.length ? 'Specs in this folder:' : 'No specs yet.',
+            ...specs.map((s) => `- "${s.title}" — ${s.status} — ${questionsLine(s.openQuestions)}`),
+            'CSPeach keeps these specs and their answers: never read, parse or write the files under specs/ yourself.',
+            'To write a new spec or change one: hand_off with skill "abap-spec-gap" and what the spec is about.',
+        ];
+        if (seat === 'functional') {
+            lines.push('When the person says a spec is ready for the developer, CSPeach records it; this seat does not build.');
+        }
+        else {
+            lines.push('To build a ready spec: hand_off with skill "abap-app" and the spec\'s title in the request. CSPeach attaches the spec and shows its open questions first.');
+        }
+        lines.push('</team_build>');
+        return lines.join('\n');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/register/picture.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { buildRegister, narrowedLanes } from '@cspeach/register-core';
-import { collectRecords, readBaseline, readEstate, readLanes, readProjectFile } from './store.js';
+import { collectRecords, coreProject, readBaseline, readEstate, readLanes, readProjectFile } from './store.js';
 /** `project`: the folder's project file when the caller has already read it (one read, one answer). */
 export function registerFor(projectDir, outboxDir, project = readProjectFile(projectDir)) {
     const collected = collectRecords(projectDir);
@@ -13,7 +13,7 @@ export function registerFor(projectDir, outboxDir, project = readProjectFile(pro
     // The newest discovery, when the folder holds one: the estate around the team project.
     const estate = readEstate(projectDir)?.estate;
     const register = buildRegister({
-        project, baseline, lanes, records: [...collected.records, ...own.records], ...(estate !== undefined ? { estate } : {}),
+        project: coreProject(project), baseline, lanes, records: [...collected.records, ...own.records], ...(estate !== undefined ? { estate } : {}),
     });
     return {
         register, files: collected.files + own.files,

package/dist/register/store.js

@@ -21,6 +21,19 @@ import { writeWhole } from './write-whole.js';
 export const TEAM_FILE = 'cspeach-team.json';
 export const BASELINE_FILE = path.join('baseline', 'objects.json');
 export const LANES_FILE = 'lanes.json';
+/**
+ * Team build (2026-10-25): 2 is the team build (`type: 'build'`, no baseline).
+ * Clean-core and upgrade folders stay formatVersion 1, untouched. A file
+ * newer than this is refused: it was made by a newer CSPeach.
+ */
+export const TEAM_FORMAT_VERSION = 2;
+/**
+ * register-core types a project file as formatVersion 1 and never reads the
+ * field (its sheet makes a bare one with 1). Handing it a team build file
+ * (formatVersion 2) is safe; this says so in one place instead of a cast at
+ * every call.
+ */
+export const coreProject = (p) => p;
 export class RegisterError extends Error {
 }
 export const defaultRand = (bytes) => randomBytes(bytes).toString('hex');
@@ -86,6 +99,9 @@ export function readProjectFile(projectDir) {
     if (p?.kind !== 'team-project' || typeof p.projectId !== 'string' || typeof p.lead?.name !== 'string') {
         throw new RegisterError(`${path.join(projectDir, TEAM_FILE)} is not a CSPeach team project file`);
     }
+    if (typeof p.formatVersion === 'number' && p.formatVersion > TEAM_FORMAT_VERSION) {
+        throw new RegisterError('This team folder was made by a newer CSPeach. Update CSPeach: cspeach --upgrade');
+    }
     return p;
 }
 /**
@@ -124,6 +140,9 @@ function readTextOrSay(file, missing) {
 }
 /** `project`: the folder's project file when the caller has already read it (one read, one answer). */
 export function readBaseline(projectDir, project = readProjectFile(projectDir)) {
+    // A team build pulls no baseline: nothing to read, and baseline/ is never touched.
+    if (project.type === 'build' && project.formatVersion === 2)
+        return [];
     const file = path.join(projectDir, project.baseline?.file ?? BASELINE_FILE);
     const text = readTextOrSay(file, `The baseline file is missing: ${file}`);
     if (project.baseline?.sha256 && sha256(text) !== project.baseline.sha256) {

package/dist/renderer/routing-line.js

@@ -12,3 +12,14 @@ export function formatRoutingLine(e) {
         case 'cancelled': return formatInfo('Cancelled');
     }
 }
+/**
+ * F6 (2026-10-29 live run) — a slash command the person typed starts its
+ * skill without a word on screen; a routed one says "· Using /<skill>". Same
+ * line for the typed one. A queued command (hand-off, app chain) and a plan
+ * phase already have their own line: null.
+ */
+export function typedSkillLine(a) {
+    if (!a.skill || a.queued || a.planPhase)
+        return null;
+    return formatRoutingLine({ kind: 'using', skill: a.skill });
+}

package/dist/repl/builtin-commands.js

@@ -34,6 +34,7 @@ export const BUILTIN_ENTRIES = [
     { name: '/usage', get description() { return usageCommandDescription(); } },
     { name: '/compact', description: 'Shrink a long session and keep the facts (later turns cost far less)' },
     { name: '/export', description: 'Export the session audit record (/export audit [filename]) or a Word copy: of the last answer (/export docx, or /export docx <name>), of the whole conversation (/export docx conversation) or of a Markdown file (/export docx <file>.md)' },
+    { name: '/files', description: 'Pick a saved project file and what to do with it' },
     { name: '/context', description: 'Show what fills the model context window — a composition grid of bars' },
     { name: '/exit', description: 'Exit CSPeach' },
     { name: '/quit', description: 'Exit CSPeach (alias)' },
@@ -56,9 +57,9 @@ export const BUILTIN_ENTRIES = [
 ];
 /**
  * Builtin command heads for routing checks. Superset of BUILTIN_ENTRIES:
- * `/files` is a real REPL builtin (repl.tsx handles it in both paths) and
- * `/cancel` is still handled by the classic loop, but neither is listed in the
- * picker catalogue, so both are added here.
+ * `/cancel` is still handled by the classic loop but is not listed in the
+ * picker catalogue, so it is added here. (`/files` is listed since 2026-10-27;
+ * it stays here too, harmlessly.)
  */
 const BUILTIN_HEADS = new Set([
     ...BUILTIN_ENTRIES.map((e) => e.name),