@cspeach/cli 1.1.31 → 1.1.32

package/dist/agent/loop.js

@@ -41,8 +41,9 @@ import { consumeTodoSetThisTurn } from '../ui/todo-emitter.js';
 import { runSaveCommand, runPromoteCommand, detectArtifactSkill, offerAnswerBlockers } from '../projects/index.js';
 import { planLaneBlockForTurn } from '../projects/plan-lane.js';
 import { clearAppFlow, getAppFlow, setGapConfirmed, startAppFlow } from '../lane/app-flow.js';
-import { afterJourneyTurn, gateJourneyForTurn, journeyAsk, journeyCardConfirm, journeyTurnBlock, pauseJourneyForInterruptedTurn } from '../journey/chain.js';
-import { addJourneyLeftOut, addJourneySkips, clearJourneyFlow, getJourneyFlow } from '../journey/flow.js';
+import { afterRebuildTurn } from '../journey/rebuild.js';
+import { afterJourneyTurn, gateJourneyForTurn, journeyAsk, journeyCardConfirm, journeyStoppedOnError, journeyTurnBlock, pauseJourneyForInterruptedTurn } from '../journey/chain.js';
+import { addJourneyLeftOut, addJourneySkips, getJourneyFlow } from '../journey/flow.js';
 import { afterPlanSave, afterSpecGapNotSaved, afterSpecGapSave, cleanSpecToken, extractSpecToken, FLOW_ENDED_LINE, gateAppFlowForTurn, resolveAppSpec, sameRealFile, STEP_1, STEP_3, } from '../lane/app-chain.js';
 import { shownToken } from '../lane/card.js';
 import { parseFromFlag, coerceDocFromFlagToAttachment } from '../skills/promotion-dispatch.js';
@@ -449,7 +450,7 @@ function journeyHooks(params, emit) {
         cwd: ctx.cwd,
         headless: isHeadless(),
         emit,
-        ...(ctx.pendingDispatch ? { queueNext: (cmd) => ctx.pendingDispatch.set(cmd) } : {}),
+        ...(ctx.pendingDispatch ? { queueNext: (cmd, origin) => ctx.pendingDispatch.set(cmd, origin) } : {}),
         ...(!standaloneTurn && ctx.adt ? { adt: ctx.adt } : {}),
         ...(ctx.sapAlias ? { sapAlias: ctx.sapAlias } : {}),
         ...(standaloneTurn ? { noSap: true } : {}),
@@ -1710,7 +1711,7 @@ ${imageExpansion.error}`));
                             appChain: {
                                 session,
                                 cwd: params.ctx.cwd,
-                                ...(params.ctx.pendingDispatch ? { queueNext: (cmd) => params.ctx.pendingDispatch.set(cmd) } : {}),
+                                ...(params.ctx.pendingDispatch ? { queueNext: (cmd, origin) => params.ctx.pendingDispatch.set(cmd, origin) } : {}),
                                 ...(params.ctx.sapAlias && params.ctx.sapAlias !== 'none' ? { sapAlias: params.ctx.sapAlias } : {}),
                             },
                         } : {}),
@@ -1743,10 +1744,19 @@ ${imageExpansion.error}`));
                 catch (err) {
                     if (process.env['CSPEACH_DEBUG'] === '1')
                         throw err;
-                    clearJourneyFlow(session);
-                    emit(chalk.yellow('The clean-core steps stopped here. Say carry on to continue.'));
+                    // Audit M-1: paused (not ended), so the line's "carry on" works; the
+                    // error is logged, and a second stop at the same step says so (follow-up a).
+                    emit(chalk.yellow(journeyStoppedOnError(session, params.ctx.cwd, err)));
                 }
             }
+            // Step 2, Task 5 — a /abap-modernize rebuild handed off by the journey
+            // reads `started` once one of its turns wrote to SAP (F9).
+            if (!readerChild && !params.ctx.subagent) {
+                try {
+                    await afterRebuildTurn(session, params.skill);
+                }
+                catch { /* the row stays handed-off */ }
+            }
             // Phase 2 #9 (2026-05-16) — auto-compact end-of-turn hook.
             // Runs only on the success path (after maybeOfferSave) so an interrupted
             // turn never triggers a summariser call on partial state. The maybeAutoCompact

package/dist/cli.js

@@ -10,7 +10,7 @@ import { migrateLegacyByokKey, legacyByokKeyNotice, cleanStaleAuthTemps } from '
  * The verbs that make `cspeach project …` a mistyped team command rather than
  * a prompt somebody meant to send. See the check in `main`.
  */
-const TEAM_SUBCOMMANDS = new Set(['init', 'join', 'lane', 'refresh', 'status', 'outbox', 'rule', 'leave']);
+const TEAM_SUBCOMMANDS = new Set(['init', 'join', 'lane', 'refresh', 'status', 'outbox', 'rule', 'rules', 'target', 'decide', 'leave', 'export']);
 export async function main(argv) {
     // NO_COLOR (piece 2 §1.2) — before ANY output, for every command (REPL,
     // one-shot, doctor, login, help, config …).
@@ -209,7 +209,10 @@ export async function main(argv) {
                 return {
                     sql: (q, max) => adt.sqlQuery(q, max),
                     system: { sid: name },
-                    atc: { runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts) },
+                    atc: {
+                        runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts),
+                        findingDocument: (href) => adt.atcFindingDocument(href),
+                    },
                 };
             },
             ask: async (question) => {
@@ -238,7 +241,7 @@ export async function main(argv) {
     // a PAID prompt on a machine that is configured and logged in. A hint, not
     // an alias: the old family does not run, and nothing is renamed back.
     if (args[0] === 'project' && TEAM_SUBCOMMANDS.has(args[1] ?? '')) {
-        console.log('Unknown command: cspeach project. Team projects use: cspeach team init|join|lane|refresh|status|outbox|rule|leave');
+        console.log('Unknown command: cspeach project. Team projects use: cspeach team init|join|lane|refresh|status|outbox|rule|rules|target|decide|leave|export');
         return 1;
     }
     // Sessions/folders (2026-10-08): sort project files from earlier builds into their folders. Copy only.
@@ -298,9 +301,11 @@ Usage:
   cspeach whoami                    Print current account info
   cspeach team discover            Read the whole estate from SAP into this folder (read only)
   cspeach team start <packages>     Start a team project in this folder: object list, first check, you own it all
+  cspeach team start --for "FI and SD" --developers "James Miller, me"   Lead: set up by name from this folder's discovery; one lane each
   cspeach team init <folder>        Lead: pull the object list from SAP, start a team project
-  cspeach team join <folder>        Record your results against a team project (on this laptop only)
+  cspeach team join <folder> [--as "<name>"]   Record your results against a team project (on this laptop only), under the lane owner's name
   cspeach team lane add|list        Lead: who owns which packages
+  cspeach team lane move --packages <names> --to <developer>   Lead: move packages by name (lanes of names only)
   cspeach team lane propose --developers "A,B" [--apply]   Lead: a first cut of the lanes, balanced by the work
   cspeach team focus "<label>" --packages … --reason "…"   Lead: what the team works on now (focus list | clear <label>)
   cspeach team priority show|set|reset   The priority rules; set and reset are the lead's
@@ -311,10 +316,14 @@ Usage:
   cspeach team status [folder]      Where every object stands, who owns it, what is proven
   cspeach team outbox               What this laptop has recorded, and where
   cspeach team rule T N <d>         Lead: settle a conflicting decision (a retire needs --reason)
+  cspeach team rules [on|off|set|add|remove|reset]   The decision rules: anyone views them, the lead changes them (also /rules in a session)
   cspeach team decide T N <d>       Record a clean-core decision: keep, fix, rebuild, retire or exception (a retire needs --reason)
+  cspeach team target <A-D> --reason "…" [--packages P1,P2] [--variant <NAME>]   Lead: the level fixes are proven against (team target clear removes it)
   cspeach team fixed T N            Claim a fix; the next refresh checks it
+  cspeach team rebuild built T N --app <APP>   Say a rebuild is built (the report then reads built, not yet checked)
   cspeach team sheet                Write your working list (Excel) from the team project
   cspeach team report               Lead: the combined workbook and status page, in reports
+  cspeach team export [--out <folder>] [--always | --never]   The CSV files for your own tools, in reports/exports (--always: with every report; --never: stop that)
   cspeach team leave                Stop recording
   cspeach files sort [--apply <plan>] [--clean <plan>]   Sort files from earlier builds into their folders (copies; --clean deletes checked originals)
   cspeach analyze project-context   Compare flag-on vs flag-off session metrics

package/dist/commands/help.js

@@ -6,6 +6,7 @@ import { paint } from '../renderer/theme.js';
 import { uiWidth, truncateToWidth } from '../renderer/ui-width.js';
 // I2's shortcuts table and note — one source for the `?` sheet and /help.
 import { SHORTCUT_ROWS, SHORTCUTS_NOTE } from '../ui/widgets/shortcuts-sheet.js';
+import { BUNDLED_RUNS } from '../runs/runs.js';
 // Workflow order: plan → understand → modify → build → upgrade → ship.
 const CATEGORY_ORDER = [
     'Pre-Coding',
@@ -26,11 +27,20 @@ const fixed = (s) => () => s;
  * follows the cost display mode (credits for managed customers).
  */
 export const HELP_GROUPS = [
+    // Guided runs (spec 2026-10-08 §3.2) — above "Work on SAP", one row per
+    // declared run, from the bundled declarations (RUN.md), never from code.
+    { title: 'Guided runs', rows: BUNDLED_RUNS.map((r) => ({
+            name: r.entry,
+            description: fixed(`${r.title} — ${r.steps.length} steps. Also: ${r.alias}`),
+            // The RUN.md body paragraph (spec §3.1, "one paragraph for /help").
+            detail: r.paragraph,
+        })) },
     { title: 'Work on SAP', rows: [
             { name: '/transport [TR]', description: fixed('View or set the transport for this session') },
             { name: '/mode [advisory|gated|auto]', description: fixed('Set the write mode (Shift+Tab also cycles)') },
             { name: '/safety-mode on|off|status', description: fixed('Turn the Forge Rule confirmation cards on or off') },
             { name: '/rewind', description: fixed('Undo a write from this session (Esc Esc)') },
+            { name: '/rules', description: fixed("View or change the team project's decision rules") },
             { name: '/reroute <skill>', description: fixed('Re-run your last prompt with a different skill') },
         ] },
     { title: 'Local files', rows: [
@@ -102,8 +112,13 @@ export function printHelp(emit = (s) => console.log(s)) {
     for (const group of HELP_GROUPS) {
         emit('');
         emit(groupTitle(group.title));
-        for (const r of group.rows)
+        for (const r of group.rows) {
             emit(row(r.name, r.description()));
+            // A row's detail (a guided run's paragraph) wraps in full, dim, under the description column.
+            if (r.detail)
+                for (const l of wrapDescription(r.detail, descWidth, Number.MAX_SAFE_INTEGER))
+                    emit(`${continuationIndent}${paint('dim', l)}`);
+        }
         if (group.title === 'Work on SAP') {
             // Skills live under "Work on SAP", one dim sub-heading per category.
             for (const category of CATEGORY_ORDER) {

package/dist/commands/plan-chain.js

@@ -28,6 +28,7 @@ import { readProjectFile } from '../projects/status.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { statusesFromItems, computeNextPhaseForRun, isPhaseSatisfiedForRun, planCompletionLines, phaseDisplayTitle, } from '../projects/plan-run.js';
 import { savedLocation } from '../projects/saved-lines.js';
+import { afterPlanComplete } from '../journey/rebuild.js';
 import { clearPlanGrant, getPlanGrant, getGrantTransport, installPlanGrant, noteDeltaOffered, offeredDeltaObjects, planGrantAllowed, } from '../approvals/plan-grant.js';
 import { collectPlannedObjects, plannedObjectFacts } from '../projects/plan-objects.js';
 import { isDeployPhase } from '../projects/plan-lane.js';
@@ -251,6 +252,8 @@ async function postPhaseChain(args) {
             const nextAfter = computeNextPhaseForRun(after.content.phases, st);
             if (built && !nextAfter) {
                 args.log('', ...planCompletionLines(after.content.phases));
+                // Step 2 (C5): a rebuild whose plan this is now reads "built, not yet checked".
+                await afterPlanComplete(cur);
                 args.log(`Plan file: ${savedLocation(cur, args.cwd)}`);
             }
             else if (!built && auditFailed && !stopShown) {

package/dist/commands/plan-gate.js

@@ -38,8 +38,17 @@ let journeyRunActive = false;
 export function setJourneyRunActive(active) {
     journeyRunActive = active;
 }
+/* Step 2 (final review I2) — the rebuild hand-off's share. The journey ends
+ * (its share off) BEFORE it queues the rebuild skill; that queued turn is
+ * auto-dispatched, so it must not inherit auto_approve either. Set just before
+ * the queue, cleared after the first top-level turn that follows the hand-off
+ * turn (journey/rebuild.ts afterRebuildTurn), whatever its skill. */
+let rebuildRunActive = false;
+export function setRebuildRunActive(active) {
+    rebuildRunActive = active;
+}
 export function isGuardedRunActive() {
-    return guardedRunActive || journeyRunActive;
+    return guardedRunActive || journeyRunActive || rebuildRunActive;
 }
 /* ── plan-phase read-only enforcement (Task 7, 2026-07-03) ─────────────────
  * Module-level flag consulted by tools/subagent/agent_run.ts. The REPL sets

package/dist/commands/plan-resume.js

@@ -53,6 +53,7 @@ import { acquireRunLease, releaseRunLease } from '../projects/run-lease.js';
 import { validateEnvelope } from '../projects/validate.js';
 import { collectTurnAssistantText } from '../agent/turn-assistant-text.js';
 import { getAuthorIdentity } from '../agent/loop.js';
+import { afterPlanComplete } from '../journey/rebuild.js';
 import { DEFAULT_PLAN_MODE } from './plan-gate.js';
 import { FLOORPLAN_TO_TEMPLATE } from '../tools/fiori/floorplan-map.js';
 import { getCurrentTransport, setCurrentTransport } from '../repl/current-transport.js';
@@ -1019,6 +1020,9 @@ export async function finishPlanResume(args) {
         if (!next && provisionalPhases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit))) {
             // C2 (D24): same chain as preparePlanResume — single source in plan-run.ts.
             args.log(...planCompletionLines(provisionalPhases));
+            // Step 2 (C5): the live run finished — a rebuild whose plan this is reads built.
+            // Not at the re-opened complete plan above (preparePlanResume).
+            await afterPlanComplete(args.prepared.path);
         }
         else if (!next) {
             const blocked = provisionalPhases.filter((p) => statuses[p.id] === 'blocked').map((p) => phaseDisplayTitle(p, provisionalPhases));

package/dist/commands/team-rules.js

@@ -0,0 +1,187 @@
+/**
+ * `cspeach team rules …` — the decision rules, read and changed from the
+ * terminal (step 2, Task 10; spec 2026-10-08 §7 D7). `/rules` in a session
+ * (repl/rules-menu.ts) saves through the same `saveRuleEdit`.
+ *
+ *   rules                                  anyone: the numbered table
+ *   rules on|off <id>                      lead
+ *   rules set <id> --min-findings N | --max-findings N | --then <disposition> [--target L] | --target L|none
+ *   rules add --template <name>            lead
+ *   rules remove <id>                      lead
+ *   rules reset                            lead: the file names no rules again
+ *
+ * A save is the whole team project file, then renamed (every other key as it
+ * was), and one plan record in the lead's `plan/` so the change is a line of
+ * History and of the CSV events. Never reachable from a model tool.
+ */
+import path from 'node:path';
+import { readDecisionRules } from '@cspeach/register-core';
+import { RegisterError, readProjectFile, TEAM_FILE } from '../register/store.js';
+import { writeLeadRecord } from '../register/records.js';
+import { writeWhole } from '../register/write-whole.js';
+import { addFromTemplate, removeRule, resetRules, rulesTableLines, setOutcome, setTarget, setThreshold, toggleRule, RULE_TEMPLATES, } from '../register/rules-edit.js';
+import { flags, joinedOrThrow, requireLead, whoAmI } from './team.js';
+import { reasonFrom } from './team-plan.js';
+export const RULES_USAGE = 'Usage: cspeach team rules [on|off <id> | set <id> --min-findings N | --max-findings N | --then keep|fix|rebuild|retire-candidate [--target A-D] '
+    + '| --target A-D|none | add --template <name> | remove <id> | reset] [--reason "<why>"]';
+const SET_USAGE = 'Usage: cspeach team rules set <id> --min-findings N | --max-findings N | --then keep|fix|rebuild|retire-candidate [--target A-D] | --target A-D|none';
+const SET_OPTIONS = ['min-findings', 'max-findings', 'then', 'target', 'reason'];
+/** The one line someone who is not the lead gets for any change. */
+export const rulesRefusal = (lead) => `Only the lead (${lead}) changes the rules. You can view them: cspeach team rules`;
+/** The joined team project and its rules as the next read will see them. */
+export function rulesNow(projectDir) {
+    const project = readProjectFile(projectDir);
+    return { project, ...readDecisionRules(project) };
+}
+/** Lead only, in the rules' own words; `requireLead` decides who the lead is. */
+export function requireRulesLead(project, deps) {
+    try {
+        requireLead(project, deps);
+    }
+    catch (e) {
+        if (e instanceof RegisterError)
+            throw new RegisterError(rulesRefusal(project.lead.name));
+        throw e;
+    }
+}
+/** An edit over rules the file holds but this build cannot read would quietly throw them away; only reset may go ahead. */
+export function refuseUnreadable(warning, edit) {
+    if (!warning || edit === 'reset')
+        return;
+    throw new RegisterError(`${warning.replace(/, so the default rules are used\.$/, '.')} Fix the file, or start again from the defaults: cspeach team rules reset`);
+}
+export const stampFor = (deps) => ({ by: whoAmI(deps), at: (deps.now?.() ?? new Date()).toISOString() });
+/** The rules changed between the card and the save (a sync, a second terminal): nothing is written. */
+export const RULES_CHANGED_LINE = 'The rules changed since you opened them. Open /rules again.';
+/** Said before the first save of a project whose file names no rules yet (review round 1). */
+export const DEFAULTS_PINNED_LINE = "Saving writes all rules into this project's file; later CSPeach default changes will not apply here until you Restore defaults.";
+/**
+ * Save one edit: the team project file whole, then renamed — `decisionRules`
+ * replaced, or removed on reset, every other key as it was — then the plan
+ * record that puts it in History. Returns the lines to print.
+ *
+ * The rules in the file must still be the ones the edit was made from: if a
+ * sync or a second terminal changed them meanwhile, nothing is written. A
+ * History record that cannot be written after the file was saved is said, not
+ * hidden; the file keeps the change (it is what the person confirmed).
+ */
+export function saveRuleEdit(projectDir, edit, deps, reason = '') {
+    const joined = joinedOrThrow();
+    const project = readProjectFile(projectDir);
+    requireRulesLead(project, deps);
+    if (edit.basis && JSON.stringify(readDecisionRules(project).rules) !== JSON.stringify(edit.basis)) {
+        throw new RegisterError(RULES_CHANGED_LINE);
+    }
+    const next = { ...project };
+    if (edit.rules === null)
+        delete next.decisionRules;
+    else
+        next.decisionRules = edit.rules;
+    writeWhole(path.join(projectDir, TEAM_FILE), `${JSON.stringify(next, null, 2)}\n`);
+    const lines = [`✓ Saved. ${edit.summary}`];
+    try {
+        writeLeadRecord(path.join(projectDir, 'plan'), project.projectId, 'plan', {
+            action: 'rules',
+            rules: { change: edit.change, ...(edit.id ? { id: edit.id } : {}), summary: edit.summary, before: edit.before, after: edit.after },
+            ...(reason ? { reason } : {}),
+        }, [], { name: whoAmI(deps), writer: joined.writerId }, {
+            ...(deps.now ? { now: deps.now() } : {}), ...(deps.rand ? { rand: deps.rand } : {}),
+        });
+    }
+    catch (e) {
+        const why = (e instanceof Error ? e.message : String(e)).split('\n')[0].replace(/[\u0000-\u001f\u007f]/g, ' ').slice(0, 200);
+        lines.push(`! Saved, but no History line was written: ${why}`);
+    }
+    return lines;
+}
+function onlyOptions(opts, known, usage) {
+    for (const name of Object.keys(opts))
+        if (!known.includes(name))
+            throw new RegisterError(`Unknown option --${name}.\n${usage}`);
+}
+/** A flag that needs a value got none: say which, never read "true" as the value. */
+function valueOf(opts, name) {
+    const v = opts[name];
+    return v === 'true' ? '' : v;
+}
+export function rulesCommand(args, deps) {
+    const { positional, opts } = flags(args);
+    const [verb, id, ...extra] = positional;
+    const joined = joinedOrThrow();
+    const now = rulesNow(joined.projectDir);
+    if (!verb || verb === 'list' || verb === 'show') {
+        onlyOptions(opts, [], RULES_USAGE);
+        for (const line of rulesTableLines(now.rules, now.from, now.warning))
+            deps.print(line);
+        deps.print(`Change them in a session with /rules, or: cspeach team rules on|off|set|add|remove|reset   (lead: ${now.project.lead.name})`);
+        return 0;
+    }
+    if (!['on', 'off', 'set', 'add', 'remove', 'reset'].includes(verb))
+        throw new RegisterError(RULES_USAGE);
+    requireRulesLead(now.project, deps);
+    const reason = reasonFrom(opts, false);
+    const stamp = stampFor(deps);
+    let edit;
+    switch (verb) {
+        case 'on':
+        case 'off':
+        case 'remove': {
+            onlyOptions(opts, ['reason'], RULES_USAGE);
+            if (!id || extra.length)
+                throw new RegisterError(RULES_USAGE);
+            refuseUnreadable(now.warning, verb === 'remove' ? 'remove' : verb);
+            edit = verb === 'remove' ? removeRule(now.rules, id) : toggleRule(now.rules, id, verb === 'on', stamp);
+            break;
+        }
+        case 'set': {
+            onlyOptions(opts, SET_OPTIONS, SET_USAGE);
+            if (!id || extra.length)
+                throw new RegisterError(SET_USAGE);
+            refuseUnreadable(now.warning, 'set');
+            const min = valueOf(opts, 'min-findings');
+            const max = valueOf(opts, 'max-findings');
+            const then = valueOf(opts, 'then');
+            const target = valueOf(opts, 'target');
+            const counts = min !== undefined || max !== undefined;
+            if (!counts && then === undefined && target === undefined)
+                throw new RegisterError(SET_USAGE);
+            if (counts && (then !== undefined || target !== undefined))
+                throw new RegisterError(`One change at a time: a threshold, or the outcome.\n${SET_USAGE}`);
+            if (counts) {
+                edit = setThreshold(now.rules, id, { ...(min !== undefined ? { minFindings: min } : {}), ...(max !== undefined ? { maxFindings: max } : {}) }, stamp);
+            }
+            else if (then !== undefined) {
+                const t = target === undefined ? undefined : target.toLowerCase() === 'none' ? null : target.toUpperCase();
+                edit = setOutcome(now.rules, id, then.toLowerCase(), stamp, t);
+            }
+            else {
+                edit = setTarget(now.rules, id, target.toLowerCase() === 'none' ? null : target.toUpperCase(), stamp);
+            }
+            break;
+        }
+        case 'add': {
+            onlyOptions(opts, ['template', 'reason'], RULES_USAGE);
+            const template = valueOf(opts, 'template');
+            if (id || !template)
+                throw new RegisterError(`Usage: cspeach team rules add --template <name>   Templates: ${Object.keys(RULE_TEMPLATES).join(', ')}`);
+            refuseUnreadable(now.warning, 'add');
+            edit = addFromTemplate(now.rules, template, stamp);
+            break;
+        }
+        default: {
+            onlyOptions(opts, ['reason'], RULES_USAGE);
+            if (id)
+                throw new RegisterError(RULES_USAGE);
+            if (now.from === 'default' && !now.warning) {
+                deps.print('The rules are the defaults already. Nothing was written.');
+                return 0;
+            }
+            edit = resetRules(now.rules);
+        }
+    }
+    for (const line of saveRuleEdit(joined.projectDir, edit, deps, reason))
+        deps.print(line);
+    if (now.from === 'default' && edit.rules !== null)
+        deps.print(`  ${DEFAULTS_PINNED_LINE}`);
+    return 0;
+}