@cspeach/cli 1.1.47 → 1.1.49

package/dist/journey/chain.js

@@ -13,27 +13,41 @@
  * Every queued command is built by code (run.ts triageCommand / refactorCommand).
  * Headless runs nothing and queues nothing: runJourneyStage says the next step.
  */
-import { estateSummaryOf } from '@cspeach/register-core';
-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 { estateSummaryOf, viewWords } from '@cspeach/register-core';
+import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, isLead, ruleObject, runTeamCommand, whoAmI } from '../commands/team.js';
+import { activeProject, readBaseline, 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, folderKind, provenForTarget, readJourneyFacts, stageOf, stepOf, STEPS, toDecide, toFix, toRedesign } from './clean-core.js';
+import { decidePage, folderKind, journeyView, 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 { addJourneyLeftOut, addJourneySkips, clearJourneyFlow, forgetDoneFingerprint, forgetNotNow, forgetSkippedRows, getJourneyFlow, journeyHopLine, journeySkips, journeyStepKey, folderReadThisSession, markFolderRead, markJourneyEnded, markSkippedAsked, noteJourneyStop, pauseJourneyFlow, setJourneyAt, setJourneyDevelopers, setJourneyPage, setJourneyQueued, startJourneyFlow, } from './flow.js';
+import { parsePeople } from './people.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 { RISK_NOTE } from '../approvals/risk-floor.js';
+import { firstCheckPerPackage, needsFirstCheck, notInViewLine, notRecordedLine, passedOverLine, refactorCommand, runJourneyStage, shownReason } from './run.js';
+import { cleanKeepReason, FACT_ROWS, KEEP_QUESTION, RETIRE_QUESTION, retireNeedsLine } from '../projects/clean-core-confirm.js';
 import { sessionTeamDeps } from './session-deps.js';
 import { lookupVariant, variantLookupLine, variantWhat, VARIANT_TITLE } from '../register/variant.js';
+import { isModifiable } from '@cspeach/sap-client';
+import { notARequestLine, TRANSPORT_REQUEST } from '../register/project-transport.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.';
+/** B1: asked at every project start, before "Start the project here?". */
+export const PEOPLE_TITLE = 'Anyone else working on this?';
+export const PEOPLE_QUESTION = 'Who else? Full names, comma separated — for example: James Miller, Emily Parker';
+/** R8: said before a read that can take a while (a project folder read cold, or a big one). */
+export const READING_LINE = 'Reading the folder…';
+/** R8: a baseline above this many objects is read slowly enough to say so on every run. */
+const READING_BIG = 200;
+export const JUST_YOU_LINE = 'Carrying on with just you.';
+/** One person's line on the people cards and the start card. */
+const shareFact = (name) => `${shown(name)}: a share of the work, set at the start.`;
 /** 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?';
 /**
@@ -158,9 +172,14 @@ 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) {
+/**
+ * End the chain: optional last line, the guarded run off. `done`: it ended at
+ * DONE, whose line says "say carry on" — so bare "carry on" picks it up (B8).
+ */
+function end(h, line, done = false) {
     clearJourneyFlow(h.session);
+    if (done)
+        markJourneyEnded(h.session);
     if (line)
         h.emit(line);
 }
@@ -227,7 +246,13 @@ export async function enterJourney(trigger, h) {
         return;
     }
     startJourneyFlow(h.session, trigger.kind === 'start' ? trigger.packages : []);
+    // B8: a start sentence is a new run: its DONE never reads as "nothing left" against an earlier one.
+    if (trigger.kind === 'start')
+        forgetDoneFingerprint(h.session);
     forgetNotNow(h.session);
+    // G3: "carry on" asks the rows skipped again (a start sentence keeps them put off).
+    if (trigger.kind === 'resume')
+        forgetSkippedRows(h.session);
     try {
         await drive(h);
     }
@@ -269,36 +294,38 @@ function startScope(cwd, packages) {
 /** The card shows this much of a recorded reason, wrapped over up to FACT_ROWS rows. */
 export const CARD_REASON = 300;
 const LEVEL = /^[A-D]$/;
+/** The view's words with a capital first letter, for a fact line. */
+const sentence = (words) => words.charAt(0).toUpperCase() + words.slice(1);
 /**
- * Every fix or rebuild is recorded with target A when none was given
- * (register/records.ts, `cspeach team decide`); register-core keeps what it is
- * handed, so a recorded A cannot be told from a default. Only another level
- * was set on purpose, and only that one is said.
- */
-const DEFAULT_TARGET = 'A';
-/**
- * The facts of the fix card, from the register only (no SAP call): the open
- * findings, a failed check, why (the decision's reason as written, cleaned
- * for the screen, at most 300 characters, wrapped on the card), the target level when one was set
- * on purpose, the approval promise, and where this object stands in the list.
+ * The facts of the fix card, from the project view only (no SAP call): the
+ * open findings, a failed check, the decision's reason in the view's card
+ * words (`viewWords.cardReason`: "Proposed reason:", "Why:" or "Reason
+ * recorded:"; cleaned for the screen, at most 300 characters, wrapped on the
+ * card), the target only when a person or the project set one
+ * (`viewWords.target`, never a level the model wrote), the approval promise,
+ * and where this object stands in the list ("12 objects marked fix; this is
+ * the first.", or "1 object marked fix.").
  */
 export function fixFacts(o, at, of, open = []) {
-    const reason = shownReason(o.decision?.reason, CARD_REASON);
-    const set = o.decision?.targetLevel;
-    // 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;
+    const r = o.decision.reason;
+    const reason = viewWords.cardReason(r ? { ...r, text: shownReason(r.text, CARD_REASON) } : null);
+    const t = o.target;
+    const now = o.level.now ?? o.level.decided;
+    const target = t.from !== 'none' && t.level
+        ? [`${sentence(viewWords.target({ ...t, by: t.by ? { ...t.by, name: shown(t.by.name) } : null }))}${now && now !== t.level ? `, now ${now}` : ''}.`]
+        : [];
     return [
-        o.openFindings === null ? 'Not checked yet.' : `${plural(o.openFindings, 'open finding', 'open findings')}.`,
-        ...(fixFailedCheck(o) ? ['Its last fix failed the check.', ...open] : []),
-        ...(reason ? [`Why: ${reason}`] : []),
-        ...(target ? [`Target: level ${target}${now && now !== target ? `, now ${now}` : ''}.`] : []),
+        o.proof.open === null ? 'Not checked yet.' : `${plural(o.proof.open, 'open finding', 'open findings')}.`,
+        ...(o.part === 'failed-check' ? ['Its last fix failed the check.', ...open] : []),
+        ...(reason ? [reason] : []),
+        ...target,
         'CSPeach asks before it writes to SAP.',
-        `${at} of ${plural(of, 'object marked fix', 'objects marked fix')}.`,
+        of === 1 ? '1 object marked fix.' : `${plural(of, 'object marked fix', 'objects marked fix')}; this is ${whichOne(at)}.`,
     ];
 }
+const ORDINALS = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth', 'seventh', 'eighth', 'ninth', 'tenth'];
+/** Live re-run L4: "the first" … "the tenth", then "number 11" ("1 of 12" read as "one of twelve"). */
+const whichOne = (at) => (ORDINALS[at - 1] ? `the ${ORDINALS[at - 1]}` : `number ${at.toLocaleString('en-US')}`);
 /** "Still open:" shows at most this many lines on a card. */
 const STILL_OPEN_ROWS = 3;
 /** A fact wraps onto at most this many rows on a card that also lists what is still open. */
@@ -340,20 +367,28 @@ export function stillOpenLines(key) {
  * only the chosen object first. Objects whose names are not ABAP names never
  * reach this card: the chain passes them over first.
  */
-export async function fixCard(confirm, objects, skips, openOf = () => []) {
-    const list = objects.filter((o) => refactorCommand({ type: o.type, name: o.name }) !== null);
+export async function fixCard(confirm, objects, skips, view, passOver, openOf = () => []) {
+    // Fix round 1: an object the card cannot show is passed over with its line, never dropped in silence.
+    const list = objects.filter((o) => {
+        const line = fixPassOverLine(o, view);
+        if (line)
+            passOver(o, line);
+        return !line;
+    });
     if (!list.length)
         return { kind: 'none' };
     const many = list.length > 1;
     for (let i = 0; i < list.length * 20; i++) {
         const o = list[i % list.length];
         const name = o.name.toUpperCase();
-        const open = fixFailedCheck(o) ? openOf(o) : [];
+        const v = view.object(o.key);
+        const failed = v.part === 'failed-check';
+        const open = failed ? openOf(o) : [];
         const res = await confirm({
             id: 'journey-fix',
             tag: 'QUESTION',
-            title: fixFailedCheck(o) ? `${name}'s fix failed the check — try again?` : `Fix ${name} now?`,
-            facts: fixFacts(o, (i % list.length) + 1, list.length, open),
+            title: failed ? `${name}'s fix failed the check — try again?` : `Fix ${name} now?`,
+            facts: fixFacts(v, (i % list.length) + 1, list.length, open),
             choices: [{ value: 'yes', label: 'Yes' }, ...(many ? [{ value: 'another', label: 'Pick another' }] : []), { value: 'later', label: 'Later' }],
             initial: 0,
             aliases: { y: 'yes', ...(many ? { p: 'another' } : {}), l: 'later' },
@@ -372,9 +407,15 @@ 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. */
+/** Why the fix card cannot show an object: a name that is not an ABAP name, or an object the project view does not hold. Null: it can. */
+export function fixPassOverLine(o, view) {
+    if (refactorCommand({ type: o.type, name: o.name }) === null)
+        return passedOverLine(o.name);
+    return view.object(o.key) ? null : notInViewLine(o.name);
+}
+/** The object's target for the fix turn's prompt, from the project view: only when a person or the project set one. */
 function targetFor(o) {
-    const level = o?.proof?.target?.level;
+    const level = o && o.target.from !== 'none' ? o.target.level : null;
     return level && LEVEL.test(level) ? { target: level } : {};
 }
 export const VARIANT_QUESTION = 'Which check variant? Type its name.';
@@ -442,6 +483,166 @@ async function variantCard(h, team, confirm) {
     h.emit(VARIANT_TRIES_LINE);
     return null;
 }
+/** Task 8 (B11): asked at the start, after the check variant. */
+export const TRANSPORT_TITLE = 'Which transport request will hold the fixes?';
+export const TRANSPORT_QUESTION = 'Which transport request? Type its number.';
+/** Said when five answers gave no request that can take the fixes; the project starts without one. */
+export const TRANSPORT_TRIES_LINE = 'Too many tries to choose a transport request. The project starts without one.';
+/** The longest request description the card shows. */
+const TRANSPORT_DESCRIPTION_MAX = 60;
+/** The session can read a transport request from SAP (the card needs it). Standalone and no-SAP sessions cannot. */
+function readsTransports(h, team) {
+    return !h.noSap && !team.deps.noSap && typeof h.adt?.transportRead === 'function';
+}
+/**
+ * Task 8 (B11), step 2, after the check variant: "Which transport request
+ * will hold the fixes?" [Type it] [None yet]. A typed number is checked for
+ * shape, read from SAP (as the release card reads it: request_approval
+ * attachReleaseFacts) and shown back — "Record fixes in <REQ> "<text>"?"
+ * [Yes] [Use another] [None yet] with its owner and status. A task, a
+ * request SAP cannot read, or one that can no longer take changes is said in
+ * one line and the question comes again; five answers, then none yet.
+ * Returns the request, '' for none yet, or null when a card or the question
+ * was put away (no project, as on every start card).
+ */
+async function transportCard(h, confirm) {
+    const first = await confirm({
+        id: 'journey-transport',
+        tag: 'QUESTION',
+        title: TRANSPORT_TITLE,
+        choices: [{ value: 'type', label: 'Type it' }, { value: 'none', label: 'None yet' }],
+        initial: 0,
+        aliases: { t: 'type', n: 'none' },
+        footnote: footnote('START'),
+    });
+    if (first.cancelled || first.value === null)
+        return null;
+    if (first.value !== 'type')
+        return '';
+    const ask = h.ask ?? journeyAsk();
+    for (let tries = 0; tries < 5; tries++) {
+        let said;
+        try {
+            said = await ask(TRANSPORT_QUESTION);
+        }
+        catch {
+            return null;
+        }
+        const asked = said.trim().toUpperCase();
+        if (!TRANSPORT_REQUEST.test(asked)) {
+            h.emit(notARequestLine(shownUpTo(said.trim(), 60)));
+            continue;
+        }
+        let doc;
+        try {
+            doc = await h.adt.transportRead(asked);
+        }
+        catch {
+            h.emit(`CSPeach could not read ${asked}.`);
+            continue;
+        }
+        const number = shown(String(doc.number ?? '')).trim().toUpperCase();
+        if (doc.kind === 'task') {
+            // A task document without its request's number says so without one.
+            h.emit(TRANSPORT_REQUEST.test(number) && number !== asked
+                ? `${asked} is a task of ${number}. Type the request number.`
+                : `${asked} is a task, not a request. Type the request number.`);
+            continue;
+        }
+        const status = shown(String(doc.statusText || doc.status || '')).trim() || 'of unknown status';
+        if (!isModifiable(doc.status)) {
+            h.emit(`${asked} is ${status}; it cannot take changes.`);
+            continue;
+        }
+        const request = TRANSPORT_REQUEST.test(number) ? number : asked;
+        const description = shownUpTo(String(doc.description ?? '').trim(), TRANSPORT_DESCRIPTION_MAX);
+        const owner = shown(String(doc.owner ?? '')).trim();
+        const res = await confirm({
+            id: 'journey-transport-confirm',
+            tag: 'QUESTION',
+            title: `Record fixes in ${request}${description ? ` "${description}"` : ''}?`,
+            facts: [`${owner ? `Owner: ${owner}. ` : ''}Status: ${status}.`],
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'another', label: 'Use another' }, { value: 'none', label: 'None yet' }],
+            initial: 0,
+            aliases: { y: 'yes', u: 'another', n: 'none' },
+            footnote: footnote('START'),
+        });
+        if (res.cancelled || res.value === null)
+            return null;
+        if (res.value === 'yes')
+            return request;
+        if (res.value === 'none')
+            return '';
+    }
+    h.emit(TRANSPORT_TRIES_LINE);
+    return '';
+}
+/** "James Miller", "James Miller and Emily Parker", "A, B and C". */
+const andList = (names) => names.length < 2 ? names.join('') : `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+/**
+ * B1, step 2 — "Anyone else working on this?" [Just me] [Add people], before
+ * "Start the project here?". Add people asks for full names (free text,
+ * people.ts parsePeople: three tries, then just you) and shows them back —
+ * "Add James Miller and Emily Parker?" [Yes] [Retype] [Just me]. Returns the
+ * names (none: Just me), or null when a card or the question was put away.
+ */
+async function peopleCard(h, confirm, me, packages) {
+    const res = await confirm({
+        id: 'journey-people',
+        tag: 'QUESTION',
+        title: PEOPLE_TITLE,
+        facts: ['Each person gets a share of the packages, balanced by the work.'],
+        choices: [{ value: 'me', label: 'Just me' }, { value: 'add', label: 'Add people' }],
+        initial: 0,
+        aliases: { j: 'me', a: 'add' },
+        footnote: footnote('START'),
+    });
+    if (res.cancelled || res.value === null)
+        return null;
+    if (res.value !== 'add')
+        return [];
+    const ask = h.ask ?? journeyAsk();
+    for (let round = 0; round < 5; round++) {
+        let names = null;
+        for (let tries = 0; tries < 3 && !names; tries++) {
+            let said;
+            try {
+                said = await ask(PEOPLE_QUESTION);
+            }
+            catch {
+                return null;
+            }
+            const parsed = parsePeople(said, packages);
+            // The lead is "me" already: typed again under their own name, it is not someone else.
+            if (parsed.ok)
+                names = parsed.names.filter((x) => x.toLowerCase() !== me.trim().toLowerCase());
+            else
+                h.emit(parsed.line);
+        }
+        if (!names?.length) {
+            h.emit(JUST_YOU_LINE);
+            return [];
+        }
+        const back = await confirm({
+            id: 'journey-people-names',
+            tag: 'QUESTION',
+            title: `Add ${andList(names.map((x) => shown(x)))}?`,
+            facts: [`You: ${shown(me)} (lead).`, ...names.map(shareFact)],
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'retype', label: 'Retype' }, { value: 'me', label: 'Just me' }],
+            initial: 0,
+            aliases: { y: 'yes', r: 'retype', j: 'me' },
+            footnote: footnote('START'),
+        });
+        if (back.cancelled || back.value === null)
+            return null;
+        if (back.value === 'yes')
+            return names;
+        if (back.value === 'me')
+            return [];
+    }
+    h.emit(JUST_YOU_LINE);
+    return [];
+}
 /**
  * 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
@@ -472,8 +673,14 @@ async function firstCheckCard(h, team, skips, packages) {
     return true;
 }
 /* ── the chain ──────────────────────────────────────────────────────────── */
+/** G3: how many of my objects the session skipped and are still undecided (the DONE count's "skipped this time": the view's part). */
+function skippedRows(view, me, skips) {
+    if (!skips.decide?.size)
+        return 0;
+    return view.me(me).parts.skipped;
+}
 /** 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}|${s.rebuild?.size ?? 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}|${s.retire?.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;
@@ -487,6 +694,135 @@ function rulesReader() {
     }
     return (key) => byKey?.get(key)?.latest.map((r) => r.rule) ?? [];
 }
+/** This seat is the project's lead (the one test, commands/team.ts). Unreadable → not the lead. */
+function leadHere(team) {
+    try {
+        const joined = activeProject();
+        return !!joined && isLead(readProjectFile(joined.projectDir), team.deps);
+    }
+    catch {
+        return false;
+    }
+}
+/** Where-used, in the words CSPeach prints for it (the words a retire reason quotes). */
+function callersLine(c) {
+    if (!c)
+        return 'Where-used could not be read: no inventory for this object.';
+    if (!c.read)
+        return `Where-used could not be read: ${shownUpTo(c.why, 120).replace(/[\s.]+$/, '')}.`;
+    return c.objects === 0 ? 'No callers found (where-used read OK).' : `Callers found: ${plural(c.objects, 'object', 'objects')} (where-used read OK).`;
+}
+/** Usage with its source and period, as team_findings gives it; "unknown" says why. */
+function usageLine(u) {
+    if (!u)
+        return 'Usage: unknown.';
+    const source = u.source ? `, from ${shownUpTo(u.source, 60)}` : '';
+    const period = u.period ? ` (${shownUpTo(u.period.from, 30)} to ${shownUpTo(u.period.to, 30)})` : '';
+    const last = u.lastUsed ? `, last used ${shownUpTo(u.lastUsed, 30)}` : '';
+    const why = !u.source && u.why ? ` — ${shownUpTo(u.why, 160).replace(/[\s.]+$/, '')}` : '';
+    return `Usage: ${u.state}${source}${period}${last}${why}.`;
+}
+/**
+ * The facts of the lead's retire card: who proposed it and why (the project
+ * view's decision: a person's retire candidate), the evidence, where it stands.
+ * When the decision that stands is another one (a conflict), the person whose
+ * retire still stands is named, with no words that are not theirs.
+ */
+export function retireFacts(o, v, at, of) {
+    const d = v?.decision;
+    const reason = shownReason(d?.reason?.text, CARD_REASON).replace(/[\s.]+$/, '');
+    const proposer = d && d.from === 'person' && d.what === 'retire-candidate' && d.by ? shown(d.by.name).trim() : '';
+    const standing = proposer ? '' : shown(d?.standing?.find((x) => x.what === 'retire-candidate')?.name ?? '').trim();
+    return [
+        ...(proposer ? [`Proposed by ${proposer}${reason ? `: ${reason}` : ''}.`] : standing ? [`Proposed by ${standing}.`] : []),
+        callersLine(o.evidence?.callers),
+        usageLine(o.evidence?.usage),
+        `Row ${at} of ${of}.`,
+    ];
+}
+/**
+ * Task 6 (B4): "Retire <NAME>?" [Yes] [Not yet], one card per candidate. Yes
+ * asks "What did you check?" and writes the lead's ruling with those words
+ * (`team rule <T> <N> retire --reason "…"`, run in process); nothing typed
+ * says so and shows the card again. Not yet puts it off for the session.
+ */
+async function retireCards(h, team, list, at, view) {
+    const ask = h.ask ?? journeyAsk();
+    // Round 1: the step it runs in (the report is step 6); DONE has no step, so no footnote.
+    const foot = stepOf(at) ? { footnote: footnote(at) } : {};
+    for (let i = 0; i < list.length; i++) {
+        const o = list[i];
+        const type = shown(o.type.toUpperCase());
+        const name = shown(o.name.toUpperCase());
+        const later = () => addJourneySkips(h.session, { retire: new Set([o.key]) });
+        let settled = false;
+        for (let tries = 0; tries < 5 && !settled; tries++) {
+            const res = await team.confirm({
+                id: 'journey-retire',
+                tag: 'QUESTION',
+                title: `Retire ${name}?`,
+                facts: retireFacts(o, view?.object(o.key), i + 1, list.length),
+                choices: [{ value: 'yes', label: 'Yes' }, { value: 'later', label: 'Not yet' }],
+                initial: 0,
+                aliases: { y: 'yes', n: 'later' },
+                ...foot,
+                wrapFacts: FACT_ROWS,
+            });
+            if (res.cancelled || res.value === null)
+                return 'cancel';
+            if (res.value === 'later') {
+                later();
+                settled = true;
+                continue;
+            }
+            let said;
+            try {
+                said = await ask(RETIRE_QUESTION);
+            }
+            catch {
+                return 'cancel';
+            }
+            const reason = cleanKeepReason(said);
+            if (!reason) {
+                h.emit(retireNeedsLine(type, name));
+                continue;
+            }
+            team.said.length = 0;
+            try {
+                ruleObject({ type: o.type, name: o.name, classification: 'retire', reason }, team.deps);
+                h.emit(`✓ Recorded: ${type} ${name} — retired, reason recorded.`);
+            }
+            catch (e) {
+                h.emit(notRecordedLine(e));
+                later();
+            }
+            settled = true;
+        }
+        if (!settled) {
+            later();
+            h.emit(`${name}: left for later.`);
+        }
+    }
+    return 'done';
+}
+/**
+ * R8: a project folder this laptop records into, read for the first time in
+ * the session or holding a baseline of more than 200 objects. Any other folder
+ * (no project, or someone else's) reads no register, so says nothing. Headless
+ * prints results only, as before.
+ */
+function slowRead(h, me) {
+    if (h.headless || folderKind(h.cwd, me).kind !== 'joined')
+        return false;
+    if (!folderReadThisSession(h.session, h.cwd))
+        return true;
+    try {
+        return readBaseline(h.cwd).length > READING_BIG;
+    }
+    catch {
+        return false;
+    }
+}
 async function drive(h) {
     const flow = getJourneyFlow(h.session);
     if (!flow)
@@ -497,10 +833,19 @@ async function drive(h) {
     let ranInventory = false;
     let saidInventory = false;
     let previous = '';
+    // G3: Yes on the skipped rows goes straight to the triage, without "Next 40?" first.
+    let reask = false;
+    let saidReading = false;
     for (let round = 0; round < 24; round++) {
         const me = whoAmI(team.deps);
         const skips = journeySkips(h.session);
+        // R8: the read below is where a cold or big project folder goes quiet. Said once a run.
+        if (!saidReading && slowRead(h, me)) {
+            h.emit(READING_LINE);
+            saidReading = true;
+        }
         const facts = readJourneyFacts(h.cwd, me, skips);
+        markFolderRead(h.session, h.cwd);
         const stage = stageOf(facts);
         setJourneyAt(h.session, stage);
         // Ctrl-C: what was measured is kept; "carry on" picks up from the folder.
@@ -518,6 +863,9 @@ async function drive(h) {
         let runAs = stage;
         let runSkips = skips;
         let startVariant;
+        let startTransport;
+        // Task 8 (B11): the start asked for its transport (the card, or headless: the line).
+        let transportAsked = false;
         let bigStart = false;
         if (!h.headless) {
             // Step 1 — "Look at the system?": no inventory yet, or one older than a week.
@@ -555,6 +903,13 @@ async function drive(h) {
             if (runAs === 'START') {
                 const scope = startScope(h.cwd, flow.packages);
                 if (scope) {
+                    // B1: who else works on it, asked at every start; Just me leaves the start card as it was.
+                    const people = await peopleCard(h, confirm, me, scope.names);
+                    if (!people) {
+                        end(h, NOT_STARTED_LINE);
+                        return;
+                    }
+                    setJourneyDevelopers(h.session, people.length ? [...people, 'me'] : undefined);
                     const n = scope.objects;
                     bigStart = n > FIRST_CHECK_WHOLE_MAX;
                     const yes = await yesNo(confirm, {
@@ -567,7 +922,7 @@ async function drive(h) {
                             'Saved in this folder.',
                             // Recording fix 5: the name every record is written under, seen before anything is written.
                             `You: ${shown(me)}.`,
-                            `You own all ${n.toLocaleString('en-US')}.`,
+                            ...(people.length ? people.map(shareFact) : [`You own all ${n.toLocaleString('en-US')}.`]),
                             'Writes nothing to SAP.',
                         ],
                         footnote: footnote('START'),
@@ -584,6 +939,17 @@ async function drive(h) {
                         return;
                     }
                     startVariant = chosen;
+                    // B11: which request holds the fixes — only where the session can read one from SAP.
+                    if (readsTransports(h, team)) {
+                        const request = await transportCard(h, confirm);
+                        if (request === null) {
+                            end(h, NOT_STARTED_LINE);
+                            return;
+                        }
+                        if (request)
+                            startTransport = request;
+                        transportAsked = true;
+                    }
                 }
             }
             // T7 review 1: nothing measured yet, and the scope is too big for one check — never
@@ -598,14 +964,19 @@ async function drive(h) {
             // 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.
-                const bad = toFix(facts.register, me, skips).filter((o) => refactorCommand({ type: o.type, name: o.name }) === null);
+                const view = facts.view ?? journeyView(facts.register);
+                // A name that is not an ABAP name, or an object the view does not hold, never reaches a card: one line, passed over.
+                const bad = toFix(facts.register, me, skips, view).map((o) => ({ o, line: fixPassOverLine(o, view) })).filter((x) => x.line !== null);
                 if (bad.length) {
-                    for (const o of bad)
-                        h.emit(passedOverLine(o.name));
-                    addJourneySkips(h.session, { fix: new Set(bad.map((o) => o.key)) });
+                    for (const x of bad)
+                        h.emit(x.line);
+                    addJourneySkips(h.session, { fix: new Set(bad.map((x) => x.o.key)) });
                     continue;
                 }
-                const pick = await fixCard(confirm, toFix(facts.register, me, skips), skips, (o) => stillOpenLines(o.key));
+                const pick = await fixCard(confirm, toFix(facts.register, me, skips, view), skips, view, (o, line) => {
+                    h.emit(line);
+                    addJourneySkips(h.session, { fix: new Set([o.key]) });
+                }, (o) => stillOpenLines(o.key));
                 if (pick.kind === 'cancel') {
                     pause(h, stepOf('FIX'));
                     return;
@@ -618,10 +989,53 @@ async function drive(h) {
                 if (pick.kind === 'yes')
                     runSkips = pick.skips;
             }
+            // Task 6 (B4) — at the report and at the end, the lead rules on each
+            // retire candidate: one card each. Then the stage derives again, so the
+            // report that follows shows the ruling. A developer never sees it.
+            if ((runAs === 'REPORT' || runAs === 'DONE') && facts.register && leadHere(team)) {
+                // Task 9 fix round 1: the view's candidates (active only, as every count says), never the register's flag.
+                const byKey = new Map(facts.register.objects.map((o) => [o.key, o]));
+                const view = facts.view ?? journeyView(facts.register);
+                const candidates = view.all.candidates.filter((v) => !skips.retire?.has(v.key)).map((v) => byKey.get(v.key)).filter((o) => !!o);
+                if (candidates.length) {
+                    if ((await retireCards(h, team, candidates, runAs, view)) === 'cancel') {
+                        pause(h, stepOf(runAs));
+                        return;
+                    }
+                    previous = '';
+                    continue;
+                }
+            }
+            // G3 — before DONE: the rows skipped this session, still undecided, asked about once.
+            // Once a run (the flag lives on the flow): "Later" on "Next 40?" counts as asked.
+            if (runAs === 'DONE' && facts.view && !getJourneyFlow(h.session)?.skippedAsked) {
+                const skipped = skippedRows(facts.view, me, skips);
+                if (skipped) {
+                    markSkippedAsked(h.session);
+                    const res = await confirm({
+                        id: 'journey-skipped',
+                        tag: 'QUESTION',
+                        title: `Look at the ${plural(skipped, 'row', 'rows')} you skipped?`,
+                        choices: [{ value: 'yes', label: 'Yes' }, { value: 'later', label: 'Later' }],
+                        initial: 0,
+                        aliases: { y: 'yes', l: 'later' },
+                        footnote: footnote('DECIDE'),
+                    });
+                    if (res.cancelled || res.value === null) {
+                        pause(h, stepOf('DECIDE'));
+                        return;
+                    }
+                    if (res.value === 'yes') {
+                        forgetSkippedRows(h.session);
+                        reask = true;
+                        continue;
+                    }
+                }
+            }
             // 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());
+                const groups = rebuildGroups(toRedesign(facts.register, me, facts.view), skips.rebuild, rulesReader(), (key) => facts.view?.object(key)?.target);
                 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)
@@ -649,9 +1063,11 @@ async function drive(h) {
                 }
             }
             // 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);
-                const next = decidePage(facts.register, me, skips).length;
+            if (runAs === 'DECIDE' && reask)
+                reask = false;
+            else if (runAs === 'DECIDE' && facts.register && (getJourneyFlow(h.session)?.pages ?? 0) > 0) {
+                const left = toDecide(facts.register, me, skips, facts.view);
+                const next = decidePage(facts.register, me, skips, facts.view).length;
                 const res = await confirm({
                     id: 'journey-next-page',
                     tag: 'QUESTION',
@@ -669,15 +1085,23 @@ async function drive(h) {
                 if (res.value === 'later') {
                     // Left out, not skipped: "carry on" brings them back to deciding.
                     addJourneyLeftOut(h.session, left.map((o) => o.key));
+                    markSkippedAsked(h.session);
                     h.emit('Left for later.');
                     continue;
                 }
             }
         }
+        const developers = runAs === 'START' ? getJourneyFlow(h.session)?.developers : undefined;
         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 } : {}),
+            ...(developers ? { developers: [...developers] } : {}),
+            ...(startTransport ? { transport: startTransport } : {}),
+            // Headless shows no card: where the card would be asked, the start says the transport as a line.
+            ...(transportAsked || (h.headless && runAs === 'START' && readsTransports(h, team)) ? { transportAsked: true } : {}),
+            // B8: the DONE summary knows what the last DONE of this session summed up (headless: as before).
+            ...(h.headless ? {} : { session: h.session }),
         });
         if (runAs === 'INVENTORY')
             ranInventory = true;
@@ -705,18 +1129,18 @@ async function drive(h) {
             }
             const skill = /^\/(\S+)/.exec(command)[1];
             if (runAs === 'DECIDE') {
-                setJourneyQueued(h.session, { command, skill, stage: 'DECIDE', left: facts.register ? toDecide(facts.register, me, skips).length : 0 });
+                setJourneyQueued(h.session, { command, skill, stage: 'DECIDE', left: facts.register ? toDecide(facts.register, me, skips, facts.view).length : 0 });
                 // The page the triage is shown (team_findings reads it): at most 40, in the queued area.
-                setJourneyPage(h.session, facts.register ? decidePage(facts.register, me, skips).map((o) => o.key) : []);
+                setJourneyPage(h.session, facts.register ? decidePage(facts.register, me, skips, facts.view).map((o) => o.key) : []);
             }
             else {
                 const key = r.next.key;
-                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)) });
+                setJourneyQueued(h.session, { command, skill, stage: 'FIX', ...(key ? { key } : {}), callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd), ...targetFor(key ? facts.view?.object(key) : undefined) });
             }
             queueStep(h, command);
             return;
         }
-        end(h); // stop or done: the runner said its last words
+        end(h, undefined, r.next.kind === 'done'); // stop or done: the runner said its last words
         return;
     }
     pause(h);
@@ -741,9 +1165,9 @@ export async function afterJourneyTurn(h, t) {
     const stage = stageOf(facts);
     let moved = stage !== q.stage;
     if (!moved && facts.register && q.stage === 'DECIDE')
-        moved = toDecide(facts.register, me, skips).length < (q.left ?? Number.MAX_SAFE_INTEGER);
+        moved = toDecide(facts.register, me, skips, facts.view).length < (q.left ?? Number.MAX_SAFE_INTEGER);
     if (!moved && facts.register && q.stage === 'FIX')
-        moved = !toFix(facts.register, me).some((o) => o.key === q.key);
+        moved = !toFix(facts.register, me, {}, facts.view).some((o) => o.key === q.key);
     if (!moved) {
         if (/\?\s*$/.test(t.assistantText.trim()))
             return;
@@ -755,10 +1179,10 @@ 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);
-        // Proof first: a fix with nothing open for its own target is not offered again.
-        if (o && fixFailedCheck(o) && !claimedSinceCheck(o) && !provenForTarget(o)) {
+        // Proof first: the view's part — a fix proven for its own target, or claimed again since, is not offered again.
+        if (o && facts.view?.object(o.key)?.part === 'failed-check') {
             setJourneyQueued(h.session, undefined);
-            const goOn = await retryCard(h, team, o);
+            const goOn = await retryCard(h, team, o, facts.view?.object(o.key));
             if (!goOn)
                 return;
             try {
@@ -796,7 +1220,7 @@ export async function afterJourneyTurn(h, t) {
  * Returns true when the chain goes on from the folder (drive), false when it
  * stopped or a command was queued.
  */
-async function retryCard(h, team, o) {
+async function retryCard(h, team, o, v) {
     const name = o.name.toUpperCase();
     const type = o.type.toUpperCase();
     const level = o.decision?.level && LEVEL.test(o.decision.level) ? o.decision.level : undefined;
@@ -839,7 +1263,7 @@ 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), ...targetFor(o) });
+            setJourneyQueued(h.session, { command, skill: 'abap-refactor', stage: 'FIX', key: o.key, callsAt: toolCallsOf(h.session).length, variant: projectVariant(h.cwd), ...targetFor(v) });
             queueStep(h, command);
             return false;
         }
@@ -929,6 +1353,10 @@ export function journeyFixBlock(variant, target) {
         "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.`] : []),
+        // Task 7 — the approval card shows what callers or users will see differently.
+        "On the approval request, fill changes[].behaviour for every change: what callers or users will see differently, or 'none'.",
+        // Task 7 (R2) — the card's risk line is CSPeach's reading; the model relays it.
+        RISK_NOTE,
         `After you activate the object, run ATC on it with the variant ${v}, not the default one.`,
         // Final review M4: with a target other than A, findings that only matter for A may stay.
         t && t !== 'A'