@cspeach/cli 1.1.52 → 1.1.54

package/dist/projects/save-command.js

@@ -1,8 +1,8 @@
 import { readdirSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { extractSpecGap } from './extract-spec-gap.js';
-import { extractDesign } from './extract-design.js';
-import { extractEstimate } from './extract-estimate.js';
+import { extractSpecGap, hasSpecGapSign } from './extract-spec-gap.js';
+import { extractDesign, hasDesignSign } from './extract-design.js';
+import { extractEstimate, hasEstimateSign } from './extract-estimate.js';
 import { extractUpgradeScan, extractUpgradeProgress, extractUpgradeReport } from './extract-upgrade.js';
 import { extractCcaAssessment } from './extract-cca.js';
 import { extractModernizeResult } from './extract-modernize.js';
@@ -24,21 +24,33 @@ 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',
         extract: (md) => extractSpecGap(md),
         itemNoun: 'questions',
+        hasDocumentSign: hasSpecGapSign,
+        documentNoun: 'a spec-gap document',
     },
     'abap-design': {
         artefactType: 'design',
         extract: (md) => extractDesign(md),
         itemNoun: 'objects',
+        hasDocumentSign: hasDesignSign,
+        documentNoun: 'a design document',
     },
     'abap-estimate': {
         artefactType: 'estimate',
         extract: (md) => extractEstimate(md),
         itemNoun: 'components',
+        hasDocumentSign: hasEstimateSign,
+        documentNoun: 'an estimate document',
     },
     'abap-upgrade-scan': {
         artefactType: 'upgrade-scan',
@@ -231,6 +243,18 @@ export function resolvePriorPlanEnvelope(title, dir, opts = {}) {
     opts.log?.(`[save] More than one plan is titled '${pick.envelope.title}'; revising the newest: ${basename(pick.path)}`);
     return pick;
 }
+/**
+ * Task 17 (F-N) — the person's message asks us to save the document:
+ * "save this/it/that", "save the spec-gap/design/estimate/document",
+ * "can you save", "please save". Ordinary wording about saving in the app
+ * ("validation on save", "the user clicks Save", "saving changes") is not.
+ */
+const ASKED_TO_SAVE_RE = new RegExp([
+    String.raw `\b(?:can|could|would|will)\s+you\s+(?:please\s+)?save\b`,
+    String.raw `\bplease\s+save\b`,
+    String.raw `\bsave\s+(?:this|it|that|them)\b`,
+    String.raw `\bsave\s+(?:the|my|our)\s+(?:spec[\s-]*gaps?|design|estimate|document|doc|result|analysis|file|project\s+file)\b`,
+].join('|'), 'i');
 export async function runSaveCommand(args) {
     const spec = SKILL_REGISTRY[args.skillName];
     if (!spec)
@@ -323,22 +347,31 @@ export async function runSaveCommand(args) {
                 return runSaveCommand({ ...args, skillName: detected });
             }
         }
-        if (spec.manifestMarker && args.skillOutput.includes(spec.manifestMarker)) {
-            args.log('');
-            args.log(`[save] ${args.skillName}: a ${spec.manifestMarker} block IS present but failed to parse — artefact NOT saved.`);
-            args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
-            args.log(`[save] The output above is otherwise complete — re-run the skill or report this as a manifest bug.`);
+        if (spec.manifestMarker) {
+            // Task 17 fix round 1 (F-N): the manifest skills send every turn here.
+            // A turn with no manifest block is a conversational turn, not a failed
+            // save: say nothing (the B5 contract on manifestMarker above). A block
+            // that is present but fails to parse keeps its loud lines.
+            if (args.skillOutput.includes(spec.manifestMarker)) {
+                args.log('');
+                args.log(`[save] ${args.skillName}: a ${spec.manifestMarker} block IS present but failed to parse — artefact NOT saved.`);
+                args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
+                args.log(`[save] The output above is otherwise complete — re-run the skill or report this as a manifest bug.`);
+            }
         }
-        else {
-            // 2026-09-17 — marker-less skills (design, estimate, spec-gap) used to
-            // fail here in silence: no file, no line, and the next --from step had
-            // nothing to start from (seen live: a design titled "# ABAP Design"
-            // instead of "## ABAP Design"). Say what happened and what to do.
-            args.log('');
-            args.log(`[save] ${args.skillName}: could not read the output as a ${spec.artefactType} — nothing was saved.`);
-            args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
-            args.log(`[save] Ask CSPeach to "re-issue the ${spec.artefactType} in the standard structure" and it will be saved then.`);
+        else if (spec.hasDocumentSign && spec.documentNoun) {
+            // Task 17 (F-N, 2026-10-26) — the save step runs on every turn of the
+            // session skill. A turn with no sign of the document (a recap after a
+            // choice card) is not a failed save: say nothing, unless the person
+            // asked to save. A text that does look like the document gets one
+            // plain line.
+            if (spec.hasDocumentSign(args.skillOutput) || ASKED_TO_SAVE_RE.test(args.skillInput ?? '')) {
+                args.log('');
+                args.log(`We couldn't save this as ${spec.documentNoun}. Ask us to write it again in the usual layout.`);
+            }
         }
+        // (2026-09-17's "[save] … could not read the output" lines are gone: every
+        // registry skill now has a manifest marker or a document sign above.)
         args.onNotSaved?.('unreadable');
         return null;
     }
@@ -401,7 +434,8 @@ export async function runSaveCommand(args) {
     const answer = journey ? 'y' : await askYesNo({
         question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt,
         // F-A (live check 2026-10-26) — a plan is only built from its saved file.
-        ...(spec.artefactType === 'plan' ? { defaultYes: true } : {}),
+        // Task 20 (owner 2026-10-26) — the spec-gap document defaults to Yes too.
+        ...(spec.artefactType === 'plan' || spec.artefactType === 'spec-gap' ? { defaultYes: true } : {}),
     });
     if (!isYes(answer)) {
         args.onNotSaved?.('declined');
@@ -461,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 {
@@ -524,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,239 @@
+/**
+ * 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';
+export const SPECS_DIR = 'specs';
+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;
+    }
+    const name = saved ?? 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 composed = composeSpec(best.env, readAnswers(specDir).filter((a) => a.file === bestFile));
+        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,
+            author: 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,
+        });
+    }
+    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/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/change-card.js

@@ -103,6 +103,20 @@ export function diffBody(card, differ = defaultDiffer) {
         for (const l of part.value.replace(/\r?\n$/, '').split(/\r?\n/))
             changed.push(`${part.added ? '+' : '-'} ${clean(l)}`);
     }
+    // 1.1.53 (live F-E): the first write after a create replaces SAP's template,
+    // whose removed lines are only comments. Myers puts those first and hides the
+    // new code, so in that case the added code leads, then added comment/blank
+    // lines, then the removals. Any removal that carries code keeps Myers order.
+    const isCommentOrBlank = (l) => {
+        const code = l.slice(2);
+        return code.trim() === '' || code.startsWith('*') || /^\s*"/.test(code);
+    };
+    const removed = changed.filter((l) => l.startsWith('-'));
+    const added = changed.filter((l) => l.startsWith('+'));
+    const addedCode = added.filter((l) => !isCommentOrBlank(l));
+    if (removed.length > 0 && removed.every(isCommentOrBlank) && addedCode.length > 0) {
+        changed.splice(0, changed.length, ...addedCode, ...added.filter(isCommentOrBlank), ...removed);
+    }
     return { lines: changed.slice(0, DIFF_LINES), hidden: Math.max(0, changed.length - DIFF_LINES) };
 }
 export function buildChangeCard(input, width, box = getBoxChars()) {

package/dist/renderer/html-entities.js

@@ -0,0 +1,25 @@
+/**
+ * 1.1.53 item 5 — the model sometimes writes `<` / `>` / `&` in the
+ * text and diffs it puts on an approval card. Cards show the real characters.
+ * One pass only: `&amp;lt;` becomes `&lt;`, never `<`.
+ *
+ * Display only. Never apply this to anything written to SAP or saved.
+ */
+const ENTITY = /&(lt|gt|amp);/g;
+const CHAR = { lt: '<', gt: '>', amp: '&' };
+export function decodeDisplayEntities(s) {
+    return s.replace(ENTITY, (_m, name) => CHAR[name]);
+}
+/** A raw field symbol or raw markup: `<` followed by a letter, `_`, `/` or `!`. */
+const RAW_TAG = /<[A-Za-z_/!]/;
+/**
+ * The same decode for a whole source or diff block, except when the block
+ * holds a raw field symbol or raw markup (`<fs>`, `<b>`, `</p>`, `<!--`).
+ * A model that escapes field symbols escapes them throughout; real source
+ * that holds `&lt;` in a literal almost always has a raw `<fs>` or markup
+ * too, so it stays as written. Operators and comparisons (`->`, `=>`, `>=`,
+ * `<=`, `<>`, ` < `) do not count. Display only, like decodeDisplayEntities.
+ */
+export function decodeDisplayBlock(s) {
+    return RAW_TAG.test(s) ? s : decodeDisplayEntities(s);
+}