@cspeach/cli 1.1.31 → 1.1.32

package/dist/journey/chain.js

@@ -14,23 +14,33 @@
  * Headless runs nothing and queues nothing: runJourneyStage says the next step.
  */
 import { estateSummaryOf } from '@cspeach/register-core';
-import { DEFAULT_ATC_VARIANT, runTeamCommand, whoAmI } from '../commands/team.js';
+import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, runTeamCommand, whoAmI } from '../commands/team.js';
 import { activeProject, readEstate, readProjectFile, VARIANT_NAME } from '../register/store.js';
 import { findingsByObject } from '../register/findings.js';
 import { shown, shownUpTo } from '../register/atc-file.js';
 import { cspeachWritesThisSession } from '../register/offer.js';
 import { cardSlotEmitter } from '../ui/card-slot.js';
-import { claimedSinceCheck, decidePage, fixFailedCheck, readJourneyFacts, stageOf, stepOf, STEPS, toDecide, toFix } from './clean-core.js';
-import { addJourneyLeftOut, addJourneySkips, clearJourneyFlow, forgetNotNow, getJourneyFlow, journeySkips, pauseJourneyFlow, setJourneyPage, setJourneyQueued, startJourneyFlow, } from './flow.js';
-import { notRecordedLine, passedOverLine, refactorCommand, runJourneyStage, shownReason } from './run.js';
+import { claimedSinceCheck, decidePage, fixFailedCheck, folderKind, provenForTarget, readJourneyFacts, stageOf, stepOf, STEPS, toDecide, toFix, toRedesign } from './clean-core.js';
+import { handOffRebuild, rebuildCard, rebuildGroups } from './rebuild.js';
+import { addJourneyLeftOut, addJourneySkips, clearJourneyFlow, forgetNotNow, getJourneyFlow, journeyHopLine, journeySkips, journeyStepKey, noteJourneyStop, pauseJourneyFlow, setJourneyAt, setJourneyPage, setJourneyQueued, startJourneyFlow, } from './flow.js';
+import { recordFullNotice } from '../renderer/notice-log.js';
+import { firstCheckPerPackage, needsFirstCheck, notRecordedLine, passedOverLine, refactorCommand, runJourneyStage, shownReason } from './run.js';
 import { cleanKeepReason, FACT_ROWS, KEEP_QUESTION } from '../projects/clean-core-confirm.js';
 import { sessionTeamDeps } from './session-deps.js';
+import { lookupVariant, variantLookupLine, variantWhat, VARIANT_TITLE } from '../register/variant.js';
 /* ── words ──────────────────────────────────────────────────────────────── */
 export const PAUSED_LINE = (step) => step ? `Paused at step ${step}. Say carry on to continue.` : 'Paused. Say carry on to continue.';
 export const LOOK_TITLE = 'Look at the system?';
 export const START_TITLE = 'Start the project here?';
 export const NOTHING_READ_LINE = 'Nothing was read from the system.';
 export const NOT_STARTED_LINE = 'No project was started.';
+/** I15: the start above 500 objects measured nothing; this card offers the first check per package. */
+export const FIRST_CHECK_TITLE = 'Run the first check per package now?';
+/**
+ * Mode 1 (architecture §D, spec §3.6): No at "Start the project here?" leaves the
+ * analysis only — what the inventory showed, with nothing kept against it.
+ */
+export const POINT_IN_TIME_LINE = 'What you saw is a point-in-time look, not tracked: no count matched against SAP, no history, no proof after a later change.';
 /** A discovery this many days old is used as it is; an older one asks again. */
 export const FRESH_DAYS = 7;
 const plural = (count, one, many) => `${count.toLocaleString('en-US')} ${count === 1 ? one : many}`;
@@ -140,12 +150,70 @@ function toolCallsOf(session) {
     const calls = session.toolCalls;
     return Array.isArray(calls) ? calls : [];
 }
+/**
+ * Queue the journey's next model step (already set with setJourneyQueued):
+ * tagged as CSPeach's, with the one line that stands for it on screen (audit M-2).
+ */
+function queueStep(h, command) {
+    const line = journeyHopLine(h.session, command);
+    h.queueNext(command, { by: 'journey', ...(line ? { line } : {}) });
+}
 /** End the chain: optional last line, the guarded run off. */
 function end(h, line) {
     clearJourneyFlow(h.session);
     if (line)
         h.emit(line);
 }
+/**
+ * Audit M-1 — an unexpected error stopped the chain (the entry, or the post-turn
+ * hook). The line promises "carry on", so the run is PAUSED, the same pause a
+ * stray turn makes: bare "carry on" resumes from the folder-derived stage.
+ * With no project file in the folder "carry on" cannot pick anything up
+ * (detectJourney needs one), so the run ends and the line says to start again.
+ */
+export const STOPPED_LINE = 'The clean-core steps stopped here. Say carry on to continue.';
+export const STOPPED_BEFORE_START_LINE = 'The clean-core steps stopped before a project was started. Say the same words again to start over.';
+/**
+ * The same step stopped again (must-fix follow-up a). The run ENDS rather than
+ * pauses, so a bare "carry on" no longer picks it up and nothing can loop on
+ * its own; the words that name clean core still start it again, by choice.
+ */
+export const STOPPED_AGAIN_LINE = (count, detail) => `This step failed ${count === 2 ? 'twice' : `${count} times`}. Details: ${shortDetail(detail)}. Say carry on with clean core to try again, or ask for help.`;
+/** The first line of an error, at most 140 characters, without a trailing full stop. */
+function shortDetail(text) {
+    const first = (String(text ?? '').split(/\r?\n/)[0] ?? '').trim().replace(/[.\s]+$/, '') || 'no detail';
+    return first.length > 140 ? `${first.slice(0, 140).trimEnd()}…` : first;
+}
+/**
+ * The error goes to the session's notice log with the step it stopped at, so
+ * support can see it. A second stop in a row at the same step says so, with
+ * the detail, and ends the run (`STOPPED_AGAIN_LINE`).
+ */
+export function journeyStoppedOnError(session, cwd, err) {
+    // The step is the stage the chain last reached: a stop before the folder could
+    // be read again (the entry after "carry on") is still a stop at that step.
+    const step = journeyStepKey(session) ?? getJourneyFlow(session)?.queued?.stage ?? 'START';
+    const detail = err instanceof Error ? err.message : err === undefined ? '' : String(err);
+    recordFullNotice('journey', `clean-core steps stopped at ${step}: ${detail || 'no detail'}`);
+    let resumable = false;
+    try {
+        resumable = folderKind(cwd, '').kind !== 'none';
+    }
+    catch {
+        resumable = false;
+    }
+    if (!resumable) {
+        clearJourneyFlow(session);
+        return STOPPED_BEFORE_START_LINE;
+    }
+    const count = noteJourneyStop(session, step);
+    if (count > 1) {
+        clearJourneyFlow(session);
+        return STOPPED_AGAIN_LINE(count, detail);
+    }
+    pauseJourneyFlow(session);
+    return STOPPED_LINE;
+}
 /** Pause the chain: the pause line, and "carry on" (even bare) picks it up. */
 function pause(h, step) {
     pauseJourneyFlow(h.session);
@@ -217,7 +285,10 @@ const DEFAULT_TARGET = 'A';
 export function fixFacts(o, at, of, open = []) {
     const reason = shownReason(o.decision?.reason, CARD_REASON);
     const set = o.decision?.targetLevel;
-    const target = set && LEVEL.test(set) && set !== DEFAULT_TARGET ? set : undefined;
+    // Step 2: a target a person or the project set (proof.target) is said, A included.
+    // Without one, the legacy reading stands: only a recorded level other than A.
+    const named = o.proof?.target?.level;
+    const target = named && LEVEL.test(named) ? named : set && LEVEL.test(set) && set !== DEFAULT_TARGET ? set : undefined;
     const now = o.decision?.level && LEVEL.test(o.decision.level) ? o.decision.level : undefined;
     return [
         o.openFindings === null ? 'Not checked yet.' : `${plural(o.openFindings, 'open finding', 'open findings')}.`,
@@ -301,9 +372,121 @@ export async function fixCard(confirm, objects, skips, openOf = () => []) {
     }
     return { kind: 'cancel' };
 }
+/** The object's target for the fix turn's prompt, when a person or the project set one. */
+function targetFor(o) {
+    const level = o?.proof?.target?.level;
+    return level && LEVEL.test(level) ? { target: level } : {};
+}
+export const VARIANT_QUESTION = 'Which check variant? Type its name.';
+/** Said before "No project was started." when the variant card or its question was tried too often. */
+export const VARIANT_TRIES_LINE = 'Too many tries to choose a check variant.';
+/**
+ * Step 2, after "Start the project here?" (spec §3.1, F7, F16, I17): the check
+ * the project measures with, shown and looked up on the system. The journey
+ * always proposes ABAP_CLOUD_READINESS (no sentence parser, F7). [Use another]
+ * asks for a name (journeyAsk: free text), refuses one that is not a variant
+ * name, looks it up and shows the card again. Returns the confirmed name, or
+ * null when the card or the question was put away.
+ */
+async function variantCard(h, team, confirm) {
+    const inv = inventoryOf(h.cwd);
+    const sid = shown(inv?.sid ?? (h.sapAlias && h.sapAlias !== 'none' ? h.sapAlias : 'the system'));
+    const ask = h.ask ?? journeyAsk();
+    const look = async (name) => {
+        if (team.deps.noSap || !team.deps.connect)
+            return 'unreadable';
+        try {
+            return await lookupVariant((await team.deps.connect()).sql, name);
+        }
+        catch {
+            return 'unreadable';
+        }
+    };
+    let name = DEFAULT_ATC_VARIANT;
+    for (let tries = 0; tries < 5; tries++) {
+        const res = await confirm({
+            id: 'journey-variant',
+            tag: 'QUESTION',
+            title: VARIANT_TITLE(name),
+            facts: [variantWhat(name), variantLookupLine(name, sid, await look(name))],
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'another', label: 'Use another' }],
+            initial: 0,
+            aliases: { y: 'yes', u: 'another' },
+            footnote: footnote('START'),
+        });
+        if (res.cancelled || res.value === null)
+            return null;
+        if (res.value === 'yes')
+            return name;
+        let typed = '';
+        for (let k = 0; k < 3 && !typed; k++) {
+            let said;
+            try {
+                said = await ask(VARIANT_QUESTION);
+            }
+            catch {
+                return null;
+            }
+            const candidate = said.trim().toUpperCase();
+            if (VARIANT_NAME.test(candidate))
+                typed = candidate;
+            else
+                h.emit(`"${shownUpTo(said.trim(), 60)}" is not an ATC check variant name.`);
+        }
+        if (!typed) {
+            h.emit(VARIANT_TRIES_LINE);
+            return null;
+        }
+        name = typed;
+    }
+    h.emit(VARIANT_TRIES_LINE);
+    return null;
+}
+/**
+ * I15: "Run the first check per package now? It resumes if stopped." Yes runs
+ * `team refresh --all --per-package`; Later (or the card put away) ends the
+ * chain with the command as a line. Returns true when the chain goes on.
+ */
+async function firstCheckCard(h, team, skips, packages) {
+    const res = await team.confirm({
+        id: 'journey-first-check',
+        tag: 'QUESTION',
+        title: FIRST_CHECK_TITLE,
+        facts: ['It resumes if stopped.'],
+        choices: [{ value: 'yes', label: 'Yes' }, { value: 'later', label: 'Later' }],
+        initial: 0,
+        aliases: { y: 'yes', l: 'later' },
+        footnote: footnote('START'),
+    });
+    if (res.cancelled || res.value === null || res.value === 'later') {
+        end(h, FIRST_CHECK_PER_PACKAGE_LINE);
+        return false;
+    }
+    const check = await firstCheckPerPackage({ cwd: h.cwd, team, headless: h.headless, skips, packages: [...packages] });
+    for (const line of check.lines)
+        h.emit(line);
+    if (check.next.kind !== 'continue') {
+        end(h);
+        return false;
+    }
+    return true;
+}
 /* ── the chain ──────────────────────────────────────────────────────────── */
 /** Where the chain is: the stage, and a print of what the session put off (no progress → stop). */
-const fingerprint = (stage, s) => `${stage}|${s.decide?.size ?? 0}|${s.fix?.size ?? 0}|${s.prove ? 1 : 0}|${s.report ? 1 : 0}`;
+const fingerprint = (stage, s) => `${stage}|${s.decide?.size ?? 0}|${s.fix?.size ?? 0}|${s.prove ? 1 : 0}|${s.report ? 1 : 0}|${s.rebuild?.size ?? 0}`;
+/** The newest check's rule ids per object (the kind proposal's ALV fact, F6); none when they cannot be read. */
+function rulesReader() {
+    let byKey = null;
+    try {
+        const joined = activeProject();
+        if (joined)
+            byKey = findingsByObject(joined.projectDir, joined.outboxDir);
+    }
+    catch {
+        byKey = null;
+    }
+    return (key) => byKey?.get(key)?.latest.map((r) => r.rule) ?? [];
+}
 async function drive(h) {
     const flow = getJourneyFlow(h.session);
     if (!flow)
@@ -319,6 +502,7 @@ async function drive(h) {
         const skips = journeySkips(h.session);
         const facts = readJourneyFacts(h.cwd, me, skips);
         const stage = stageOf(facts);
+        setJourneyAt(h.session, stage);
         // Ctrl-C: what was measured is kept; "carry on" picks up from the folder.
         if (h.signal?.aborted) {
             stopAt(h, stage);
@@ -333,6 +517,8 @@ async function drive(h) {
         previous = print;
         let runAs = stage;
         let runSkips = skips;
+        let startVariant;
+        let bigStart = false;
         if (!h.headless) {
             // Step 1 — "Look at the system?": no inventory yet, or one older than a week.
             const inv = stage === 'START' && !ranInventory ? inventoryOf(h.cwd) : null;
@@ -370,13 +556,14 @@ async function drive(h) {
                 const scope = startScope(h.cwd, flow.packages);
                 if (scope) {
                     const n = scope.objects;
+                    bigStart = n > FIRST_CHECK_WHOLE_MAX;
                     const yes = await yesNo(confirm, {
                         id: 'journey-start',
                         title: START_TITLE,
                         facts: [
                             `${plural(n, 'object', 'objects')} in ${scope.names.join(', ')} in the inventory.`,
                             "The start checks this against SAP's own count.",
-                            `First check: ${aboutMinutes(n)}.`,
+                            bigStart ? 'First check: one package at a time, after the start.' : `First check: ${aboutMinutes(n)}.`,
                             'Saved in this folder.',
                             // Recording fix 5: the name every record is written under, seen before anything is written.
                             `You: ${shown(me)}.`,
@@ -386,11 +573,28 @@ async function drive(h) {
                         footnote: footnote('START'),
                     });
                     if (!yes) {
+                        end(h, NOT_STARTED_LINE);
+                        h.emit(POINT_IN_TIME_LINE);
+                        return;
+                    }
+                    // F16 / D5: the check is chosen visibly — never silently the default.
+                    const chosen = await variantCard(h, team, confirm);
+                    if (!chosen) {
                         end(h, NOT_STARTED_LINE);
                         return;
                     }
+                    startVariant = chosen;
                 }
             }
+            // T7 review 1: nothing measured yet, and the scope is too big for one check — never
+            // a status page or "Done for now." over nothing: the per-package first check is offered again.
+            // DECIDE too: 600 objects to decide with no check behind any of them is no step to take first.
+            if ((runAs === 'DECIDE' || runAs === 'REPORT' || runAs === 'DONE') && needsFirstCheck(facts)) {
+                if (!(await firstCheckCard(h, team, runSkips, flow.packages)))
+                    return;
+                previous = '';
+                continue;
+            }
             // Step 4 — "Fix <NAME> now?".
             if (runAs === 'FIX' && facts.register) {
                 // A name that is not an ABAP name never reaches a card or a command: one line, passed over.
@@ -414,6 +618,36 @@ async function drive(h) {
                 if (pick.kind === 'yes')
                     runSkips = pick.skips;
             }
+            // Step 2, Task 5 (D3, F1) — at the end, the rebuild hand-off: one card
+            // per object or app label. Yes ends the journey, then queues the rebuild.
+            if (runAs === 'DONE' && facts.register) {
+                const groups = rebuildGroups(toRedesign(facts.register, me), skips.rebuild, rulesReader());
+                if (groups.passed.length) {
+                    // A rebuild CSPeach cannot hand off is said once, with why, and not asked again.
+                    for (const p of groups.passed)
+                        h.emit(p.line);
+                    addJourneySkips(h.session, { rebuild: new Set(groups.passed.map((p) => p.key)) });
+                }
+                const group = groups[0];
+                if (group) {
+                    const pick = await rebuildCard(confirm, group);
+                    if (pick.kind === 'cancel') {
+                        pause(h);
+                        return;
+                    }
+                    if (pick.kind === 'later') {
+                        addJourneySkips(h.session, { rebuild: new Set(group.objects.map((o) => o.key ?? `${o.type}|${o.name}`)) });
+                        h.emit(`${group.objects.length === 1 ? group.objects[0].name : group.app}: left for later.`);
+                        continue;
+                    }
+                    const sid = inventoryOf(h.cwd)?.sid;
+                    handOffRebuild({
+                        session: h.session, cwd: h.cwd, emit: h.emit, by: me, now,
+                        ...(h.queueNext ? { queueNext: h.queueNext } : {}), ...(sid ? { sid } : {}), callsAt: toolCallsOf(h.session).length,
+                    }, group, pick.rebuild);
+                    return;
+                }
+            }
             // Step 3, from the second page on — "Next 40? [Yes] [Later]".
             if (runAs === 'DECIDE' && facts.register && (getJourneyFlow(h.session)?.pages ?? 0) > 0) {
                 const left = toDecide(facts.register, me, skips);
@@ -443,12 +677,21 @@ async function drive(h) {
         const r = await runJourneyStage(runAs, {
             cwd: h.cwd, team, headless: h.headless, skips: runSkips, packages: flow.packages,
             ...(h.openFile ? { openFile: h.openFile } : {}),
+            ...(startVariant ? { variant: startVariant } : {}),
         });
         if (runAs === 'INVENTORY')
             ranInventory = true;
         for (const line of r.lines)
             h.emit(line);
         addJourneySkips(h.session, r.skip);
+        // I15: a start above 500 objects measured nothing. Asked once: the first check, per package.
+        // `firstCheckPerPackage`: init decided from the live pull, which can be over 500 when the inventory was not (T7 review 2).
+        if (runAs === 'START' && (bigStart || r.firstCheckPerPackage) && r.next.kind === 'continue') {
+            if (!(await firstCheckCard(h, team, runSkips, flow.packages)))
+                return;
+            previous = '';
+            continue;
+        }
         if (r.next.kind === 'continue') {
             if (runAs !== stage)
                 previous = ''; // a fresh inventory is progress
@@ -468,9 +711,9 @@ async function drive(h) {
             }
             else {
                 const key = r.next.key;
-                setJourneyQueued(h.session, { command, skill, stage: 'FIX', ...(key ? { key } : {}), callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd) });
+                setJourneyQueued(h.session, { command, skill, stage: 'FIX', ...(key ? { key } : {}), callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd), ...targetFor(facts.register?.objects.find((o) => o.key === key)) });
             }
-            h.queueNext(command);
+            queueStep(h, command);
             return;
         }
         end(h); // stop or done: the runner said its last words
@@ -512,7 +755,8 @@ export async function afterJourneyTurn(h, t) {
         // nothing recorded. "Left for later" alone hid what was still open: one
         // card says it and asks what to do.
         const o = facts.register?.objects.find((x) => x.key === q.key);
-        if (o && fixFailedCheck(o) && !claimedSinceCheck(o)) {
+        // Proof first: a fix with nothing open for its own target is not offered again.
+        if (o && fixFailedCheck(o) && !claimedSinceCheck(o) && !provenForTarget(o)) {
             setJourneyQueued(h.session, undefined);
             const goOn = await retryCard(h, team, o);
             if (!goOn)
@@ -595,8 +839,8 @@ async function retryCard(h, team, o) {
                 return false;
             }
             h.emit(`Step ${stepOf('FIX')} of ${STEPS} — fix ${name} again.`);
-            setJourneyQueued(h.session, { command, skill: 'abap-refactor', stage: 'FIX', key: o.key, callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd) });
-            h.queueNext(command);
+            setJourneyQueued(h.session, { command, skill: 'abap-refactor', stage: 'FIX', key: o.key, callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd), ...targetFor(o) });
+            queueStep(h, command);
             return false;
         }
         if (res.value === 'keep' && level) {
@@ -676,14 +920,20 @@ export function projectVariant(cwd) {
  * variant and found the fix had failed. The turn's own prompt now names that
  * variant and when the fix is done.
  */
-export function journeyFixBlock(variant) {
+export function journeyFixBlock(variant, target) {
     const v = VARIANT_NAME.test(variant) ? variant : DEFAULT_ATC_VARIANT;
+    // Step 2: the object's target, said only when one is set (a letter, never other words).
+    const t = target && LEVEL.test(target) ? target : undefined;
     return [
         '<journey>',
         "This fix is one step of CSPeach's guided clean-core run.",
         `The project's check variant is ${v}.`,
+        ...(t ? [`This object's target is clean-core level ${t}. CSPeach proves the fix against that target with this check.`] : []),
         `After you activate the object, run ATC on it with the variant ${v}, not the default one.`,
-        `The fix is done only when ${v} shows no findings for the object.`,
+        // Final review M4: with a target other than A, findings that only matter for A may stay.
+        t && t !== 'A'
+            ? `The fix is done when ${v} shows no findings that stand in the way of level ${t}; findings that only matter for A may stay.`
+            : `The fix is done only when ${v} shows no findings for the object.`,
         'If findings remain, fix them and check again. For example: do not type parameters with fields of views SAP has not released; use released data elements and classes.',
         'Do at most 2 more rounds. Then say plainly what is still open.',
         'Do not suggest any cspeach command, and do not use the words team or lane.',
@@ -699,7 +949,7 @@ export function journeyTurnBlock(session, skill) {
     if (q?.stage === 'DECIDE' && skill === 'abap-clean-core')
         return JOURNEY_TURN_BLOCK;
     if (q?.stage === 'FIX' && skill === 'abap-refactor')
-        return journeyFixBlock(q.variant ?? DEFAULT_ATC_VARIANT);
+        return journeyFixBlock(q.variant ?? DEFAULT_ATC_VARIANT, q.target);
     return '';
 }
 /* ── the gate ───────────────────────────────────────────────────────────── */

package/dist/journey/clean-core.js

@@ -10,6 +10,7 @@
  *   INVENTORY  no discovery in the folder
  *   START      no project in the folder
  *   JOIN       a project in the folder this laptop does not record into
+ *   UNOWNED    joined, not the lead, and no lane is mine: "You own nothing here yet" — never DONE (step 2, §3.6)
  *   DECIDE     my objects with findings (or not measured) and no decision
  *   FIX        my objects decided "fix" with no claim yet, then fixes that failed the check
  *   PROVE      my objects whose fix is claimed and not measured since
@@ -24,12 +25,13 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { 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';
 import { samePath } from '../commands/team-discover.js';
 export const STEPS = 6;
-/** "Step n of 6". Joining a project is part of step 2; UNREADABLE and DONE have no step. */
+/** "Step n of 6". Joining a project is part of step 2; UNREADABLE, UNOWNED and DONE have no step. */
 const STAGE_STEP = {
     INVENTORY: 1, START: 2, JOIN: 2, DECIDE: 3, FIX: 4, PROVE: 5, REPORT: 6,
 };
@@ -69,7 +71,9 @@ export function decidePage(register, me, skip = {}) {
  * regressed). Each group smallest first (fewest open findings, never measured last).
  */
 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));
+    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'));
@@ -84,6 +88,17 @@ export function claimedSinceCheck(o) {
     const checked = o.lastMeasuredAt ? Date.parse(o.lastMeasuredAt) : NaN;
     return o.fixes.some((f) => f.status === 'fixed' && (!Number.isFinite(checked) || Date.parse(f.at) > checked));
 }
+/**
+ * Step 2 (spec §3.2): a fix the check says did not hold, measured, with a
+ * target a person or the project set, and NOTHING open for that target — the
+ * findings left would only matter for a stricter level. It reads "fix proven
+ * for <L>" and the journey does not send it back to FIX. No target (a legacy
+ * `targetLevel` without `targetBy`), or no `proof` at all: false, as before.
+ */
+export function provenForTarget(o) {
+    // One predicate for the journey and every report (final review I1).
+    return provenForTargetCore(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. */
@@ -103,8 +118,11 @@ export function newestRecordAt(register) {
             newest = t;
     };
     take(register.lastMeasuredAt);
-    for (const o of register.objects)
+    // Final review M5: a rebuild row is evidence, so lastRecordAt never moves for it; count its time too.
+    for (const o of register.objects) {
         take(o.lastRecordAt);
+        take(o.evidence?.rebuild?.at);
+    }
     return newest;
 }
 /** Why the stage is UNREADABLE, as a reason kind; undefined when it is not. */
@@ -128,6 +146,10 @@ export function stageOf(f) {
     const r = f.register;
     if (!r)
         return 'UNREADABLE'; // unreadableReason(f) === 'other'
+    // Step 2 (spec §3.6): a developer who owns no lane has nothing to do yet — and is told so, never DONE.
+    // The lead is never UNOWNED: a lead who left themselves out of the lanes still makes the report.
+    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)
         return 'DECIDE';

package/dist/journey/flow.js

@@ -94,6 +94,12 @@ export function setJourneyQueued(session, step) {
         f.queued = { ...step };
     else
         delete f.queued;
+    // The step the chain is at is now this object's (ruling on follow-up a).
+    if (step)
+        lastAt.set(session, { stage: step.stage, ...(step.key ? { key: step.key } : {}) });
+    // Review M2: a step queued is a step the chain got through: the stop count starts over.
+    if (step)
+        stops.delete(session);
 }
 /** End the journey: the flow goes, the guarded run ends; skips stay for the session. */
 export function clearJourneyFlow(session) {
@@ -113,6 +119,43 @@ export function pauseJourneyFlow(session, offset = 0) {
     paused.set(session, userTurnCount(session) + offset);
 }
 export const isJourneyPaused = (session) => !!session && paused.has(session);
+/**
+ * The stage the chain last reached (set each round by `drive`). Kept for the
+ * session across a pause or an ended run: an error that stops the chain before
+ * it can read the folder again still belongs to the step it last reached.
+ */
+const lastAt = new WeakMap();
+/** A new stage drops the object; the same stage keeps it until another object is queued. */
+export function setJourneyAt(session, stage) {
+    const cur = lastAt.get(session);
+    // Review M2: a new stage is progress: the stop count starts over.
+    if (cur?.stage !== stage)
+        stops.delete(session);
+    lastAt.set(session, cur?.stage === stage ? cur : { stage });
+}
+export const journeyAt = (session) => lastAt.get(session)?.stage;
+/**
+ * The step an error stopped: the stage on the object it was working on (a FIX
+ * on ZCL_A is not a FIX on ZCL_B), or the stage alone when it has no object.
+ */
+export function journeyStepKey(session) {
+    const at = lastAt.get(session);
+    return at ? (at.key ? `${at.stage} ${at.key}` : at.stage) : undefined;
+}
+/**
+ * Stops on an error, by step, for the session (must-fix follow-up a): kept
+ * across a pause and an ended run, so a step that fails again after "carry on"
+ * is told apart from a new failure. Counted only IN A ROW: a stop at another
+ * step, a new stage reached, or a step queued (the chain got through) starts over.
+ */
+const stops = new WeakMap();
+/** Count this stop: how many times in a row the chain has stopped at `step`. */
+export function noteJourneyStop(session, step) {
+    const last = stops.get(session);
+    const count = last && last.step === step ? last.count + 1 : 1;
+    stops.set(session, { step, count });
+    return count;
+}
 /** 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);
 /** The session skips as the stage machine reads them. */
@@ -126,6 +169,7 @@ export function journeySkips(session) {
         ...(s.fix.size ? { fix: new Set(s.fix) } : {}),
         ...(s.prove ? { prove: true } : {}),
         ...(s.report ? { report: true } : {}),
+        ...(s.rebuild?.size ? { rebuild: new Set(s.rebuild) } : {}),
     };
 }
 export function addJourneySkips(session, add) {
@@ -140,6 +184,11 @@ export function addJourneySkips(session, add) {
         s.prove = true;
     if (add.report)
         s.report = true;
+    if (add.rebuild?.size) {
+        s.rebuild ??= new Set();
+        for (const k of add.rebuild)
+            s.rebuild.add(k);
+    }
     skips.set(session, s);
 }
 /**
@@ -155,12 +204,13 @@ export function addJourneyLeftOut(session, keys) {
         s.leftOut.add(k);
     skips.set(session, s);
 }
-/** "Carry on" asks the check, the report 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 and rows skipped stay put off. */
 export function forgetNotNow(session) {
     const s = skips.get(session);
     if (!s)
         return;
     delete s.prove;
     delete s.report;
+    delete s.rebuild;
     delete s.leftOut;
 }