@cspeach/cli 1.1.31 → 1.1.33

package/dist/journey/run.js

@@ -12,11 +12,13 @@
  * inside a slash command the journey queues or names.
  */
 import path from 'node:path';
-import { estateSummaryOf, usageLineWithWindow } from '@cspeach/register-core';
-import { runTeamCommand, whoAmI, writeReports } from '../commands/team.js';
+import { estateSummaryOf, provenForTargetWords, usageLineWithWindow } from '@cspeach/register-core';
+import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, ownerMatch, runTeamCommand, severalLine, whoAmI, writeExports, writeReports } from '../commands/team.js';
+import { EXPORTS_DIR, exportsOn, setExportsAlways } from '../register/export-files.js';
 import { shown, shownUpTo } from '../register/atc-file.js';
-import { activeProject, readEstate, readLanes, readProjectFile } from '../register/store.js';
-import { claimedSinceCheck, fixFailedCheck, myObjects, readJourneyFacts, stepOf, toDecide, toFix, toProve, toRedesign, unreadableReason, STEPS, } from './clean-core.js';
+import { activeProject, readEstate, readLanes, readProjectFile, VARIANT_NAME } from '../register/store.js';
+import { registerFor } from '../register/picture.js';
+import { claimedSinceCheck, fixFailedCheck, myObjects, provenForTarget, readJourneyFacts, stepOf, toDecide, toFix, toProve, toRedesign, unreadableReason, STEPS, } from './clean-core.js';
 /* ── words ──────────────────────────────────────────────────────────────── */
 export const UNREADABLE_LINES = {
     'object-list': 'The project\'s object list in this folder can\'t be read right now — it may still be syncing. Try again in a minute.',
@@ -77,10 +79,12 @@ export function notRecordedLine(error) {
 export const objectShown = (name) => (OBJECT_NAME.test(name.toUpperCase()) ? name.toUpperCase() : shown(name));
 /** An object marked fix whose name CSPeach never puts in a command: one plain line, and it is passed over. */
 export const passedOverLine = (name) => `${objectShown(name)}: the name is not an ABAP name, so CSPeach passed it over.`;
+/** F16: the check a project measures with, said as a line. */
+export const checkedWithLine = (variant) => `  Checked with: ${variant}.`;
 /* ── commands the journey queues ────────────────────────────────────────── */
-const OBJECT_TYPE = /^[A-Z]{4}$/;
+export const OBJECT_TYPE = /^[A-Z]{4}$/;
 /** An ABAP object name: letters, digits, underscores, an optional /NAMESPACE/ in front. */
-const OBJECT_NAME = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,40}$/;
+export const OBJECT_NAME = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,40}$/;
 const LANE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
 export const MAX_REASON = 300;
 const chars = (...codes) => String.fromCharCode(...codes);
@@ -155,6 +159,7 @@ export async function runJourneyStage(stage, ctx) {
             case 'INVENTORY': return await inventory(ctx);
             case 'START': return await start(ctx);
             case 'JOIN': return await joinStage(ctx);
+            case 'UNOWNED': return unowned(ctx);
             case 'DECIDE': return decideStage(ctx);
             case 'FIX': return fixStage(ctx);
             case 'PROVE': return await prove(ctx);
@@ -186,11 +191,21 @@ function nextStepOnly(stage, ctx) {
         case 'INVENTORY': return stop(`Next: ${step(stage, 'look at what custom code is on the system.')}`);
         case 'START': {
             const named = (ctx.packages ?? []).map((p) => p.trim().toUpperCase()).filter((p) => PACKAGE.test(p));
-            return stop(`Next: ${step(stage, `start your project${named.length ? ` on ${named.join(', ')}` : ''} in this folder.`)}`);
+            // F16: headless shows no card; the check it would start with is said as a line.
+            const objects = inventoryObjects(ctx.cwd, named);
+            return result(stage, [
+                `Next: ${step(stage, `start your project${named.length ? ` on ${named.join(', ')}` : ''} in this folder.`)}`,
+                checkedWithLine(DEFAULT_ATC_VARIANT),
+                // I15: above 500 objects the first check is per package, said as a line.
+                ...(objects !== null && objects > FIRST_CHECK_WHOLE_MAX ? [FIRST_CHECK_PER_PACKAGE_LINE] : []),
+            ], { kind: 'stop' });
         }
         case 'JOIN': return stop(`Next: ${step(stage, 'pick up the project in this folder.')}`);
+        case 'UNOWNED': return unowned(ctx);
         case 'DECIDE':
         case 'FIX': {
+            if (needsFirstCheck(facts(ctx)))
+                return nothingMeasuredResult(stage);
             const r = stage === 'DECIDE' ? decideStage(ctx) : fixStage(ctx);
             // Names passed over are still said; the step line gives way to the command.
             return r.next.kind === 'queue'
@@ -198,7 +213,7 @@ function nextStepOnly(stage, ctx) {
                 : r;
         }
         case 'PROVE': return stop(`Next: ${step(stage, 'let SAP check your fixes.')}`);
-        case 'REPORT': return stop(`Next: ${step(stage, 'make the status page.')}`);
+        case 'REPORT': return nothingMeasured(facts(ctx)) ? nothingMeasuredResult(stage) : stop(`Next: ${step(stage, 'make the status page.')}`);
         case 'DONE': return done(ctx);
     }
 }
@@ -234,21 +249,65 @@ async function start(ctx) {
     const unknown = known ? packages.filter((p) => !known.includes(p)) : [];
     if (unknown.length)
         return stop(`CSPeach did not find ${unknown.length === 1 ? 'the package' : 'the packages'} ${unknown.join(', ')} on the system.`);
-    const { code, said } = await quiet(ctx, ['start', ...packages, '--folder', ctx.cwd]);
+    const asWith = ctx.variant && VARIANT_NAME.test(ctx.variant) ? ['--atc-variant', ctx.variant] : [];
+    // I15: above 500 objects the start measures nothing; the chain offers the per-package first check.
+    const big = isBigStart(ctx.cwd, packages);
+    const { code, said } = await quiet(ctx, ['start', ...packages, '--folder', ctx.cwd, ...asWith, ...(big ? ['--no-measure'] : [])]);
     if (code !== 0)
         return stop(failure(said, 'The project could not be started.'));
     let name = packages.join(', ');
+    let variant = asWith[1] ?? DEFAULT_ATC_VARIANT;
     try {
-        name = shown(readProjectFile(ctx.cwd).name);
+        const project = readProjectFile(ctx.cwd);
+        name = shown(project.name);
+        if (project.atcVariant && VARIANT_NAME.test(project.atcVariant))
+            variant = project.atcVariant;
     }
-    catch { /* the name it was started with */ }
+    catch { /* the name and the check it was started with */ }
     const objects = said.map((l) => /^\s*([\d,]+) objects?, matched against/.exec(l)?.[1]).find(Boolean);
     const check = said.map((l) => /First check \([^)]*\): ([\d,]+) of ([\d,]+) objects? with findings/.exec(l)).find(Boolean);
-    const lines = [`✓ Your project on ${name} started here.`];
+    const lines = [`✓ Your project on ${name} started here.`, checkedWithLine(variant)];
     if (objects)
         lines.push(`  ${objects} ${objects === '1' ? 'object' : 'objects'}, matched against the system's count.`);
     lines.push(check ? `  First check: ${check[1]} of ${check[2]} objects with findings.` : '  No check yet.');
-    return result('START', lines, { kind: 'continue' });
+    // Review T7 finding 2: init decides "big" from the live pull, which may differ from the inventory.
+    const perPackage = !check && said.includes(FIRST_CHECK_PER_PACKAGE_LINE);
+    return { ...result('START', lines, { kind: 'continue' }), ...(perPackage ? { firstCheckPerPackage: true } : {}) };
+}
+/** Code objects the folder's inventory holds for these packages; null when it does not know them all. */
+function inventoryObjects(cwd, packages) {
+    const found = readEstate(cwd);
+    const s = found ? estateSummaryOf(found.estate) : null;
+    if (!s || !packages.length)
+        return null;
+    const by = new Map(s.packages.map((p) => [p.name.toUpperCase(), p.codeObjects]));
+    if (packages.some((p) => !by.has(p.toUpperCase())))
+        return null;
+    return packages.reduce((n, p) => n + (by.get(p.toUpperCase()) ?? 0), 0);
+}
+/** A start the 30-minute whole-baseline check would cut (I15): more than 500 objects, known from the inventory. */
+export function isBigStart(cwd, packages) {
+    const n = inventoryObjects(cwd, packages.map((p) => p.trim().toUpperCase()).filter(Boolean));
+    return n !== null && n > FIRST_CHECK_WHOLE_MAX;
+}
+/**
+ * The first check, one package at a time (I15): `team refresh --all
+ * --per-package`, which resumes where it stopped. Never throws.
+ */
+export async function firstCheckPerPackage(ctx) {
+    try {
+        const { code, said } = await quiet(ctx, ['refresh', '--all', '--per-package']);
+        const done = said.find((l) => /^✓ [\d,]+ packages? measured, one record each\./.test(l));
+        if (code === 0 && done)
+            return result('START', [`  First check: ${done.replace(/^✓ /, '')}`], { kind: 'continue' });
+        const stopped = said.find((l) => /^✗ (Stopped|Lost the connection)/.test(l));
+        return result('START', [stopped ? `  ${stopped.replace(/^✗ /, '')}` : failure(said, 'The first check could not finish.'), FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        return result('START', ['The first check could not finish.', FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
+    }
 }
 /* JOIN — a project in this folder this laptop does not record into. */
 async function joinStage(ctx) {
@@ -273,15 +332,77 @@ async function joinStage(ctx) {
         if (res.cancelled || res.value !== 'yes')
             return result('JOIN', ['Nothing changed in this folder.'], { kind: 'stop' });
     }
+    // Step 2 (spec §3.6, F13, cut 5): a lane owner who shares my first name is
+    // asked about once; two of them are never guessed between.
+    let asName;
+    if (folder.kind === 'someone-else') {
+        const match = ownerByFirstName(ctx.cwd, me(ctx));
+        if (match.kind === 'several') {
+            return result('JOIN', [severalLine(match)], { kind: 'stop' });
+        }
+        if (match.kind === 'one') {
+            const res = await ctx.team.confirm({
+                id: 'journey-join-name',
+                tag: 'QUESTION',
+                title: `Are you ${match.owner}?`,
+                facts: [match.lane],
+                choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+                initial: 0,
+                aliases: { y: 'yes', n: 'no' },
+            });
+            if (res.cancelled || res.value === null)
+                return result('JOIN', ['Nothing changed in this folder.'], { kind: 'stop' });
+            if (res.value === 'yes')
+                asName = match.owner;
+        }
+    }
     // Results go straight into the folder.
-    const { code, said } = await quiet(ctx, ['join', ctx.cwd, '--outbox', ctx.cwd]);
+    const { code, said } = await quiet(ctx, ['join', ctx.cwd, '--outbox', ctx.cwd, ...(asName ? ['--as', asName] : [])]);
     if (code !== 0)
         return result('JOIN', [failure(said, 'The project in this folder could not be opened.')], { kind: 'stop' });
     const line = folder.kind === 'mine-not-joined'
         ? `Picking up your project on ${name}.`
-        : `✓ Working in ${lead}'s project ${name}.`;
+        : `✓ Working in ${lead}'s project ${name}${asName ? ` as ${asName}` : ''}.`;
     return result('JOIN', [line], { kind: 'continue' });
 }
+/**
+ * The lane owner I may be, decided by team.ts `ownerMatch` (the one shared
+ * rule), with that person's lanes' size for the card.
+ */
+function ownerByFirstName(cwd, myName) {
+    let lanes = [];
+    try {
+        lanes = readLanes(cwd);
+    }
+    catch {
+        return { kind: 'none' };
+    }
+    const m = ownerMatch(lanes, myName);
+    if (m.kind === 'several')
+        return m;
+    if (m.kind !== 'one')
+        return { kind: 'none' };
+    const ids = new Set(m.laneIds);
+    const packages = new Set(lanes.filter((l) => ids.has(l.id)).flatMap((l) => l.packages)).size;
+    let objects = null;
+    try {
+        objects = registerFor(cwd).register.lanes.filter((l) => ids.has(l.id)).reduce((n, l) => n + l.objects, 0);
+    }
+    catch {
+        objects = null;
+    }
+    const size = `${plural(packages, 'package', 'packages')}${objects === null ? '' : `, ${plural(objects, 'object', 'objects')}`}`;
+    return { kind: 'one', owner: m.owner, lane: `Your lane: ${size}.` };
+}
+/* UNOWNED — joined, and nothing here is mine yet (spec §3.6). Never DONE. */
+function unowned(ctx) {
+    let lead = '';
+    try {
+        lead = readProjectFile(ctx.cwd).lead.name;
+    }
+    catch { /* the line without a name */ }
+    return result('UNOWNED', [`You own nothing here yet. Ask ${lead ? shown(lead) : 'the lead'} to move packages to you.`], { kind: 'stop' });
+}
 /* DECIDE — the triage of my objects, a model step. */
 function decideStage(ctx) {
     const f = facts(ctx);
@@ -325,6 +446,24 @@ function proveScope(f, waiting) {
         objects: r.objects.filter((o) => o.inScope && packages.includes(o.package)).length,
     };
 }
+/**
+ * What a check that ran says about one object's fix. A fix the check says did
+ * not hold, with nothing open for its own target, is proven FOR THAT TARGET
+ * (spec §3.2, proof first) — "would only matter for A" only when every finding
+ * left is one that only level A cares about.
+ */
+export function proveLine(name, now) {
+    if (now.state === 'verified')
+        return `${name}: fix proven.`;
+    // F12: an object clean at its check never had a fix to prove.
+    if (now.state === 'clean')
+        return `${name}: no findings.`;
+    if (provenForTarget(now))
+        return `${name}: ${provenForTargetWords(now)}.`;
+    if (fixFailedCheck(now) && !claimedSinceCheck(now))
+        return `${name}: fix failed the check.`;
+    return `${name}: not checked yet.`;
+}
 /* PROVE — SAP checks the claimed fixes. */
 async function prove(ctx) {
     const f = facts(ctx);
@@ -357,12 +496,8 @@ async function prove(ctx) {
         const name = objectShown(was.name);
         if (!now || !now.lastMeasuredAt || now.lastMeasuredAt === was.lastMeasuredAt)
             lines.push(`${name}: not checked yet.`);
-        else if (now.state === 'verified' || now.state === 'clean')
-            lines.push(`${name}: fix proven.`);
-        else if (fixFailedCheck(now) && !claimedSinceCheck(now))
-            lines.push(`${name}: fix failed the check.`);
         else
-            lines.push(`${name}: not checked yet.`);
+            lines.push(proveLine(name, now));
     }
     if (!measured && lines.every((l) => l.endsWith('not checked yet.'))) {
         return result('PROVE', [failure(said, 'SAP could not check them right now.')], { kind: 'stop' });
@@ -371,6 +506,9 @@ async function prove(ctx) {
 }
 /* REPORT — the status page and the workbook, in reports/. */
 async function report(ctx) {
+    // A status page with nothing measured on it is no report (review T7 finding 1).
+    if (nothingMeasured(facts(ctx)))
+        return nothingMeasuredResult('REPORT');
     const joined = activeProject();
     if (!joined)
         return result('REPORT', [UNREADABLE_LINES.other], { kind: 'stop' });
@@ -406,13 +544,68 @@ async function report(ctx) {
             }
         }
     }
+    // The report is saved whatever happens to the CSV files: a failure here is one line, never the stage.
+    try {
+        lines.push(...await csvExport(ctx, joined.projectDir, project));
+    }
+    catch (e) {
+        const said = e instanceof Error ? e.message : String(e);
+        lines.push(`  The CSV files could not be written: ${failureLine([`✗ ${said.split('\n')[0]}`], 'the folder could not be written to').replace(/[\s.…]+$/, '')}.`);
+    }
     return result('REPORT', lines, { kind: 'continue' }, { report: true });
 }
+const CSV_SAVED = '✓ Saved the CSV files for your own tools in the exports folder.';
+/**
+ * The CSV export at REPORT (spec §3.4, D2): written when the project file's
+ * switch is on; otherwise one card. "Every time" turns the switch on (visible
+ * in the project file), "Just this once" writes them, "No" or a card put away
+ * writes nothing. A headless chain never reaches REPORT (it stops at the
+ * next-step line before it), so there is no card and no file there.
+ */
+async function csvExport(ctx, projectDir, project) {
+    const write = () => {
+        const { saved, held } = writeExports(projectDir, project, path.join(projectDir, 'reports', EXPORTS_DIR), ctx.team.deps);
+        return [
+            ...(saved.length ? [CSV_SAVED] : []),
+            ...held.map((name) => `  "${name}" is open in another program, so it was not updated. Close it and say carry on.`),
+        ];
+    };
+    if (exportsOn(project))
+        return write();
+    const res = await ctx.team.confirm({
+        id: 'journey-export',
+        tag: 'QUESTION',
+        title: 'Also write CSV files for your own tools?',
+        choices: [{ value: 'every', label: 'Every time' }, { value: 'once', label: 'Just this once' }, { value: 'no', label: 'No' }],
+        initial: 2,
+        aliases: { e: 'every', j: 'once', n: 'no' },
+    });
+    if (res.cancelled || (res.value !== 'every' && res.value !== 'once'))
+        return [];
+    if (res.value === 'once')
+        return write();
+    setExportsAlways(projectDir);
+    return [...write(), '  They are written with every report from now on.'];
+}
 /** The closing count of objects kept: "1 kept as is", "2 kept as they are". */
 export const keptPart = (n) => `${n} ${n === 1 ? 'kept as is' : 'kept as they are'}`;
 /* DONE — a short summary. */
+/** Said instead of "Done for now." when the project has no counted check at all. */
+export const NOTHING_MEASURED_LINE = 'Nothing is measured yet.';
+/** The folder's project has no counted check run (I15, review T7 finding 1). */
+export function nothingMeasured(f) {
+    return !!f.register && f.register.runs.length === 0;
+}
+/** Nothing measured, and too many objects for one check: the per-package first check comes first (I15). */
+export function needsFirstCheck(f) {
+    return nothingMeasured(f) && f.register.objects.length > FIRST_CHECK_WHOLE_MAX;
+}
+const nothingMeasuredResult = (stage) => result(stage, [NOTHING_MEASURED_LINE, FIRST_CHECK_PER_PACKAGE_LINE], { kind: 'stop' });
 function done(ctx) {
     const f = facts(ctx);
+    // Never "Done for now." with nothing measured.
+    if (nothingMeasured(f))
+        return nothingMeasuredResult('DONE');
     const lines = ['Done for now.'];
     if (f.register) {
         const mine = myObjects(f.register, f.me);

package/dist/journey/session-deps.js

@@ -65,7 +65,11 @@ export async function sessionTeamDeps(o) {
         connect: noSap ? undefined : async () => ({
             sql: (q, max) => adt.sqlQuery(q, max),
             ...(o.sapAlias && o.sapAlias !== 'none' ? { system: { sid: o.sapAlias } } : {}),
-            atc: { runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts) },
+            atc: {
+                runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts),
+                // The finding's own document names the API it uses, when its worklist entry does not.
+                ...(adt.atcFindingDocument ? { findingDocument: (href) => adt.atcFindingDocument(href) } : {}),
+            },
         }),
         ask: askWith(confirm),
         ...(o.signal ? { onInterrupt: interruptOn(o.signal) } : {}),

package/dist/lane/app-chain.js

@@ -29,10 +29,16 @@ import { chainFromToken } from './chain-token.js';
 import { containSpecPath, specDisplayPath, SpecProtectedError } from './roots.js';
 import { resolveAtTokenAsync } from '../projects/workspace.js';
 import { parseFromFlag } from '../skills/promotion-dispatch.js';
+import { rebuildStartedAfterPlanSave } from '../journey/rebuild.js';
 export const STEP_1 = 'Step 1 of 3: finding the gaps in the spec.';
 export const STEP_2 = 'Step 2 of 3: choosing the build lane.';
 export const STEP_3 = 'Step 3 of 3: planning the build.';
 export const START_QUESTION = 'Build this now?';
+/**
+ * Audit M-2 — who queued the chain's commands: CSPeach. No line of its own: the
+ * step lines (Step 2/3) and the plan board already stand for the step.
+ */
+const APP_ORIGIN = { by: 'app' };
 /** Trailing characters a sentence puts after a token: `see @spec.md.` / `(@spec.md)`. */
 const TRAILING_PUNCT = /[.,;:!?)\]}>]+$/;
 /**
@@ -300,7 +306,7 @@ export async function afterSpecGapSave(h, savedPath) {
         h.emit(`Next: ${cmd}`);
         return;
     }
-    h.queueNext(cmd);
+    h.queueNext(cmd, APP_ORIGIN);
     h.emit(STEP_2);
 }
 /** The result was written but could not be read as a spec-gap: the flow waits at step 1. */
@@ -348,6 +354,10 @@ export async function afterPlanSave(h, savedPath) {
         || canonicalLanePath(flow.lane.path) !== canonicalLanePath(lane.path) || flow.lane.sha256 !== lane.sha256)) {
         return;
     }
+    // Step 2 (I6): a plan saved for a rebuild brief under <project>/rebuilds/<APP>/
+    // moves that rebuild to `started`, with this plan's file name as its link.
+    if (flow)
+        await rebuildStartedAfterPlanSave({ cwd: h.cwd, specToken: cleanSpecToken(flow.specToken), savedPath, emit: h.emit });
     const end = () => { if (flow)
         clearAppFlow(h.session); };
     const cmd = startCommand(savedPath);
@@ -397,7 +407,7 @@ export async function afterPlanSave(h, savedPath) {
                 h.emit(OBJECT_LIST_FAILED);
             }
         }
-        h.queueNext(cmd);
+        h.queueNext(cmd, APP_ORIGIN);
     }
     else {
         h.emit(`Start it later with: ${cmd}`);

package/dist/one-shot.js

@@ -77,6 +77,8 @@ import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 import './tools/subagent/read_agent.js';
 import { folderTag } from './session/project-match.js';
+import { detectRunStart } from './runs/front-door.js';
+import { guardRunLabel } from './runs/shadow.js';
 export async function runOneShot(prompt, opts) {
     applyColorMode(); // NO_COLOR (piece 2 §1.2)
     const cfg = await loadConfig();
@@ -196,24 +198,26 @@ export async function runOneShot(prompt, opts) {
     }
     const session = newSession(makeSessionId(), alias, null, resolveModelRole('session_default', cfg), folderTag(process.cwd()));
     await saveSession(session);
-    // Guided clean-core journey (Task 3) — one-shot is headless: a journey
-    // sentence prints its next step and queues nothing; no model call. Only a
-    // START sentence (or the explicit /abap-clean-core start form): a bare
-    // "continue" / "carry on" keeps its old meaning here (final fix wave).
-    {
-        const { parseJourneyStart } = await import('./journey/trigger.js');
-        const journey = parseJourneyStart(prompt);
-        if (journey) {
-            const { runJourneyEntry } = await import('./repl/journey-entry.js');
-            await runJourneyEntry(journey, {
-                session, cwd: process.cwd(), adt, sapAlias: alias, standalone, headless: true,
-                emit: (line) => writeStdout(line + '\n'),
-                signal: new AbortController().signal,
-            });
-            return 0;
-        }
+    // Guided runs — the same front door as both REPLs (audit G-2). One-shot is
+    // headless: a start sentence prints its next step and queues nothing; no
+    // model call. A bare "continue" / "carry on" keeps its old meaning here
+    // (resume: false — final fix wave).
+    const door = await detectRunStart(prompt, { cwd: process.cwd(), session, resume: false });
+    if (door.kind === 'line') {
+        console.error(door.line);
+        return 1;
+    }
+    const input = door.input;
+    if (door.kind === 'run') {
+        const { runJourneyEntry } = await import('./repl/journey-entry.js');
+        await runJourneyEntry(door.trigger, {
+            session, cwd: process.cwd(), adt, sapAlias: alias, standalone, headless: true,
+            emit: (line) => writeStdout(line + '\n'),
+            signal: new AbortController().signal,
+        });
+        return 0;
     }
-    const parsed = parseShortcut(prompt);
+    const parsed = parseShortcut(input);
     const body = parsed.prompt;
     let skill;
     if (parsed.skill) {
@@ -260,6 +264,9 @@ export async function runOneShot(prompt, opts) {
         finally {
             routingBeat.stop();
         }
+        // Defensive (spec §4 step 2): a run label never dispatches in this release.
+        // No shadow here: one-shot exits when the turn ends (ruling 5).
+        c = guardRunLabel(c);
         if (c.offline) {
             // Remote classify failed twice — local-rules fallback fired. Print
             // to stderr so it doesn't pollute stdout for scripted callers, but

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

@@ -7,11 +7,42 @@ 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(`target ${r.targetLevel ?? 'A'}`);
+        parts.push(r.targetLevel ? `target ${r.targetLevel}` : 'no target set');
     return `${parts.join(', ')}${r.reason ? `, because: ${r.reason}` : ''}`;
 }
 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 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
+ * answers the card either way.
+ */
+export function ruleRow(r, p) {
+    const own = (r.reason ?? '').replace(RULE_PREFIX, '').trim();
+    if (!p)
+        return { row: own === r.reason ? r : { ...r, reason: own } };
+    const id = shown(p.ruleId);
+    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}` };
+    }
+    // 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('') } };
+}
 export async function confirmCleanCoreRows(ex, a) {
     if (!a.joined) {
         // Review Focus 4: the file is still saved; say why nothing is recorded.
@@ -23,8 +54,9 @@ export async function confirmCleanCoreRows(ex, a) {
         return ex;
     }
     const rows = [];
-    for (const r of ex.content.adjudications) {
-        const answer = await a.confirm(`Record ${r.objectType} ${r.objectName}: ${rowWords(r)}?`, { default: 'n' });
+    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 yes = rows.filter((r) => r.confirmed).length;
@@ -54,7 +86,8 @@ function proposalWords(r) {
 }
 export async function decideCleanCoreRows(ex, j) {
     const all = ex.content.adjudications;
-    const rows = all.map((r) => ({ ...r, confirmed: false }));
+    const ruled = all.map((r) => (j.rules ? ruleRow(r, j.rules(keyOf(r))) : { row: r, differs: undefined }));
+    const rows = ruled.map(({ row }) => ({ ...row, confirmed: false }));
     const tally = { total: all.length, yes: [], kept: [], skipped: [], cancelled: false };
     const footnote = `Step ${stepOf('DECIDE')} of ${STEPS}`;
     let answered = 0;
@@ -72,7 +105,7 @@ export async function decideCleanCoreRows(ex, j) {
                 id: 'journey-row',
                 tag: 'QUESTION',
                 title: `Record ${type} ${name}: ${proposalWords({ ...r, objectType: type, objectName: name })}?`,
-                facts: [...(why ? [`Why: ${why}`] : []), `Row ${i + 1} of ${rows.length}.`],
+                facts: [...(why ? [`Why: ${why}`] : []), ...(ruled[i].differs ? [ruled[i].differs] : []), `Row ${i + 1} of ${rows.length}.`],
                 choices: [
                     { value: 'yes', label: 'Yes' },
                     ...(canKeep ? [{ value: 'keep', label: 'Keep as is' }] : []),

package/dist/projects/save-command.js

@@ -398,11 +398,28 @@ export async function runSaveCommand(args) {
     if (spec.artefactType === 'clean-core-decision') {
         const { confirmCleanCoreRows, decideCleanCoreRows } = await import('./clean-core-confirm.js');
         const { activeProject } = await import('../register/store.js');
-        const joined = activeProject() !== null;
+        const project = activeProject();
+        const joined = project !== null;
+        // Step 2 (D6): the rule that decides each row, said on its card. Never blocks a save: unreadable → no rule line.
+        let rules;
+        if (project) {
+            try {
+                const { ruleProposalsFor } = await import('../register/decision-rules.js');
+                const r = ruleProposalsFor(project.projectDir, project.outboxDir);
+                rules = r.lookup;
+                // Inside a journey no file name is said (Task 7); the triage tool carries the warning to the model.
+                if (r.warning && !journey)
+                    args.log(r.warning);
+            }
+            catch {
+                // No rule can be read: every row is CSPeach's judgement, so a "Rule <id>:" the model wrote is taken off (review 9 #2).
+                rules = () => null;
+            }
+        }
         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,
+                card: journey.card, ask: journey.ask, skip: journey.skip, log: args.log, ...(rules ? { rules } : {}),
             });
             extract = r.extract;
             tally = r.tally;
@@ -415,7 +432,7 @@ export async function runSaveCommand(args) {
             }
             else {
                 extract = await confirmCleanCoreRows(extract, {
-                    ...(args.confirm ? { confirm: args.confirm } : {}), log: args.log, joined,
+                    ...(args.confirm ? { confirm: args.confirm } : {}), log: args.log, joined, ...(rules ? { rules } : {}),
                 });
             }
         }

package/dist/register/baseline.js

@@ -50,6 +50,43 @@ export async function listCustomPackages(sql, prefixes = ['Z', 'Y']) {
     }
     return [...out.values()].sort((a, b) => a.package.localeCompare(b.package));
 }
+/** The data preview never returns more than this many rows in one answer. */
+export const SQL_ROW_CAP = 5000;
+/** A quote in a paging key is doubled, so it cannot end the literal. */
+const lit = (v) => v.replace(/\x27/g, '\x27\x27');
+/**
+ * One package (or one $TMP prefix). Below the cap: today's single query for
+ * `expected + 50` rows. Above it (`expected + 50 > 5000`, review I14): keyset
+ * pages of 5,000 by OBJ_NAME until a page is short. The key is `>=` with the
+ * rows already seen dropped, so a name held by two object types that a page
+ * boundary splits is never lost. The control total of the caller still decides.
+ */
+async function pullOne(sql, pkg, select, expected) {
+    if (expected + 50 <= SQL_ROW_CAP)
+        return (await sql(select, expected + 50)).rows;
+    const rows = [];
+    const seen = new Set();
+    let last;
+    for (;;) {
+        const page = (await sql(`${select}${last === undefined ? '' : ` AND OBJ_NAME >= '${lit(last)}'`} ORDER BY OBJ_NAME, OBJECT`, SQL_ROW_CAP)).rows;
+        let fresh = 0;
+        for (const r of page) {
+            const k = `${clean(r.OBJECT)}|${clean(r.OBJ_NAME)}`;
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            rows.push(r);
+            fresh += 1;
+        }
+        if (page.length < SQL_ROW_CAP)
+            return rows;
+        const next = clean(page[page.length - 1].OBJ_NAME);
+        if (fresh === 0 || next === last) {
+            throw new BaselineError(`Package ${pkg}: the pull could not page past ${next}. The baseline was NOT written.`);
+        }
+        last = next;
+    }
+}
 export async function pullBaseline(sql, opts) {
     const types = new Set((opts.objectTypes ?? CODE_OBJECT_TYPES).map((t) => t.toUpperCase()));
     const objects = [];
@@ -65,11 +102,11 @@ export async function pullBaseline(sql, opts) {
             for (const [prefix, n] of Object.entries(byPrefix)) {
                 if (!PREFIX_RE.test(prefix))
                     throw new BaselineError(`Not a valid name prefix: ${prefix}`);
-                res.rows.push(...(await sql(`${select} AND OBJ_NAME LIKE '${prefix}%'`, n + 50)).rows);
+                res.rows.push(...(await pullOne(sql, pkg, `${select} AND OBJ_NAME LIKE '${prefix}%'`, n)));
             }
         }
         else {
-            res.rows.push(...(await sql(select, expected + 50)).rows);
+            res.rows.push(...(await pullOne(sql, pkg, select, expected)));
         }
         if (res.rows.length !== expected) {
             throw new BaselineError(`Package ${pkg}: the system counted ${expected} objects but the pull returned ${res.rows.length}. `