@cspeach/cli 1.1.48 → 1.1.50

package/dist/projects/clean-core-confirm.js

@@ -1,47 +1,58 @@
 import { shown, shownUpTo } from '../register/atc-file.js';
+import { withoutRuleId } from '../register/records.js';
 import { STEPS, stepOf } from '../journey/clean-core.js';
-const WORD = {
-    keep: 'keep', exception: 'accepted exception', fix: 'fix', rebuild: 'rebuild beside the core', retire: 'retire',
-};
-export function rowWords(r) {
-    const parts = [WORD[r.disposition]];
-    if (r.level)
-        parts.push(`level ${r.level}`);
-    // Step 2 (F3): a target is said only when the proposal named one; the record keeps the legacy A, which is no target.
-    if (r.disposition === 'fix' || r.disposition === 'rebuild')
-        parts.push(r.targetLevel ? `target ${r.targetLevel}` : 'no target set');
-    return `${parts.join(', ')}${r.reason ? `, because: ${r.reason}` : ''}`;
+import { proposalOf, viewWords } from '@cspeach/register-core';
+const NO_TARGET = { level: null, from: 'none', by: null };
+/**
+ * The row in words: the project view's proposal words (project view Task 5),
+ * then the proposal's reason. The card never says the target the model
+ * proposed — a Yes does not set one. It says the object's target as the view
+ * reads it (`team decide --target`, or the lead's `team target`), else "no target set".
+ */
+export function rowWords(r, target) {
+    return `${viewWords.proposal(proposalOf(r), target ?? NO_TARGET)}${r.reason ? `, because: ${r.reason}` : ''}`;
 }
+async function retireYes(r, reason, w) {
+    if (w.lead === true && w.rule) {
+        try {
+            await w.rule({ type: r.objectType.trim().toUpperCase(), name: r.objectName.trim().toUpperCase(), reason });
+            return { kind: 'ruled' };
+        }
+        catch (e) {
+            return { kind: 'failed', line: `Not recorded for ${shown(r.objectType)} ${shown(r.objectName)}: ${shownUpTo(e instanceof Error ? e.message : String(e), 200)}` };
+        }
+    }
+    return { kind: 'candidate', reason };
+}
+const ruledLine = (type, name) => `✓ Recorded: ${type} ${name} — retired, reason recorded.`;
+const candidateLine = (type, name) => `✓ Recorded: ${type} ${name} — retire candidate, your reason recorded.`;
 const DECIDE_HINT = 'cspeach team decide <TYPE> <NAME> <decision>';
-/** What a recorded reason keeps (records.ts). */
-const MAX_ROW_REASON = 300;
 const RULE_ROW = {
     keep: 'keep', fix: 'fix', rebuild: 'rebuild', 'retire-candidate': 'retire',
 };
-/** A "Rule <id>: " the reason starts with — written by the model, so code checks it. */
-const RULE_PREFIX = /^\s*rule\s+[A-Za-z0-9_-]{1,20}\s*:\s*/i;
+/** The fact a row that agrees with its rule carries: the rule is said by its note, never as an id inside the reason. */
+export const matchesRuleLine = (note) => `Matches your rule: ${note}`;
 /**
- * The row read against the rule that decides its object. Agrees (same
- * disposition): the reason starts "Rule <id>: " (the rule's note when the row
- * gave none). Differs: the row stays the model's, and `differs` is the fact
- * line "Differs from rule <id>: <why>". No rule: a "Rule <id>:" the model
- * wrote is taken off — the row is CSPeach's judgement. The person still
+ * The row read against the rule that decides its object. The reason is always
+ * the proposal's own words: a "Rule <id>:" the model wrote is taken off, and
+ * no rule id is put in (project view Task 4 — the recorded reason is the
+ * proposal's text, marked as such). Agrees (same disposition): `matches` is
+ * the fact line "Matches your rule: <note>". Differs: `differs` is the fact
+ * line "Differs from rule <id>: <why>". No rule: neither. The person still
  * answers the card either way.
  */
 export function ruleRow(r, p) {
-    const own = (r.reason ?? '').replace(RULE_PREFIX, '').trim();
+    const own = withoutRuleId(r.reason ?? '').trim();
+    const row = own === r.reason ? r : { ...r, reason: own };
     if (!p)
-        return { row: own === r.reason ? r : { ...r, reason: own } };
-    const id = shown(p.ruleId);
+        return { row };
     const why = shownUpTo(p.why, 200);
     // Agrees = same disposition, and the same target when the rule itself names one (owner ruling, review 9 #7).
     const targetDiffers = p.targetFrom === 'rule' && p.target !== undefined && r.targetLevel !== p.target;
     if (RULE_ROW[p.disposition] !== r.disposition || targetDiffers) {
-        return { row: own === r.reason ? r : { ...r, reason: own }, differs: `Differs from rule ${id}: ${why}` };
+        return { row, differs: `Differs from rule ${shown(p.ruleId)}: ${why}` };
     }
-    // Prefix + reason stay within the 300 the record keeps (records.ts would cut the end); cut by code point.
-    const head = `Rule ${id}: `;
-    return { row: { ...r, reason: head + Array.from(own || why).slice(0, Math.max(0, MAX_ROW_REASON - head.length)).join('') } };
+    return { row, matches: matchesRuleLine(why) };
 }
 export async function confirmCleanCoreRows(ex, a) {
     if (!a.joined) {
@@ -54,12 +65,56 @@ export async function confirmCleanCoreRows(ex, a) {
         return ex;
     }
     const rows = [];
+    let ruled = 0;
     for (const given of ex.content.adjudications) {
-        const { row: r, differs } = a.rules ? ruleRow(given, a.rules(keyOf(given))) : { row: given, differs: undefined };
-        const answer = await a.confirm(`Record ${r.objectType} ${r.objectName}: ${rowWords(r)}?${differs ? ` (${differs})` : ''}`, { default: 'n' });
-        rows.push({ ...r, confirmed: answer === 'y' });
+        const { row: r, differs, matches } = a.rules ? ruleRow(given, a.rules(keyOf(given))) : { row: given, differs: undefined, matches: undefined };
+        const note = differs ?? matches;
+        const question = `Record ${r.objectType} ${r.objectName}: ${rowWords(r, a.targets?.(keyOf(r)))}?${note ? ` (${note})` : ''}`;
+        if (r.disposition !== 'retire') {
+            const answer = await a.confirm(question, { default: 'n' });
+            // A Yes accepts the proposal's words (project view §3.2): marked so, never as the person's.
+            rows.push(answer === 'y' ? { ...r, reasonBy: 'proposal', confirmed: true } : { ...r, confirmed: false });
+            continue;
+        }
+        // Task 6 round 1 (B4): a retire Yes asks what the person checked; the model's words are never recorded.
+        let done = { ...r, confirmed: false };
+        for (let tries = 0; tries < 5; tries++) {
+            if ((await a.confirm(question, { default: 'n' })) !== 'y')
+                break;
+            let said = '';
+            if (a.ask) {
+                try {
+                    said = await a.ask(RETIRE_QUESTION);
+                }
+                catch {
+                    said = '';
+                }
+            }
+            const reason = cleanKeepReason(said);
+            if (!reason) {
+                a.log(retireNeedsLine(shown(r.objectType), shown(r.objectName)));
+                if (!a.ask)
+                    break; // nothing can ask: never the same card over and over
+                continue;
+            }
+            const out = await retireYes(r, reason, a);
+            if (out.kind === 'failed') {
+                a.log(out.line);
+                break;
+            }
+            if (out.kind === 'ruled') {
+                ruled += 1;
+                a.log(ruledLine(shown(r.objectType), shown(r.objectName)));
+                break;
+            }
+            done = { ...r, reason: out.reason, reasonBy: 'person', confirmed: true };
+            a.log(candidateLine(shown(r.objectType), shown(r.objectName)));
+            break;
+        }
+        rows.push(done);
     }
-    const yes = rows.filter((r) => r.confirmed).length;
+    // A ruling is recorded too (in the lead's own folder), so it counts as confirmed.
+    const yes = rows.filter((r) => r.confirmed).length + ruled;
     a.log(`${yes} of ${rows.length} rows confirmed. To record a row differently: ${DECIDE_HINT}`);
     const byId = new Map(rows.map((r) => [r.id, r.confirmed]));
     return {
@@ -69,6 +124,10 @@ export async function confirmCleanCoreRows(ex, a) {
     };
 }
 export const KEEP_QUESTION = 'Why keep it?';
+/** Task 6 (B4): asked on a retire row's Yes, and on the lead's retire card. */
+export const RETIRE_QUESTION = 'What did you check?';
+/** A retire Yes with nothing typed: nothing is recorded, and the card comes again. */
+export const retireNeedsLine = (type, name) => `A retire needs what you checked. Nothing was recorded for ${type} ${name} yet.`;
 /** "Yes to the remaining n shown" is offered once this many rows are answered. */
 const OFFER_REST_AFTER = 3;
 const MAX_KEEP_REASON = 300;
@@ -81,31 +140,44 @@ export function cleanKeepReason(raw) {
     return Array.from(shownUpTo(raw ?? '', Number.POSITIVE_INFINITY)).slice(0, MAX_KEEP_REASON).join('').trim();
 }
 /** The proposal in words, without the reason (the reason is a fact line on the card). */
-function proposalWords(r) {
-    return rowWords({ ...r, reason: '' });
+function proposalWords(r, target) {
+    return rowWords({ ...r, reason: '' }, target);
 }
 export async function decideCleanCoreRows(ex, j) {
     const all = ex.content.adjudications;
-    const ruled = all.map((r) => (j.rules ? ruleRow(r, j.rules(keyOf(r))) : { row: r, differs: undefined }));
+    const ruled = all.map((r) => (j.rules ? ruleRow(r, j.rules(keyOf(r))) : { row: r, differs: undefined, matches: undefined }));
     const rows = ruled.map(({ row }) => ({ ...row, confirmed: false }));
-    const tally = { total: all.length, yes: [], kept: [], skipped: [], cancelled: false };
+    const tally = { total: all.length, yes: [], kept: [], skipped: [], cancelled: false, ruled: [], candidates: [] };
     const footnote = `Step ${stepOf('DECIDE')} of ${STEPS}`;
+    const isRetire = (r) => r.disposition === 'retire';
+    /** "Yes to the remaining n shown" said: the rows that are not a retire are recorded as proposed; each retire is still asked. */
+    let restYes = false;
     let answered = 0;
     rowLoop: for (let i = 0; i < rows.length; i++) {
         const r = rows[i];
+        // Recorded already, when "Yes to the remaining n" was said.
+        if (restYes && !isRetire(r))
+            continue;
         const type = shown(r.objectType);
         const name = shown(r.objectName);
-        const left = rows.length - i;
+        // Task 6: "the remaining n" counts only what it records — a retire is always asked on its own.
+        const left = rows.slice(i).filter((x) => !isRetire(x)).length;
         const why = shownUpTo(r.reason ?? '', MAX_KEEP_REASON);
         let canKeep = true;
         let settled = false;
         for (let tries = 0; tries < 20 && !settled; tries++) {
-            const offerRest = answered >= OFFER_REST_AFTER && left >= 2;
+            const offerRest = !restYes && answered >= OFFER_REST_AFTER && left >= 2;
             const res = await j.card({
                 id: 'journey-row',
                 tag: 'QUESTION',
-                title: `Record ${type} ${name}: ${proposalWords({ ...r, objectType: type, objectName: name })}?`,
-                facts: [...(why ? [`Why: ${why}`] : []), ...(ruled[i].differs ? [ruled[i].differs] : []), `Row ${i + 1} of ${rows.length}.`],
+                // Project view Task 5: what was proposed, in the view's words; the reason is the proposal's, never the person's.
+                title: `Record ${type} ${name} as proposed: ${proposalWords({ ...r, objectType: type, objectName: name }, j.targets?.(keyOf(r)))}?`,
+                facts: [
+                    ...(why ? [viewWords.cardReason({ text: why, from: 'proposal' })] : []),
+                    ...(ruled[i].differs ? [ruled[i].differs] : []),
+                    ...(ruled[i].matches ? [ruled[i].matches] : []),
+                    `Row ${i + 1} of ${rows.length}.`,
+                ],
                 choices: [
                     { value: 'yes', label: 'Yes' },
                     ...(canKeep ? [{ value: 'keep', label: 'Keep as is' }] : []),
@@ -123,14 +195,55 @@ export async function decideCleanCoreRows(ex, j) {
                 break rowLoop;
             }
             if (res.value === 'all' && offerRest) {
+                // Round 1: every row from here that is not a retire is recorded now, so a card put away later keeps them.
+                restYes = true;
                 for (let k = i; k < rows.length; k++) {
-                    rows[k] = { ...rows[k], confirmed: true };
+                    if (isRetire(rows[k]))
+                        continue;
+                    rows[k] = { ...rows[k], reasonBy: 'proposal', confirmed: true };
                     tally.yes.push(keyOf(rows[k]));
                 }
-                break rowLoop;
+                // This row is a retire: its own card again, without the offer.
+                if (isRetire(r))
+                    continue;
+                settled = true;
+                continue;
+            }
+            if (res.value === 'yes' && isRetire(r)) {
+                // Task 6 (B4): what the person checked is the reason recorded — never the model's words.
+                let said;
+                try {
+                    said = await j.ask(RETIRE_QUESTION);
+                }
+                catch {
+                    tally.cancelled = true;
+                    break rowLoop;
+                }
+                const reason = cleanKeepReason(said);
+                if (!reason) {
+                    j.log(retireNeedsLine(type, name));
+                    continue;
+                }
+                // The lead's Yes is the ruling; the row stays unconfirmed, so no writer row is added.
+                const out = await retireYes(r, reason, j);
+                if (out.kind === 'failed') {
+                    j.log(out.line);
+                    tally.skipped.push(keyOf(r));
+                    j.skip([keyOf(r)]);
+                }
+                else if (out.kind === 'ruled') {
+                    tally.ruled.push(keyOf(r));
+                }
+                else {
+                    rows[i] = { ...r, reason: out.reason, reasonBy: 'person', confirmed: true };
+                    tally.yes.push(keyOf(r));
+                    tally.candidates.push(keyOf(r));
+                }
+                settled = true;
+                continue;
             }
             if (res.value === 'yes') {
-                rows[i] = { ...r, confirmed: true };
+                rows[i] = { ...r, reasonBy: 'proposal', confirmed: true };
                 tally.yes.push(keyOf(r));
                 settled = true;
                 continue;
@@ -160,7 +273,7 @@ export async function decideCleanCoreRows(ex, j) {
                     j.log(`A keep needs a reason. Nothing was recorded for ${type} ${name} yet.`);
                     continue;
                 }
-                rows[i] = { ...r, disposition: 'exception', targetLevel: null, reason, confirmed: true };
+                rows[i] = { ...r, disposition: 'exception', targetLevel: null, reason, reasonBy: 'person', confirmed: true };
                 tally.kept.push({ key: keyOf(r), type: r.objectType.toUpperCase(), name: r.objectName.toUpperCase(), level: r.level });
                 settled = true;
             }
@@ -191,9 +304,18 @@ export async function decideCleanCoreRows(ex, j) {
 export function journeyRowLines(t, refused) {
     const out = new Set(refused.map((k) => k.trim().toUpperCase()));
     const kept = t.kept.filter((k) => !out.has(k.key));
-    const yes = t.yes.filter((k) => !out.has(k.toUpperCase())).length;
+    const ruled = t.ruled ?? [];
+    const candidates = (t.candidates ?? []).filter((k) => !out.has(k.toUpperCase()));
+    // A ruling is recorded too (in the lead's own folder; never refused here).
+    const yes = t.yes.filter((k) => !out.has(k.toUpperCase())).length + ruled.length;
+    const said = (key) => {
+        const [type = '', name = ''] = key.split('|');
+        return [shown(type), shown(name)];
+    };
     return [
         ...kept.map((k) => `✓ Recorded: ${shown(k.type)} ${shown(k.name)} — kept at ${k.level}, reason recorded.`),
+        ...ruled.map((k) => ruledLine(...said(k))),
+        ...candidates.map((k) => candidateLine(...said(k))),
         `${yes} of ${t.total} rows recorded; ${kept.length} kept by decision; ${t.skipped.length} skipped.`,
     ];
 }

package/dist/projects/extract-cca.js

@@ -1,8 +1,8 @@
 /**
  * Parser for the `<!-- csforge:cca-manifest ... -->` block that
- * /abap-cca and /abap-cca-merge emit at the end of their markdown
- * output. Hidden from human renderers, structured enough for a
- * deterministic extractor.
+ * /abap-cca emitted at the end of its markdown output (an old saved one
+ * still loads; the register reads it for decision records). Hidden from
+ * human renderers, structured enough for a deterministic extractor.
  *
  * Format mirrors the upgrade-manifest pattern (see extract-upgrade.ts):
  *
@@ -104,9 +104,10 @@ function asConfidence(raw) {
 /**
  * Parse the optional 6th table cell on a merged row:
  *   `conflict=<label>:<cls>;<label>:<cls>`
- * (rendered by merge-cca.ts:renderCcaMergeManifest). Returns undefined
- * for absent / unrecognisable cells; invalid classification values are
- * skipped pair-wise so one typo doesn't drop the whole record.
+ * (rendered by the former merge-cca.ts, cut 2026-10-20; files it saved
+ * still load). Returns undefined for absent / unrecognisable cells;
+ * invalid classification values are skipped pair-wise so one typo
+ * doesn't drop the whole record.
  */
 function parseConflictCell(raw) {
     if (!raw)
@@ -165,7 +166,7 @@ export function extractCcaAssessment(markdown) {
     // Battery S4 caught manifests whose counts contradicted their own rows
     // (`retire: 0` next to 7 retire rows) and tables silently truncated
     // (27/104 rows, no marker). These manifests are CHAIN INPUT for
-    // /abap-cca-merge — a quiet save corrupts the consolidated estate
+    // the register's decision records — a quiet save corrupts the estate
     // numbers, so a contradiction fails the extract LOUDLY instead (same
     // philosophy as extract-plan's loud-failure path in save-command.ts).
     const truncated = kv.classifications_truncated === 'true';

package/dist/projects/index.js

@@ -6,7 +6,6 @@ export { canonicalSha256 } from './canonicalize.js';
 export { titleSlug, shortId, projectFilename } from './filename.js';
 export { runSaveCommand, detectArtifactSkill, peekPlanManifestTitle, resolvePriorPlanEnvelope } from './save-command.js';
 export { offerAnswerBlockers, openBlockers, applyBlockerAnswers } from './answer-blockers.js';
-export { mergeCcaAssessments, renderCcaMergeManifest, parseScopePatterns, scopePatternsIntersect, CCA_MANIFEST_ROW_CAP } from './merge-cca.js';
 export { mergeUpgradeProgress, renderUpgradeMergeManifest } from './merge-upgrade.js';
 export { extractDesign } from './extract-design.js';
 export { extractEstimate } from './extract-estimate.js';

package/dist/projects/merge-upgrade.js

@@ -3,8 +3,8 @@
  * into ONE consolidated upgrade-progress (the /abap-upgrade-merge
  * skill's engine).
  *
- * WHY CODE, NOT PROSE: see merge-cca.ts header — battery S4 (defects
- * D6/D7) showed the model cannot keep counts and rows consistent when
+ * WHY CODE, NOT PROSE: battery S4 (docs/research/battery/
+ * s4-cca-scorecard.md, defects D6/D7) showed the model cannot keep counts and rows consistent when
  * reconciling envelopes by hand. This module owns the arithmetic.
  *
  * Rules implemented (mirrors .claude/skills/abap-upgrade-merge/SKILL.md):

package/dist/projects/project-folder.js

@@ -25,7 +25,8 @@ const real = (p) => { try {
 catch {
     return path.resolve(p);
 } };
-const key = (p) => { const r = real(p).replace(/[\\/]+$/, ''); return process.platform === 'win32' ? r.toLowerCase() : r; };
+/** A folder as the file system opens it: links followed, no trailing separator, case-folded on Windows. */
+export const key = (p) => { const r = real(p).replace(/[\\/]+$/, ''); return process.platform === 'win32' ? r.toLowerCase() : r; };
 /** The team project id when `cwd` holds a valid cspeach-team.json, else null. */
 export function teamProjectId(cwd) {
     try {

package/dist/projects/save-command.js

@@ -72,14 +72,6 @@ const SKILL_REGISTRY = {
         itemNoun: 'classifications',
         manifestMarker: 'cca-manifest',
     },
-    'abap-cca-merge': {
-        // Merge produces a NEW cca-assessment (consolidated) — same shape as
-        // a single consultant's slice, just reconciled across N parallel reviews.
-        artefactType: 'cca-assessment',
-        extract: (md) => extractCcaAssessment(md),
-        itemNoun: 'classifications',
-        manifestMarker: 'cca-manifest',
-    },
     'abap-modernize': {
         artefactType: 'modernize-result',
         extract: (md) => extractModernizeResult(md),
@@ -314,8 +306,8 @@ export async function runSaveCommand(args) {
         // extractor throws, and bailing here would silently lose an artifact that
         // carries a complete, recognizable manifest. If the manifest resolves to
         // a DIFFERENT registry skill, retry the save under that skill. Skipped
-        // when both skills share the same manifest-marker family (abap-cca-merge
-        // ↔ abap-cca, abap-upgrade-merge ↔ abap-upgrade-fix): the family
+        // when both skills share the same manifest-marker family
+        // (abap-upgrade-merge ↔ abap-upgrade-fix): the family
         // extractor already ran and failed, and re-dispatching would only launder
         // merge provenance onto the non-merge skill — keep the label's failure.
         const detected = detectArtifactSkill(args.skillOutput);
@@ -401,7 +393,9 @@ export async function runSaveCommand(args) {
     // the row cards go through `confirm` only (never `prompt`), and a headless
     // run confirms no row. Any further question routed through `prompt` would
     // silently receive 'y' too: give maybeOfferSave's headless prompt a
-    // question-aware answer first.
+    // question-aware answer first. (Task 6 round 1: a retire row's "What did
+    // you check?" uses `prompt`, but only when `confirm` is given — which
+    // maybeOfferSave never does headless — so the blanket 'y' never reaches it.)
     // Inside a journey a triage is saved without the question: the journey needs the rows.
     const journey = spec.artefactType === 'clean-core-decision' ? args.journey : undefined;
     const answer = journey ? 'y' : await askYesNo({ question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt });
@@ -412,6 +406,8 @@ export async function runSaveCommand(args) {
     // 2026-10-06 — a clean-core triage becomes team project decisions only row by
     // row, each on its own Yes. Without a joined team project nothing is asked.
     let tally;
+    /** Task 6: rulings the lead's retire Yes wrote during this save (no writer row beside them). */
+    let ruledHere = 0;
     if (spec.artefactType === 'clean-core-decision') {
         const { confirmCleanCoreRows, decideCleanCoreRows } = await import('./clean-core-confirm.js');
         const { activeProject } = await import('../register/store.js');
@@ -433,10 +429,48 @@ export async function runSaveCommand(args) {
                 rules = () => null;
             }
         }
+        // Task 6 (B4): the lead's retire Yes is the ruling `team rule` writes, run in process —
+        // on the journey's row cards and on the Yes/No cards alike. Unreadable project file →
+        // not the lead: a retire stays a candidate. Round 1: the card says the object's
+        // target as the project view reads it (a person or the lead set it), never the
+        // model's; unreadable → "no target set".
+        let retire = {};
+        let targets;
+        if (project) {
+            const { isLead, ruleObject } = await import('../commands/team.js');
+            const teamDeps = { print: () => { }, identity: () => ({ name: project.name ?? args.author.name }) };
+            try {
+                const { readProjectFile } = await import('../register/store.js');
+                if (isLead(readProjectFile(project.projectDir), teamDeps)) {
+                    retire = {
+                        lead: true,
+                        rule: async (x) => {
+                            ruleObject({ type: x.type, name: x.name, classification: 'retire', reason: x.reason }, teamDeps);
+                            ruledHere += 1;
+                        },
+                    };
+                }
+            }
+            catch {
+                retire = {};
+            }
+            try {
+                // Project view Task 5: the view is built once here and answers each card's target.
+                const { registerFor } = await import('../register/picture.js');
+                const { readProjectFile } = await import('../register/store.js');
+                const { projectView } = await import('@cspeach/register-core');
+                const view = projectView(registerFor(project.projectDir, project.outboxDir).register, readProjectFile(project.projectDir));
+                targets = (key) => view.object(key.trim().toUpperCase())?.target;
+            }
+            catch {
+                targets = undefined;
+            }
+        }
         if (journey && joined) {
             // Guided journey: [Yes] [Keep as is] [Skip] per row.
             const r = await decideCleanCoreRows(extract, {
                 card: journey.card, ask: journey.ask, skip: journey.skip, log: args.log, ...(rules ? { rules } : {}),
+                ...retire, ...(targets ? { targets } : {}),
             });
             extract = r.extract;
             tally = r.tally;
@@ -449,7 +483,9 @@ export async function runSaveCommand(args) {
             }
             else {
                 extract = await confirmCleanCoreRows(extract, {
-                    ...(args.confirm ? { confirm: args.confirm } : {}), log: args.log, joined, ...(rules ? { rules } : {}),
+                    // B5: the free-text "What did you check?" goes with `confirm` only — never the headless blanket-'y' prompt.
+                    ...(args.confirm ? { confirm: args.confirm, ask: args.prompt } : {}), log: args.log, joined, ...(rules ? { rules } : {}),
+                    ...retire, ...(targets ? { targets } : {}),
                 });
             }
         }
@@ -540,7 +576,8 @@ export async function runSaveCommand(args) {
             }
             else if (res?.file)
                 args.log(`Recorded for team project ${joined.projectId}: ${res.written} objects → ${basename(res.file)}`);
-            if (res?.file) {
+            // A ruling made on a row card changes the list too, with no writer row beside it (Task 6).
+            if (res?.file || ruledHere > 0) {
                 const { regenerateWorkingList } = await import('../register/workbooks.js');
                 // The name the team project knows this laptop by (init --lead), as the team verbs use.
                 const sheet = regenerateWorkingList(joined, joined.name ?? args.author.name);
@@ -578,7 +615,7 @@ export async function runSaveCommand(args) {
         else if (journey.page?.length) {
             // One triage per page: a row of the page the triage left out is put off
             // until "carry on", so the journey moves on instead of asking it again — and says so.
-            const answered = new Set([...tally.yes, ...tally.kept.map((k) => k.key), ...tally.skipped]);
+            const answered = new Set([...tally.yes, ...tally.kept.map((k) => k.key), ...tally.skipped, ...tally.ruled]);
             const left = journey.page.filter((k) => !answered.has(k.toUpperCase()));
             if (left.length) {
                 journey.leaveForLater(left);

package/dist/projects/workspace.js

@@ -606,6 +606,8 @@ function shortHint(filename) {
  * char boundary because we slice the decoded string, not the bytes.
  */
 const MAX_TEXT_FILE_CHARS = 64 * 1024;
+/** The note after a cut attachment (also refused in SAP writes: tools/cut-markers.ts). */
+export const ATTACHMENT_TRUNCATED_NOTE = '... [truncated, file exceeds 64 KB]';
 /**
  * Scan `userMessage` for `@<token>` references that resolve to .txt /
  * .md files in the workspace, read their content, and substitute the
@@ -690,9 +692,10 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
             try {
                 const buf = readFileSync(path);
                 const ext = path.toLowerCase().endsWith('.pdf') ? '.pdf' : '.docx';
-                const { extractDocument } = await import('../tools/filesystem/extract-document.js');
+                const { extractDocument, splitLongLines, DOC_MAX_LINE_CHARS } = await import('../tools/filesystem/extract-document.js');
                 const res = await extractDocument(buf, ext, { maxPages: 150 });
-                content = res.text;
+                // 2026-10-22 — long lines split as in read_document; the 64 KB cap below is the total.
+                content = splitLongLines(res.text, DOC_MAX_LINE_CHARS);
                 if (log)
                     for (const w of res.warnings)
                         log(`(${filename}: ${w})`);
@@ -714,7 +717,7 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
             }
         }
         if (content.length > MAX_TEXT_FILE_CHARS) {
-            content = content.slice(0, MAX_TEXT_FILE_CHARS) + '\n... [truncated, file exceeds 64 KB]';
+            content = content.slice(0, MAX_TEXT_FILE_CHARS) + '\n' + ATTACHMENT_TRUNCATED_NOTE;
         }
         const replacement = `<attached file="${filename}">\n${content}\n</attached>`;
         substitutions.push({ index, matchLen: match.length, replacement });

package/dist/register/decision-rules.js

@@ -2,7 +2,8 @@
  * Decision rules for the joined team project (step 2, D6): which rule decides
  * each object, read from the same register and findings team_findings shows,
  * with the project's own rules or the defaults. The row cards use it to say
- * "Rule <id>: …" or "Differs from rule <id>: …". Read only; never writes the
+ * "Matches your rule: <note>" or "Differs from rule <id>: …" (never a rule id
+ * inside a recorded reason, project view Task 4). Read only; never writes the
  * rules to the file.
  */
 import { evaluateRules, readDecisionRules } from '@cspeach/register-core';

package/dist/register/export-files.js

@@ -9,6 +9,7 @@
  * — set by `cspeach team export --always` or the journey's report card. No
  * hidden state. Default off.
  */
+import fs from 'node:fs';
 import path from 'node:path';
 import { csvText, exportSet } from '@cspeach/register-core';
 import { HELD } from './workbooks.js';
@@ -21,6 +22,23 @@ export function exportsOn(project) {
     const e = project.exports;
     return !!e && typeof e === 'object' && e.csv === true;
 }
+/** True only when the switch was turned off on purpose (`team export --never`): files already there stay as they are. */
+export function exportsOff(project) {
+    const e = project.exports;
+    return !!e && typeof e === 'object' && e.csv === false;
+}
+/**
+ * G5: an export already in `dir` (its manifest.json is there). A report then
+ * rewrites it, so the CSV files a person's tools read never go stale.
+ */
+export function exportsPresent(dir) {
+    try {
+        return fs.statSync(path.join(dir, 'manifest.json')).isFile();
+    }
+    catch {
+        return false;
+    }
+}
 /** Set the switch on or off: the whole project file, then renamed. Every other field stays as it is. */
 export function setExports(projectDir, on) {
     const project = readProjectFile(projectDir);

package/dist/register/picture.js

@@ -1,14 +1,14 @@
 import path from 'node:path';
 import { buildRegister, narrowedLanes } from '@cspeach/register-core';
 import { collectRecords, readBaseline, readEstate, readLanes, readProjectFile } from './store.js';
-export function registerFor(projectDir, outboxDir) {
-    const project = readProjectFile(projectDir);
+/** `project`: the folder's project file when the caller has already read it (one read, one answer). */
+export function registerFor(projectDir, outboxDir, project = readProjectFile(projectDir)) {
     const collected = collectRecords(projectDir);
     // This laptop's own outbox counts too, so a developer sees their work before
     // handing it in. It is also the one way this picture can legitimately differ
     // from the team project page's, so `status` says out loud when it counted them.
     const own = outboxDir && path.resolve(outboxDir) !== path.resolve(projectDir) ? collectRecords(outboxDir) : { records: [], unreadable: 0, files: 0 };
-    const baseline = readBaseline(projectDir);
+    const baseline = readBaseline(projectDir, project);
     const lanes = readLanes(projectDir);
     // The newest discovery, when the folder holds one: the estate around the team project.
     const estate = readEstate(projectDir)?.estate;