@cspeach/cli 1.1.47 → 1.1.49

package/dist/journey/run.js

@@ -12,13 +12,16 @@
  * inside a slash command the journey queues or names.
  */
 import path from 'node:path';
-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 { estateSummaryOf, PART_ORDER, PART_WORDS, provenForTargetWords, usageLineWithWindow } from '@cspeach/register-core';
+import { DEFAULT_ATC_VARIANT, FIRST_CHECK_PER_PACKAGE_LINE, FIRST_CHECK_WHOLE_MAX, NO_CHECK_ALL_LINE, ownerMatch, runTeamCommand, severalLine, whoAmI, writeExports, writeReports } from '../commands/team.js';
+import { EXPORTS_DIR, exportsOff, exportsOn, exportsPresent, setExportsAlways } from '../register/export-files.js';
 import { shown, shownUpTo } from '../register/atc-file.js';
+import { withoutRuleId } from '../register/records.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';
+import { TRANSPORT_NONE_WORDS, TRANSPORT_REQUEST, transportWords } from '../register/project-transport.js';
+import { claimedSinceCheck, fixFailedCheck, myObjects, newestRecordAt, provenForTarget, readJourneyFacts, stepOf, toDecide, toFix, toProve, unreadableReason, STEPS, } from './clean-core.js';
+import { doneFingerprint, setDoneFingerprint } from './flow.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.',
@@ -79,8 +82,14 @@ 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.`;
+/** Fix round 1: an object marked fix that the project's own view does not hold right now: one plain line, and it is passed over. */
+export const notInViewLine = (name) => `${objectShown(name)}: it is not in the project's list right now, so CSPeach passed it over.`;
 /** F16: the check a project measures with, said as a line. */
 export const checkedWithLine = (variant) => `  Checked with: ${variant}.`;
+/** Task 8 (B11): a project that holds no transport request yet, said as a line (headless, or None yet on the card). The words live in project-transport.ts. */
+export const TRANSPORT_NONE_LINE = `  ${TRANSPORT_NONE_WORDS}`;
+/** Task 8 (B11): the request a project's fixes are recorded in, said as a line. */
+export const transportLine = (request) => `  ${transportWords(request)}`;
 /* ── commands the journey queues ────────────────────────────────────────── */
 export const OBJECT_TYPE = /^[A-Z]{4}$/;
 /** An ABAP object name: letters, digits, underscores, an optional /NAMESPACE/ in front. */
@@ -129,13 +138,17 @@ export function cleanReason(reason) {
 export function triageCommand(laneId) {
     return LANE_ID.test(laneId) ? `/abap-clean-core triage lane ${laneId}` : null;
 }
-/** `/abap-refactor <TYPE> <NAME> — <reason>`, names upper-cased; null when a name is not an ABAP name. */
+/**
+ * `/abap-refactor <TYPE> <NAME> — <reason>`, names upper-cased; null when a
+ * name is not an ABAP name. A "Rule <id>:" an older record carries in its
+ * reason is left out (project view Task 4: rule ids never sit inside a reason).
+ */
 export function refactorCommand(o) {
     const type = o.type.trim().toUpperCase();
     const name = o.name.trim().toUpperCase();
     if (!OBJECT_TYPE.test(type) || !OBJECT_NAME.test(name))
         return null;
-    const reason = cleanReason(o.reason);
+    const reason = cleanReason(withoutRuleId(String(o.reason ?? '')));
     return `/abap-refactor ${type} ${name}${reason ? ` — ${reason}` : ''}`;
 }
 /* ── the runner ─────────────────────────────────────────────────────────── */
@@ -196,6 +209,7 @@ function nextStepOnly(stage, ctx) {
             return result(stage, [
                 `Next: ${step(stage, `start your project${named.length ? ` on ${named.join(', ')}` : ''} in this folder.`)}`,
                 checkedWithLine(DEFAULT_ATC_VARIANT),
+                ...(ctx.transportAsked ? [TRANSPORT_NONE_LINE] : []),
                 // 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' });
@@ -252,28 +266,68 @@ async function start(ctx) {
     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'] : [])]);
+    const developers = ctx.developers?.length ? ['--developers', ctx.developers.join(', ')] : [];
+    const transport = ctx.transport && TRANSPORT_REQUEST.test(ctx.transport) ? ['--transport', ctx.transport] : [];
+    const { code, said } = await quiet(ctx, ['start', ...packages, '--folder', ctx.cwd, ...asWith, ...(big ? ['--no-measure'] : []), ...developers, ...transport]);
     if (code !== 0)
         return stop(failure(said, 'The project could not be started.'));
     let name = packages.join(', ');
     let variant = asWith[1] ?? DEFAULT_ATC_VARIANT;
+    let stored;
     try {
         const project = readProjectFile(ctx.cwd);
         name = shown(project.name);
         if (project.atcVariant && VARIANT_NAME.test(project.atcVariant))
             variant = project.atcVariant;
+        const r = project.transport?.request;
+        if (typeof r === 'string' && TRANSPORT_REQUEST.test(r))
+            stored = r;
     }
     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);
+    // Project view Task 5: the counts are read from the folder's view, never from the lines the start printed.
+    const counts = startCounts(ctx);
+    const objects = counts?.objects;
+    const check = counts?.check;
     const lines = [`✓ Your project on ${name} started here.`, checkedWithLine(variant)];
+    // Task 8 (B11): the transport, said only when the start asked for it.
+    if (stored)
+        lines.push(transportLine(stored));
+    else if (ctx.transportAsked)
+        lines.push(TRANSPORT_NONE_LINE);
     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.');
+        lines.push(`  ${plural(objects, 'object', 'objects')}, matched against the system's count.`);
+    lines.push(check ? `  First check: ${num(check.withFindings)} of ${plural(check.checked, 'object', 'objects')} with findings.` : '  No check yet.');
+    // B1: each person's share, as the start wrote it (never the lane-move or results lines).
+    if (developers.length)
+        lines.push(...said.map(shareLine).filter((l) => l !== null));
     // 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);
+    // B1: a start with people named measures nothing at all, so the first check runs per package too.
+    const perPackage = !check && (said.includes(FIRST_CHECK_PER_PACKAGE_LINE) || said.includes(NO_CHECK_ALL_LINE));
     return { ...result('START', lines, { kind: 'continue' }), ...(perPackage ? { firstCheckPerPackage: true } : {}) };
 }
+/**
+ * What the start leaves in the folder, read from its project view: how many
+ * objects, and — when the start measured — how many of the objects checked
+ * have findings. Null when the folder cannot be read.
+ */
+function startCounts(ctx) {
+    const view = facts(ctx).view;
+    if (!view)
+        return null;
+    const { all } = view;
+    return { objects: all.total, check: all.coverage.checked ? { checked: all.coverage.checked, withFindings: all.coverage.withFindings } : null };
+}
+/** `  James Miller (james): ZSD_ORDERS, ZMM_STOCK · 10 objects` and `  James Miller: no package yet.` as team start prints them. */
+const SHARE = /^ {2}(.+?) \([A-Za-z0-9_-]+\): (.+) · (\d[\d,]* objects?)$/;
+const NO_SHARE = /^ {2}(.+): no package yet\.$/;
+/** One person's share for the journey: `  James Miller: ZSD_ORDERS, ZMM_STOCK · 10 objects.`; null for any other line. */
+function shareLine(l) {
+    const m = SHARE.exec(l);
+    if (m)
+        return `  ${shown(m[1])}: ${shownUpTo(m[2], 200)} · ${m[3]}.`;
+    const none = NO_SHARE.exec(l);
+    return none ? `  ${shown(none[1])}: no package yet.` : null;
+}
 /** 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);
@@ -406,7 +460,7 @@ function unowned(ctx) {
 /* DECIDE — the triage of my objects, a model step. */
 function decideStage(ctx) {
     const f = facts(ctx);
-    const left = f.register ? toDecide(f.register, f.me, f.skip) : [];
+    const left = f.register ? toDecide(f.register, f.me, f.skip, f.view) : [];
     const lane = left[0]?.lane;
     const command = lane ? triageCommand(lane) : null;
     if (!command)
@@ -416,22 +470,33 @@ function decideStage(ctx) {
 /* FIX — the next object to fix, a model step. */
 function fixStage(ctx) {
     const f = facts(ctx);
-    const left = f.register ? toFix(f.register, f.me, f.skip) : [];
-    // A name that is not an ABAP name is passed over with one line; the next one is queued.
+    return fixStep(f.register ? toFix(f.register, f.me, f.skip, f.view) : [], f.view);
+}
+/**
+ * The fix step over the objects left to fix, in order: a name that is not an
+ * ABAP name, or an object the project view does not hold (fix round 2), is
+ * passed over with one line and put off for the session; the next one is queued.
+ */
+export function fixStep(left, view) {
     const passed = [];
+    const skip = () => (passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
     for (const o of left) {
         // The reason comes from the recorded decision only, never from the model's words.
         const command = refactorCommand({ type: o.type, name: o.name, ...(o.decision?.reason ? { reason: o.decision.reason } : {}) });
         if (!command) {
-            passed.push(o);
+            passed.push({ key: o.key, line: passedOverLine(o.name) });
+            continue;
+        }
+        if (view && !view.object(o.key)) {
+            passed.push({ key: o.key, line: notInViewLine(o.name) });
             continue;
         }
-        const lines = [...passed.map((x) => passedOverLine(x.name)), `${step('FIX', `fix ${o.name.toUpperCase()}.`)}`];
-        if (fixFailedCheck(o))
+        const lines = [...passed.map((x) => x.line), `${step('FIX', `fix ${o.name.toUpperCase()}.`)}`];
+        if (view?.object(o.key)?.part === 'failed-check')
             lines.push('  Its last fix failed the check.');
-        return result('FIX', lines, { kind: 'queue', command, key: o.key }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+        return result('FIX', lines, { kind: 'queue', command, key: o.key }, skip());
     }
-    return result('FIX', passed.map((x) => passedOverLine(x.name)), { kind: 'continue' }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+    return result('FIX', passed.map((x) => x.line), { kind: 'continue' }, skip());
 }
 /** What a check of my claimed fixes measures: my one area, or the packages of the claimed objects. */
 function proveScope(f, waiting) {
@@ -439,7 +504,7 @@ function proveScope(f, waiting) {
     const joined = activeProject();
     const lanes = joined ? readLanes(joined.projectDir).filter((l) => l.owner.trim().toLowerCase() === f.me.trim().toLowerCase()) : [];
     if (lanes.length === 1)
-        return { args: ['refresh'], objects: myObjects(r, f.me).length };
+        return { args: ['refresh'], objects: myObjects(r, f.me, f.view).length };
     const packages = [...new Set(waiting.map((o) => o.package))];
     return {
         args: ['refresh', '--packages', packages.join(',')],
@@ -469,7 +534,7 @@ async function prove(ctx) {
     const f = facts(ctx);
     if (!f.register)
         return result('PROVE', [UNREADABLE_LINES[unreadableReason(f) ?? 'other']], { kind: 'stop' });
-    const waiting = toProve(f.register, f.me);
+    const waiting = toProve(f.register, f.me, f.view);
     if (!waiting.length)
         return result('PROVE', [], { kind: 'continue' });
     const scope = proveScope(f, waiting);
@@ -555,23 +620,29 @@ async function report(ctx) {
     return result('REPORT', lines, { kind: 'continue' }, { report: true });
 }
 const CSV_SAVED = '✓ Saved the CSV files for your own tools in the exports folder.';
+const CSV_UPDATED = '✓ Updated the CSV files 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.
+ * writes nothing. CSV files already in the exports folder (G5) are rewritten
+ * without a card, so they never go stale. 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);
+    const dir = path.join(projectDir, 'reports', EXPORTS_DIR);
+    const write = (savedLine = CSV_SAVED) => {
+        const { saved, held } = writeExports(projectDir, project, dir, ctx.team.deps);
         return [
-            ...(saved.length ? [CSV_SAVED] : []),
+            ...(saved.length ? [savedLine] : []),
             ...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();
+    if (!exportsOff(project) && exportsPresent(dir))
+        return write(CSV_UPDATED);
     const res = await ctx.team.confirm({
         id: 'journey-export',
         tag: 'QUESTION',
@@ -587,11 +658,26 @@ async function csvExport(ctx, projectDir, project) {
     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'}`;
+const num = (n) => n.toLocaleString('en-US');
+/** The closing count of objects kept: "1 kept as is", "2 kept as they are" (the view's words). */
+export const keptPart = (n) => PART_WORDS.kept(n);
+/**
+ * G2, project view Task 5: the DONE count, `  18 objects: 4 clean, …` — my
+ * objects (`view.me`, retired and out of scope included), each in exactly one
+ * of the view's parts, said in the view's order and words, the zero parts left
+ * out. Null when there are no objects.
+ */
+export function doneLine(mine) {
+    if (!mine.total)
+        return null;
+    const parts = PART_ORDER.filter((p) => mine.parts[p]).map((p) => PART_WORDS[p](mine.parts[p]));
+    return `  ${plural(mine.total, 'object', 'objects')}${parts.length ? `: ${parts.join(', ')}` : ''}.`;
+}
 /* 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.';
+/** B8: said instead of "Done for now." when "carry on" finds nothing new since the last DONE. */
+export const NOTHING_LEFT_LINE = 'Nothing left to carry on.';
 /** 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;
@@ -607,19 +693,20 @@ function done(ctx) {
     if (nothingMeasured(f))
         return nothingMeasuredResult('DONE');
     const lines = ['Done for now.'];
-    if (f.register) {
-        const mine = myObjects(f.register, f.me);
-        const count = (pred) => mine.filter(pred).length;
-        const parts = [
-            [count((o) => o.state === 'clean'), 'clean'],
-            [count((o) => o.state === 'verified'), 'fix proven'],
-        ].filter(([n]) => n > 0).map(([n, w]) => `${n} ${w}`);
-        const kept = count((o) => o.decision?.classification === 'keep' && o.state !== 'clean');
-        if (kept)
-            parts.push(keptPart(kept));
-        if (mine.length)
-            lines.push(`  ${plural(mine.length, 'object', 'objects')}${parts.length ? `: ${parts.join(', ')}` : ''}.`);
-        const rebuild = toRedesign(f.register, f.me).length;
+    if (f.register && f.view) {
+        const mine = f.view.me(f.me);
+        // B8: "carry on" after DONE with nothing new since says so, then the same counts.
+        if (ctx.session) {
+            const print = `${newestRecordAt(f.register) ?? ''}|${f.register.runs.length}|${mine.active}`;
+            if (doneFingerprint(ctx.session) === print)
+                lines[0] = NOTHING_LEFT_LINE;
+            setDoneFingerprint(ctx.session, print);
+        }
+        // The view's parts (built with this session's skipped rows): retired and out of scope are parts of their own, so it adds up.
+        const counts = doneLine(mine);
+        if (counts)
+            lines.push(counts);
+        const rebuild = mine.parts.rebuild;
         if (rebuild)
             lines.push(`  ${plural(rebuild, 'object', 'objects')} planned for a rebuild — handled separately.`);
     }

package/dist/journey/trigger.js

@@ -17,17 +17,18 @@
  * A pattern (*, %, ?) in such a sentence is refused in one line; no journey.
  *
  * Resume, in a folder that holds a project with no plan step pending: any of
- * "carry on" / "continue" / "continue clean core" picks up a journey this
- * session paused; "continue clean core" also resumes after a clean turn with
- * no answer pending; bare "carry on" / "continue" only as the session's first
- * words. Otherwise "continue" keeps its old meaning.
+ * "carry on" / "continue clean core" resumes when no turn was interrupted and
+ * no answer is pending (live re-run L2, 2026-10-21: after any turn, not only
+ * after DONE, a pause or as the first words). A bare "continue" often answers
+ * the turn before, so it resumes only after a pause or DONE, or as the first
+ * words. Right after a pause line any of the words resume. In a folder
+ * without a project, "continue" keeps its old meaning.
  */
 import { folderKind } from './clean-core.js';
-import { isJourneyPaused, isJourneyPausedJustNow, userTurnCount } from './flow.js';
+import { isJourneyEndedJustNow, isJourneyPaused, isJourneyPausedJustNow, userTurnCount } from './flow.js';
 /** The runner's own words for a pattern (run.ts START). */
 export const PATTERN_LINE = 'Name each package in full, for example ZFI_AR — not a pattern.';
 const CC = String.raw `clean[\s-]?core`;
-const CLEAN_CORE = new RegExp(CC, 'i');
 /** Words in front of the verb that do not change what is asked. */
 const FILLER = new RegExp(String.raw `^(?:(?:let'?s|let us|please|now|ok(?:ay)?|so|then|and|right|go ahead and|time to|(?:i|we)(?:'d| would)? (?:like|want) to|(?:i|we) need to)[,]?\s+)+`, 'i');
 const QUESTION = /^(?:what|why|how|is|are|was|were|can|could|would|should|does|did|will|explain|tell|describe|which|when|where|who|whether|show)\b/i;
@@ -129,9 +130,8 @@ export function isResumePhrase(input) {
  * Resume needs a project in `cwd` and no plan step in flight. Then:
  *   - right after a pause line, with no turn of the person's since, any of the
  *     words resumes — even after an interrupted step (that is what paused it);
- *   - otherwise nothing interrupted, no answer pending, and: a journey this
- *     session paused, or the words name clean core, or it is the session's
- *     first turn (text and image turns count; tool results do not).
+ *   - otherwise nothing interrupted and no answer pending: the words resume,
+ *     whatever turn came before (L2).
  */
 export function detectJourney(input, ctx) {
     const start = parseJourneyStart(input);
@@ -149,5 +149,11 @@ export function detectJourney(input, ctx) {
         return { kind: 'resume' };
     if (s.turnInterrupted || s.awaitingSkillAnswer)
         return null;
-    return isJourneyPaused(ctx.session) || CLEAN_CORE.test(input) || userTurnCount(ctx.session) === 0 ? { kind: 'resume' } : null;
+    // A bare "continue" often answers the turn before, so it keeps its old rule:
+    // after a pause or DONE, or as the session's first words.
+    if (/^continue[.!]*$/i.test(input.trim())) {
+        return isJourneyPaused(ctx.session) || isJourneyEndedJustNow(ctx.session) || userTurnCount(ctx.session) === 0 ? { kind: 'resume' } : null;
+    }
+    // L2: "carry on" and "continue clean core" always resume here (after DONE, a pause, or any other turn).
+    return { kind: 'resume' };
 }

package/dist/one-shot.js

@@ -78,10 +78,10 @@ import './tools/web/web_search.js';
 import './tools/project/project_context_get.js';
 import './tools/project/playbook_get.js';
 import './tools/project/convention_get.js';
-import './tools/project/cca_merge.js';
 import './tools/project/upgrade_merge_progress.js';
 import './tools/project/team_findings.js';
 import './tools/project/team_estate.js';
+import './tools/project/team_lane_move.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';

package/dist/project-context/render.js

@@ -97,6 +97,13 @@ function renderSapConnection(s) {
     if (s.currentTransport) {
         lines.push(`    <current_transport>${escapeXml(s.currentTransport)}</current_transport>`);
     }
+    // Task 6 (project view): the request the project in this folder records its fixes in. Absent outside one.
+    if (s.projectTransport) {
+        lines.push(`    <project_transport>${escapeXml(s.projectTransport)}</project_transport>`);
+        // Fix round 1: say plainly where a write with no request goes (the write tools' order).
+        lines.push(`    <transport_rule>A write that names no transport goes to the project request ${escapeXml(s.projectTransport)}, `
+            + 'not to the current transport (a request that already holds the object, or the request of an approved plan, still wins).</transport_rule>');
+    }
     if (s.activeScope) {
         if (s.activeScope.package) {
             lines.push(`    <active_package>${escapeXml(s.activeScope.package)}</active_package>`);