@cspeach/cli 1.1.48 → 1.1.49

package/dist/journey/clean-core.js

@@ -25,7 +25,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { provenForTarget as provenForTargetCore } from '@cspeach/register-core';
+import { projectView, provenForTarget as provenForTargetCore } from '@cspeach/register-core';
 import { DISCOVERY_DIR, TEAM_FILE, activeProject, readBaseline, readEstate, readProjectFile } from '../register/store.js';
 import { registerFor } from '../register/picture.js';
 import { reportFileNames } from '../register/workbooks.js';
@@ -36,22 +36,37 @@ const STAGE_STEP = {
     INVENTORY: 1, START: 2, JOIN: 2, DECIDE: 3, FIX: 4, PROVE: 5, REPORT: 6,
 };
 export const stepOf = (stage) => STAGE_STEP[stage];
-/** States that need nothing more from the person. */
-const SETTLED = new Set(['clean', 'verified', 'retired']);
 /** A fix was claimed and a later check still found it (or found more). */
 const FAILED_CHECK = new Set(['did-not-hold', 'regressed']);
 const same = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
 const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
 const size = (o) => (o.openFindings === null ? Number.MAX_SAFE_INTEGER : o.openFindings);
 const smallestFirst = (a, b) => size(a) - size(b) || byName(a, b);
+/**
+ * The project view of a register when the caller holds no project file (a
+ * test, a fact read that has none): the same parts — they are read from the
+ * register alone — with `lead` as the lead's name. The journey reads its
+ * lists from the view `readJourneyFacts` built; this is only the fallback.
+ */
+export function journeyView(register, lead = 'the lead') {
+    return projectView(register, { kind: 'team-project', formatVersion: 1, projectId: register.projectId, name: '', type: 'clean-core', lead: { name: lead } });
+}
+/**
+ * My objects whose part is one of `parts`, in register order (project view
+ * Task 5: the journey lists are filters over `view.me(me)`, never a rule of
+ * their own). Register objects, so the cards read what they always read.
+ */
+function mineIn(register, me, view, keep) {
+    const byKey = new Map(register.objects.map((o) => [o.key, o]));
+    return view.me(me).objects.filter(keep).map((o) => byKey.get(o.key)).filter((o) => !!o);
+}
 /** My objects: in a lane I own, in scope, not retired. */
-export function myObjects(register, me) {
-    const lanes = new Set(register.lanes.filter((l) => same(l.owner, me)).map((l) => l.id));
-    return register.objects.filter((o) => o.lane !== null && lanes.has(o.lane) && o.inScope && o.state !== 'retired');
+export function myObjects(register, me, view = journeyView(register)) {
+    return mineIn(register, me, view, (o) => o.part !== 'retired' && o.part !== 'out-of-scope');
 }
-/** My objects that still need a decision, in register order. */
-export function toDecide(register, me, skip = {}) {
-    return myObjects(register, me).filter((o) => !o.decision && !SETTLED.has(o.state) && !skip.decide?.has(o.key));
+/** My objects that still need a decision, in register order: not decided yet, or skipped by a view that is not this session's. */
+export function toDecide(register, me, skip = {}, view = journeyView(register)) {
+    return mineIn(register, me, view, (o) => (o.part === 'undecided' || o.part === 'skipped') && !skip.decide?.has(o.key));
 }
 /** A triage is shown at most this many objects at a time (design §2: pages of 40). */
 export const PAGE_SIZE = 40;
@@ -60,23 +75,22 @@ export const PAGE_SIZE = 40;
  * the first one (the triage is queued for that one area), in register order,
  * at most PAGE_SIZE.
  */
-export function decidePage(register, me, skip = {}) {
-    const left = toDecide(register, me, skip);
+export function decidePage(register, me, skip = {}, view = journeyView(register)) {
+    const left = toDecide(register, me, skip, view);
     const lane = left[0]?.lane;
     return left.filter((o) => o.lane === lane).slice(0, PAGE_SIZE);
 }
 /**
- * My objects decided "fix" that need a fix: first the ones nobody has claimed
- * yet, then the ones whose claimed fix failed the check (did not hold, or
- * regressed). Each group smallest first (fewest open findings, never measured last).
+ * My objects decided "fix" that need a fix: first the view's "to fix" part,
+ * then its "fix failed the check" part (a fix decision only: a kept object
+ * that regressed is not a fix job). Each group smallest first (fewest open
+ * findings, never measured last). A fix proven for its own target, or
+ * claimed again since its check, is in another part and never listed here.
  */
-export function toFix(register, me, skip = {}) {
-    const mine = myObjects(register, me).filter((o) => o.decision?.classification === 'fix' && !SETTLED.has(o.state) && !skip.fix?.has(o.key)
-        // Proof first (spec §3.2): a failed fix with nothing open for its own target is not sent back.
-        && !provenForTarget(o));
-    // A failed fix already claimed again waits for its check (toProve), not for another fix.
-    const retry = mine.filter((o) => FAILED_CHECK.has(o.state) && !claimedSinceCheck(o));
-    const fresh = mine.filter((o) => !FAILED_CHECK.has(o.state) && !o.fixes.some((f) => f.status === 'fixed'));
+export function toFix(register, me, skip = {}, view = journeyView(register)) {
+    const left = (o) => !skip.fix?.has(o.key);
+    const fresh = mineIn(register, me, view, (o) => o.part === 'to-fix' && left(o));
+    const retry = mineIn(register, me, view, (o) => o.part === 'failed-check' && o.decision.what === 'fix' && left(o));
     return [...fresh.sort(smallestFirst), ...retry.sort(smallestFirst)];
 }
 /**
@@ -102,12 +116,12 @@ export function provenForTarget(o) {
 /** True when this object is in `toFix` because its fix failed the check. */
 export const fixFailedCheck = (o) => FAILED_CHECK.has(o.state);
 /** My objects planned for a rebuild beside the core — handled separately, never in the fix loop. */
-export function toRedesign(register, me) {
-    return myObjects(register, me).filter((o) => o.decision?.classification === 'redesign' && !SETTLED.has(o.state)).sort(byName);
+export function toRedesign(register, me, view = journeyView(register)) {
+    return mineIn(register, me, view, (o) => o.part === 'rebuild').sort(byName);
 }
 /** My objects whose fix is claimed and not measured since — a failed fix claimed again included. */
-export function toProve(register, me) {
-    return myObjects(register, me).filter((o) => o.state === 'claimed' || (FAILED_CHECK.has(o.state) && claimedSinceCheck(o)));
+export function toProve(register, me, view = journeyView(register)) {
+    return mineIn(register, me, view, (o) => o.part === 'awaiting-check');
 }
 /** The newest thing the register knows of, in ms; null when nothing is recorded. */
 export function newestRecordAt(register) {
@@ -151,11 +165,12 @@ export function stageOf(f) {
     if (!r.lanes.some((l) => same(l.owner, f.me)) && !same(f.folder.lead, f.me))
         return 'UNOWNED';
     const skip = f.skip ?? {};
-    if (toDecide(r, f.me, skip).length)
+    const view = f.view ?? journeyView(r, f.folder.lead);
+    if (toDecide(r, f.me, skip, view).length)
         return 'DECIDE';
-    if (toFix(r, f.me, skip).length)
+    if (toFix(r, f.me, skip, view).length)
         return 'FIX';
-    if (!skip.prove && toProve(r, f.me).length)
+    if (!skip.prove && toProve(r, f.me, view).length)
         return 'PROVE';
     if (!skip.report) {
         const newest = newestRecordAt(r);
@@ -166,14 +181,22 @@ export function stageOf(f) {
 }
 /** Where the folder's project stands for this laptop. Never throws. */
 export function folderKind(cwd, me) {
+    return folderRead(cwd, me).folder;
+}
+/**
+ * `folderKind`, plus the project file it read. The journey reuses that one read:
+ * a project file that goes unreadable halfway through a sync must read as
+ * "project file", never as some other failure on a second read.
+ */
+function folderRead(cwd, me) {
     if (!fs.existsSync(path.join(cwd, TEAM_FILE)))
-        return { kind: 'none' };
+        return { folder: { kind: 'none' } };
     let project;
     try {
         project = readProjectFile(cwd);
     }
     catch {
-        return { kind: 'unreadable', reason: 'project-file' };
+        return { folder: { kind: 'unreadable', reason: 'project-file' } };
     }
     const who = { lead: project.lead.name, name: project.name };
     let joined;
@@ -184,8 +207,8 @@ export function folderKind(cwd, me) {
         joined = null;
     }
     if (joined && joined.projectId === project.projectId && samePath(joined.projectDir, cwd))
-        return { kind: 'joined', ...who };
-    return same(project.lead.name, me) ? { kind: 'mine-not-joined', ...who } : { kind: 'someone-else', ...who };
+        return { folder: { kind: 'joined', ...who }, project };
+    return { folder: same(project.lead.name, me) ? { kind: 'mine-not-joined', ...who } : { kind: 'someone-else', ...who }, project };
 }
 /** mtime of the status page the report step writes, or null. */
 export function reportsAt(cwd, projectName) {
@@ -211,21 +234,23 @@ export function readJourneyFacts(cwd, me, skip) {
     catch {
         hasDiscovery = false;
     }
-    const folder = folderKind(cwd, me);
+    const { folder, project } = folderRead(cwd, me);
     const facts = { hasDiscovery, folder, me, reportsAt: null, ...(skip ? { skip } : {}) };
-    if (folder.kind !== 'joined')
+    if (folder.kind !== 'joined' || !project)
         return facts;
     try {
         // The object list first, on its own: its failures (missing, garbled,
         // checksum) are the everyday mid-sync case and get their own word.
-        readBaseline(cwd);
+        readBaseline(cwd, project);
     }
     catch {
         return { ...facts, folder: { kind: 'unreadable', reason: 'object-list' } };
     }
     try {
         const joined = activeProject();
-        facts.register = registerFor(joined.projectDir, joined.outboxDir).register;
+        // The project file folderRead already read (joined means its folder is this one).
+        facts.register = registerFor(joined.projectDir, joined.outboxDir, project).register;
+        facts.view = projectView(facts.register, project, skip?.decide ? { skipped: skip.decide } : {});
         facts.reportsAt = reportsAt(cwd, folder.name);
     }
     catch {

package/dist/journey/flow.js

@@ -31,12 +31,13 @@ export function userTurnCount(session) {
     return messages.filter((m) => m.role === 'user' && (typeof m.content === 'string'
         || (Array.isArray(m.content) && m.content.some((b) => b?.type !== 'tool_result')))).length;
 }
-/** Skips survive a pause, so "carry on" does not ask again what was put off. */
+/** Skips survive a pause; "carry on" asks some again (forgetNotNow, forgetSkippedRows), the fixes put off stay put off. */
 const skips = new WeakMap();
 /** Start (or restart) the journey for this session. */
 export function startJourneyFlow(session, packages = []) {
     flows.set(session, { packages: [...packages] });
     paused.delete(session);
+    ended.delete(session);
     setJourneyRunActive(true);
 }
 export function getJourneyFlow(session) {
@@ -46,8 +47,45 @@ export function getJourneyFlow(session) {
         ...(f.queued ? { queued: Object.freeze({ ...f.queued }) } : {}),
         ...(f.page ? { page: [...f.page] } : {}),
         ...(f.pages ? { pages: f.pages } : {}),
+        ...(f.developers ? { developers: [...f.developers] } : {}),
+        ...(f.skippedAsked ? { skippedAsked: true } : {}),
     }) : undefined;
 }
+/** G3: the rows skipped are asked about once a run. */
+export function markSkippedAsked(session) {
+    const f = flows.get(session);
+    if (f)
+        f.skippedAsked = true;
+}
+/** B1: the people named on the people card, `me` last; none → Just me. */
+export function setJourneyDevelopers(session, developers) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    if (developers?.length)
+        f.developers = [...developers];
+    else
+        delete f.developers;
+}
+/**
+ * B8: sessions whose journey ended at DONE ("Next time … say carry on"), with
+ * the session's user-turn count then. Bare "carry on" resumes only right
+ * after: once another turn of the person's ran, the words keep their old
+ * meaning (as isJourneyPausedJustNow). clearJourneyFlow never touches the
+ * mark; a new start clears it.
+ */
+const ended = new WeakMap();
+export const markJourneyEnded = (session) => { ended.set(session, userTurnCount(session)); };
+export const isJourneyEndedJustNow = (session) => !!session && ended.has(session) && ended.get(session) === userTurnCount(session);
+/**
+ * B8: what the last DONE summed up (the register's newest record time, its
+ * check runs and my object count). A DONE that finds the same says "Nothing
+ * left to carry on." A new start sentence forgets it (`forgetDoneFingerprint`).
+ */
+const doneFingerprints = new WeakMap();
+export const doneFingerprint = (session) => doneFingerprints.get(session);
+export const setDoneFingerprint = (session, print) => { doneFingerprints.set(session, print); };
+export const forgetDoneFingerprint = (session) => { doneFingerprints.delete(session); };
 /** The page of objects the next triage is shown; one more page handed out. */
 export function setJourneyPage(session, keys) {
     const f = flows.get(session);
@@ -158,6 +196,18 @@ export function noteJourneyStop(session, step) {
 }
 /** Paused, and no turn of the person's has run since the pause line. */
 export const isJourneyPausedJustNow = (session) => !!session && paused.has(session) && paused.get(session) === userTurnCount(session);
+/**
+ * R8: the folders this session's journey has read. The first read of a
+ * project folder in a session is the cold one (a synced folder fetches its
+ * files then); the chain says "Reading the folder…" before it.
+ */
+const foldersRead = new WeakMap();
+export const folderReadThisSession = (session, cwd) => foldersRead.get(session)?.has(cwd) ?? false;
+export function markFolderRead(session, cwd) {
+    const s = foldersRead.get(session) ?? new Set();
+    s.add(cwd);
+    foldersRead.set(session, s);
+}
 /** The session skips as the stage machine reads them. */
 export function journeySkips(session) {
     const s = skips.get(session);
@@ -170,6 +220,7 @@ export function journeySkips(session) {
         ...(s.prove ? { prove: true } : {}),
         ...(s.report ? { report: true } : {}),
         ...(s.rebuild?.size ? { rebuild: new Set(s.rebuild) } : {}),
+        ...(s.retire?.size ? { retire: new Set(s.retire) } : {}),
     };
 }
 export function addJourneySkips(session, add) {
@@ -189,6 +240,12 @@ export function addJourneySkips(session, add) {
         for (const k of add.rebuild)
             s.rebuild.add(k);
     }
+    // Task 6: "Not yet" on the lead's retire card holds for the session, "carry on" included.
+    if (add.retire?.size) {
+        s.retire ??= new Set();
+        for (const k of add.retire)
+            s.retire.add(k);
+    }
     skips.set(session, s);
 }
 /**
@@ -204,7 +261,11 @@ export function addJourneyLeftOut(session, keys) {
         s.leftOut.add(k);
     skips.set(session, s);
 }
-/** "Carry on" asks the check, the report, the rebuild hand-offs and the rows the triage left out again; fixes and rows skipped stay put off. */
+/**
+ * "Carry on" asks the check, the report, the rebuild hand-offs and the rows the
+ * triage left out again; fixes put off stay put off. The rows skipped at a row
+ * card are forgotten by forgetSkippedRows (G3), which "carry on" also calls.
+ */
 export function forgetNotNow(session) {
     const s = skips.get(session);
     if (!s)
@@ -214,3 +275,15 @@ export function forgetNotNow(session) {
     delete s.rebuild;
     delete s.leftOut;
 }
+/**
+ * G3: the rows skipped at a row card and the page rows left out, forgotten:
+ * the next DECIDE asks them again. Said Yes on "Look at the n rows you
+ * skipped?", and on "carry on". Nothing else the session put off is touched.
+ */
+export function forgetSkippedRows(session) {
+    const s = skips.get(session);
+    if (!s)
+        return;
+    s.decide.clear();
+    delete s.leftOut;
+}

package/dist/journey/people.js

@@ -0,0 +1,37 @@
+/**
+ * Task 1 (B1) — the names typed at "Who else?" on the people card. Pure.
+ *
+ * Split on `,` `;` and ` and `; me, I and myself are dropped; the same name
+ * twice is kept once. A name is 2–60 characters of letters, spaces,
+ * apostrophes, dots and hyphens, at most four words — no digit, underscore or
+ * slash, so a package name can never pass for a person; a name equal to a
+ * package of the start scope is refused too. At most 9 names.
+ */
+import { shown } from '../register/atc-file.js';
+export const MAX_PEOPLE = 9;
+const NAME = /^[\p{L}][\p{L}'’.-]*(?: [\p{L}][\p{L}'’.-]*){0,3}$/u;
+const SELF = new Set(['me', 'i', 'myself']);
+/** `typed` is cleaned for the screen by the caller (shown). */
+export const notANameLine = (typed) => `"${typed}" is not a person's name. Full names, for example James Miller.`;
+export const TOO_MANY_PEOPLE_LINE = `At most ${MAX_PEOPLE} names, please.`;
+/** `packages`: the start scope — a typed name equal to one of them (any case) is refused like any other non-name. */
+export function parsePeople(said, packages = []) {
+    const scope = new Set(packages.map((p) => p.trim().toUpperCase()));
+    const names = [];
+    const seen = new Set();
+    for (const raw of said.split(/\s*[,;]\s*|\s+and\s+/i)) {
+        const name = raw.trim().replace(/\s+/g, ' ');
+        if (!name || SELF.has(name.toLowerCase()))
+            continue;
+        if (name.length < 2 || name.length > 60 || !NAME.test(name) || scope.has(name.toUpperCase())) {
+            return { ok: false, line: notANameLine(shown(name)) };
+        }
+        if (seen.has(name.toLowerCase()))
+            continue;
+        seen.add(name.toLowerCase());
+        names.push(name);
+    }
+    if (names.length > MAX_PEOPLE)
+        return { ok: false, line: TOO_MANY_PEOPLE_LINE };
+    return { ok: true, names };
+}

package/dist/journey/rebuild.js

@@ -26,7 +26,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { APP_LABEL, isAppLabel, objectKey, proposeRebuildKind, } from '@cspeach/register-core';
+import { APP_LABEL, isAppLabel, objectKey, proposeRebuildKind, viewWords, } from '@cspeach/register-core';
 import { activeProject } from '../register/store.js';
 import { registerFor } from '../register/picture.js';
 import { writeRecord } from '../register/records.js';
@@ -53,7 +53,7 @@ export const UNSURE_LINE = 'CSPeach cannot tell the kind from what it read. Chan
 export const REBUILD_BRIEF_REL = (app) => `rebuilds/${app}/rebuild-brief.md`;
 const SID = /^[A-Z][A-Z0-9]{2}$/;
 const PACKAGE = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_$]{1,30}$/;
-const LEVEL = /^[A-D]$/;
+const NO_TARGET = { level: null, from: 'none', by: null };
 const MODERNIZE = 'abap-modernize';
 const nameOk = (type, name) => OBJECT_TYPE.test(type) && OBJECT_NAME.test(name);
 /* ── names and commands ─────────────────────────────────────────────────── */
@@ -88,13 +88,13 @@ export function rebuildBrief(b) {
     const sid = b.sid && SID.test(b.sid.toUpperCase()) ? b.sid.toUpperCase() : 'the SAP system';
     const names = objs.map((o) => o.name).join(', ');
     const why = screenedReason(b.reason);
-    const target = b.target && LEVEL.test(b.target) ? b.target : 'not set';
     return [
         `# Rebuild of ${objs.map((o) => `${o.name} (${o.type}${o.pkg ? `, package ${o.pkg}` : ''})`).join(', ')} on ${sid}`,
         ...(b.kind === 'app' ? [`Build an app that replaces the old program ${names}. Users create, change and view the same data the old program handles today.`] : []),
         ...(b.kind === 'api' ? [`Build an API service that replaces ${names}: no UI, OData service.`] : []),
         ...objs.map((o) => `Read the old program's behaviour from the SAP system (${o.type} ${o.name}) before designing: its selection fields, its output columns, its checks.`),
-        `Target clean-core level: ${target}.`,
+        // Project view Task 5: the view's words — "target B (set by Sarah Davis)", "target A (project target)", "no target set".
+        `For the new build: ${viewWords.target(b.target ?? NO_TARGET)}.`,
         ...(why ? [`Why it was decided (context only, not a requirement): ${why.text}.`] : []),
         ...(why?.marked ? [MARKED_NOTE] : []),
         // Ruling (fix round 1 follow-up): no quotable "report" phrase anywhere in the ask.
@@ -200,7 +200,7 @@ export async function rebuildCard(confirm, g) {
  * all); a class or an API service is one card per object (review fix 3).
  * `passed` names each rebuild CSPeach cannot hand off, with why.
  */
-export function rebuildGroups(mine, skip, rulesOf = () => []) {
+export function rebuildGroups(mine, skip, rulesOf = () => [], targetOf = () => undefined) {
     const groups = new Map();
     const passed = [];
     for (const o of mine) {
@@ -224,7 +224,8 @@ export function rebuildGroups(mine, skip, rulesOf = () => []) {
         const kind = own ?? p.kind;
         const entry = {
             type: o.type.toUpperCase(), name: o.name.toUpperCase(), key: o.key, package: o.package,
-            ...(o.decision.reason ? { reason: o.decision.reason } : {}), target: o.proof?.target?.level ?? null,
+            // Project view Task 5: the view's target, never a level read off the decision.
+            ...(o.decision.reason ? { reason: o.decision.reason } : {}), target: targetOf(o.key) ?? null,
         };
         const id = kind === 'app' ? `app|${app}` : `one|${o.key}`;
         const g = groups.get(id);