@cspeach/cli 1.1.31 → 1.1.32

package/dist/repl/rules-menu.js

@@ -0,0 +1,177 @@
+import { DEFAULTS_PINNED_LINE, refuseUnreadable, requireRulesLead, rulesNow, rulesRefusal, saveRuleEdit, stampFor } from '../commands/team-rules.js';
+import { activeProject, RegisterError } from '../register/store.js';
+import { addFromTemplate, addProposed, removeRule, resetRules, ruleWords, rulesTableLines, setOutcome, setThreshold, toggleRule, RULE_TEMPLATES, } from '../register/rules-edit.js';
+import { clearRuleProposal, ruleProposalFor } from '../register/rule-proposal.js';
+export const NOT_JOINED_LINE = 'This laptop has not joined a team project. Run: cspeach team join <folder>';
+const NOTHING_SAVED = 'Nothing was saved.';
+/** A menu that never ends would hold the session; a lead does a handful of changes at a sitting. */
+const MAX_ROUNDS = 100;
+const DISPOSITION_CHOICES = [
+    { value: 'keep', label: 'Keep' }, { value: 'fix', label: 'Fix' }, { value: 'rebuild', label: 'Rebuild' }, { value: 'retire-candidate', label: 'Retire candidate' },
+];
+let cardSeq = 0;
+const card = (title, choices, aliases = {}, facts) => ({
+    id: `rules-${(cardSeq += 1)}`, tag: 'QUESTION', title, choices, initial: 0, aliases, ...(facts ? { facts } : {}),
+});
+const pick = async (o, req) => {
+    const res = await o.confirm(req);
+    return res.cancelled ? null : res.value;
+};
+/** The change for one rule, from its own menu; null = back, or nothing to save. */
+async function ruleChange(o, rule, rules) {
+    const stamp = stampFor(o.deps);
+    const what = await pick(o, card(`Rule ${rule.id}: ${ruleWords(rule)}`, [
+        { value: 'toggle', label: rule.on ? 'Turn off' : 'Turn on' },
+        { value: 'threshold', label: 'Change threshold' },
+        { value: 'outcome', label: 'Change outcome' },
+        { value: 'remove', label: 'Remove' },
+        { value: 'back', label: 'Back' },
+    ], { '1': 'toggle', '2': 'threshold', '3': 'outcome', '4': 'remove', b: 'back' }, rule.note ? [`Why: ${rule.note}`] : undefined));
+    switch (what) {
+        case 'toggle': return toggleRule(rules, rule.id, !rule.on, stamp);
+        case 'remove': return removeRule(rules, rule.id);
+        case 'threshold': {
+            // A rule that only caps the count is changed at its cap; any other at its floor.
+            const atMost = rule.when.maxFindings !== undefined && rule.when.minFindings === undefined;
+            const counts = rule.when.maxFindings !== undefined || rule.when.minFindings !== undefined;
+            const answer = (await o.ask(atMost ? 'At most how many findings?'
+                : counts ? 'More than how many findings?' : 'Add a condition: more than how many findings?')).trim();
+            if (!/^\d+$/.test(answer)) {
+                if (answer)
+                    o.print('✗ The number of findings needs a whole number of 0 or more, for example 15.');
+                return null;
+            }
+            const n = Number(answer);
+            return setThreshold(rules, rule.id, atMost ? { maxFindings: n } : { minFindings: n + 1 }, stamp);
+        }
+        case 'outcome': {
+            const choices = [...DISPOSITION_CHOICES.filter((d) => d.value !== rule.then.disposition), { value: 'cancel', label: 'Cancel' }];
+            const to = await pick(o, card(`Rule ${rule.id}: what should it propose?`, choices));
+            return !to || to === 'cancel' ? null : setOutcome(rules, rule.id, to, stamp);
+        }
+        default: return null;
+    }
+}
+async function addChange(o, rules) {
+    const names = Object.keys(RULE_TEMPLATES);
+    const choices = [
+        ...names.map((n) => ({ value: n, label: `${n}: ${ruleWords({ id: '', on: true, ...RULE_TEMPLATES[n] })}` })),
+        { value: 'cancel', label: 'Cancel' },
+    ];
+    const name = await pick(o, card('Add which rule? It goes last: rules are tried in order.', choices));
+    return !name || name === 'cancel' ? null : addFromTemplate(rules, name, stampFor(o.deps));
+}
+export async function runRulesMenu(o) {
+    const joined = activeProject();
+    if (!joined) {
+        o.print(NOT_JOINED_LINE);
+        return;
+    }
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+        const now = rulesNow(joined.projectDir);
+        for (const line of rulesTableLines(now.rules, now.from, now.warning))
+            o.print(line);
+        try {
+            requireRulesLead(now.project, o.deps);
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(rulesRefusal(now.project.lead.name));
+            return;
+        }
+        // A rule proposed from words (rules_propose) waits here until the person saves it.
+        const proposed = ruleProposalFor(joined.projectId);
+        const choices = [
+            ...now.rules.map((r) => ({ value: `rule:${r.id}`, label: `${r.id} · ${ruleWords(r)}${r.on ? '' : ' (off)'}` })),
+            ...(proposed ? [{ value: 'proposed', label: `Add the proposed rule: ${proposed.words}` }] : []),
+            { value: 'add', label: 'Add a rule' }, { value: 'reset', label: 'Restore defaults' }, { value: 'done', label: 'Done' },
+        ];
+        const aliases = Object.fromEntries(choices.map((c, i) => [String(i + 1), c.value]));
+        aliases.d = 'done';
+        const choice = await pick(o, card('Decision rules: pick a rule to change it, or', choices, aliases));
+        if (!choice || choice === 'done')
+            return;
+        let edit = null;
+        try {
+            if (choice === 'add')
+                edit = await addChange(o, now.rules);
+            else if (choice === 'proposed' && proposed)
+                edit = addProposed(now.rules, proposed.proposal, stampFor(o.deps));
+            else if (choice === 'reset') {
+                if (now.from === 'default' && !now.warning) {
+                    o.print('The rules are the defaults already.');
+                    continue;
+                }
+                edit = resetRules(now.rules);
+            }
+            else {
+                const rule = now.rules.find((r) => `rule:${r.id}` === choice);
+                if (rule)
+                    edit = await ruleChange(o, rule, now.rules);
+            }
+            if (edit)
+                refuseUnreadable(now.warning, edit.change);
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(`✗ ${e.message}`);
+            continue;
+        }
+        if (!edit)
+            continue;
+        // The first save of a project on the defaults writes every rule into its file: said on the card.
+        const pins = now.from === 'default' && edit.rules !== null;
+        const save = await pick(o, card(edit.card, [{ value: 'save', label: 'Save' }, { value: 'cancel', label: 'Cancel' }], { s: 'save', c: 'cancel' }, pins ? [DEFAULTS_PINNED_LINE] : undefined));
+        if (save !== 'save') {
+            o.print(NOTHING_SAVED);
+            continue;
+        }
+        try {
+            for (const line of saveRuleEdit(joined.projectDir, edit, o.deps))
+                o.print(line);
+            if (choice === 'proposed')
+                clearRuleProposal();
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(`✗ ${e.message}`);
+        }
+    }
+}
+/**
+ * The REPL's `/rules`: both submit paths (Ink and classic) call this. The card
+ * is the Ink card slot when it has a listener, else a typed line (classic); the
+ * number question the same. Headless shows the table and no card.
+ */
+export async function runRulesSlash(trimmed, a) {
+    if (trimmed !== '/rules') {
+        a.emit('/rules takes no arguments — it opens the decision rules of the team project this laptop has joined');
+        return;
+    }
+    const { sessionTeamDeps } = await import('../journey/session-deps.js');
+    const { journeyAsk, journeyCardConfirm } = await import('../journey/chain.js');
+    const { deps } = a.headless ? await sessionTeamDeps({ headless: true }) : await sessionTeamDeps({ headless: false, signal: a.signal });
+    const ask = journeyAsk();
+    try {
+        await runRulesMenu({
+            deps: { ...deps, print: a.emit },
+            confirm: a.headless ? async () => ({ value: null, cancelled: true }) : journeyCardConfirm(a.emit),
+            // Esc on the question puts it away: nothing changes, the menu goes on.
+            ask: async (q) => { try {
+                return await ask(q);
+            }
+            catch {
+                return '';
+            } },
+            print: a.emit,
+        });
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        a.emit(`✗ ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`);
+    }
+}

package/dist/repl/slash-completer.js

@@ -36,6 +36,7 @@ const BUILTIN_COMMANDS = [
     '/ui',
     '/reroute',
     '/transport',
+    '/rules',
 ];
 /**
  * Build the full slash-command list once at module load. Skill commands

package/dist/repl/slash-picker.js

@@ -25,11 +25,12 @@ import { SKILL_CATALOG, SKILL_ALIASES } from '../skill-catalog.js';
 // 2026-06-11 — builtin list extracted to builtin-commands.ts (pure data)
 // so the router layer can check builtin heads without importing inquirer.
 import { BUILTIN_ENTRIES } from './builtin-commands.js';
+import { partOfRun } from '../runs/runs.js';
 function buildCatalogue() {
-    const skillEntries = SKILL_CATALOG.map((s) => ({
-        name: `/${s.name}`,
-        description: s.description,
-    }));
+    const skillEntries = SKILL_CATALOG.map((s) => {
+        const part = partOfRun(s.name);
+        return { name: `/${s.name}`, description: part ? `${s.description} · part of ${part}` : s.description };
+    });
     return [...BUILTIN_ENTRIES, ...skillEntries].sort((a, b) => a.name.localeCompare(b.name));
 }
 const ALL_ENTRIES = buildCatalogue();

package/dist/repl.js

@@ -21,7 +21,8 @@ import { createOfflineAdtClient } from './sap/offline-adt-client.js';
 import { STANDALONE_ALIAS } from './tools/index.js';
 import { resumeStandaloneDecision, applySystemSwitch } from './repl/resume-standalone.js';
 import { clearAppFlow } from './lane/app-flow.js';
-import { clearJourneyFlow, isJourneyHop, journeyHopLine } from './journey/flow.js';
+import { clearJourneyFlow } from './journey/flow.js';
+import { createDispatchSlot, queuedStepView } from './session/queued-step.js';
 import { applyResumedSkill, isShortFollowUp } from './router/resume-routing.js';
 import { readableInterruptReason, isUserStopReason } from './session/interrupt-reason.js';
 import { getStore } from './auth/api-key.js';
@@ -84,6 +85,8 @@ import { maybeOfferAbapforgeMigration } from './projects/migration.js';
 import { shouldOfferAbapforgeMigration } from './projects/workspace-retire.js';
 import { slashCompleter } from './repl/slash-completer.js';
 import { openSlashPicker, isExactSlashMatch } from './repl/slash-picker.js';
+import { detectRunStart } from './runs/front-door.js';
+import { shadowStart, guardRunLabel } from './runs/shadow.js';
 import { openAtPicker, pendingAtTokenPrefix } from './repl/at-picker.js';
 import { atCompleter } from './repl/at-completer.js';
 import { appendHistoryEntry, readHistoryEntries } from './repl/history.js';
@@ -172,6 +175,7 @@ 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/rules_propose.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
@@ -893,11 +897,11 @@ export async function runRepl(opts) {
     // scope so both the Ink and readline branches share the same instance.
     // Cleared at the start of every consume cycle so a stale value never
     // re-fires.
-    let pendingDispatchValue = null;
-    const pendingDispatchAccessor = {
-        get: () => pendingDispatchValue,
-        set: (cmd) => { pendingDispatchValue = cmd; },
-    };
+    // Audit M-2 — the slot also carries WHO queued the command: a CSPeach source
+    // (journey, rebuild hand-off, app chain, plan chain) sets its origin, and both
+    // branches render it through queuedStepView — never as "You › <the command>".
+    // Consumers take() the command and its origin together.
+    const pendingDispatchAccessor = createDispatchSlot();
     // Task 13 fix round — the plan chain queues through planHops.queue, which
     // marks the command as an in-run hop (one progress line, no guarded
     // notice). Anything else in the slot (the /abap-app start, a skill switch)
@@ -995,7 +999,7 @@ export async function runRepl(opts) {
         /** Auto-dispatch of the next plan phase, unless a post-turn cancel stopped it. */
         // Task 13 fix round — `planHop` travels WITH the command into handleSubmit,
         // so a refused submit can never leave a stale hop mark behind.
-        const autoDispatch = (cmd, planHop = false) => {
+        const autoDispatch = (cmd, planHop = false, queued = null) => {
             // Round 4 item 9b — the exit is already under way: start nothing new.
             // Final review B-I2 — `/exit` typed mid-turn (exitAfterTurn) stops it too.
             const decision = autoDispatchDecision({ done, exitRequested: exitAfterTurn, cancelPending: pendingCancel.pending }, cmd);
@@ -1007,11 +1011,11 @@ export async function runRepl(opts) {
                 return;
             }
             // Task 13 — no echo for a plan hop: the chain already said "Next: <title>".
-            // Journey hops (Task 3) — the journey already said its step line.
-            const notice = isJourneyHop(session, cmd) ? null : autoRoutedNotice(cmd);
+            // Audit M-2 — no "Auto-routed:" for any command CSPeach queued itself.
+            const notice = queued ? null : autoRoutedNotice(cmd);
             if (notice)
                 chunkEmitter.emit('chunk', formatInfo(notice));
-            setImmediate(() => { void handleSubmit(cmd, { planHop }); });
+            setImmediate(() => { void handleSubmit(cmd, { planHop, queued }); });
         };
         // BUG-2b — the actual dispatch. Wrapped by handleSubmit (below) which
         // owns the single-flight reserve()/release() lifecycle. All re-entrant
@@ -1037,10 +1041,14 @@ export async function runRepl(opts) {
             // new turn's content touched with no separator and looked like
             // garbled overlap).
             if (trimmed !== '/exit' && trimmed !== '/quit') {
-                // Rehearsal fix 1 — a journey hop was queued by CSPeach, not typed: one
-                // plain journey line, never "You › <the command>".
-                const hopLine = journeyHopLine(session, trimmed);
-                chunkEmitter.emit('chunk', hopLine ? `\n${hopLine}\n` : formatPromptEcho(trimmed, process.stdout.columns || 80));
+                // Rehearsal fix 1 + audit M-2 — a command CSPeach queued (journey,
+                // rebuild hand-off, app chain, plan chain) is its own step on screen:
+                // its one line, never "You › <the command>".
+                const view = queuedStepView(submitOpts?.queued);
+                if (view.echo)
+                    chunkEmitter.emit('chunk', formatPromptEcho(trimmed, process.stdout.columns || 80));
+                else if (view.line)
+                    chunkEmitter.emit('chunk', `\n${view.line}\n`);
             }
             if (trimmed === '/exit' || trimmed === '/quit') {
                 done = true;
@@ -1275,6 +1283,19 @@ export async function runRepl(opts) {
                 rewindEmitter.emit('open');
                 return;
             }
+            // /rules — the team project's decision rules (step 2, Task 10, D7): table, menu, card before every save.
+            if (trimmed === '/rules' || trimmed.startsWith('/rules ')) {
+                const { runRulesSlash } = await import('./repl/rules-menu.js');
+                const rulesAbort = new AbortController();
+                currentTurnAbort = rulesAbort;
+                try {
+                    await runRulesSlash(trimmed, { emit: (line) => chunkEmitter.emit('chunk', line + '\n'), headless: isHeadless(), signal: rulesAbort.signal });
+                }
+                finally {
+                    currentTurnAbort = null;
+                }
+                return;
+            }
             // /safety-mode on|off — structured Forge Rule confirmation cards.
             // UX-5 #1 (2026-06-12): handleSafetyModeCommand existed (unit-tested)
             // but no REPL path ever routed to it — the toggle was unreachable at
@@ -1300,6 +1321,25 @@ export async function runRepl(opts) {
                     effectiveInput = expansion.text;
                 }
             }
+            // Guided runs — the one front door for Ink, classic and one-shot:
+            // the /run verb (rewritten to its alias), then today's trigger. The
+            // trigger still decides (spec §4 step 2); the dispatch below is unchanged.
+            const door = await detectRunStart(effectiveInput, {
+                cwd: process.cwd(), session, resume: true,
+                // Shadow (spec §4 step 2): the trigger decided; in managed mode ask our
+                // router the same text, with the shadow-only text, and count whether it
+                // agrees. Not awaited; counts only; nothing on screen.
+                onFreeTextStart: (text) => void shadowStart(text, 'run-clean-core', {
+                    classify: (p, c) => classifyPrompt(p, c, { shadowRuns: true }),
+                    context: { sap_system: selectedAlias, last_skill: session.last_skill ?? null, last_object: session.last_object ?? null },
+                    llmMode: cfg.llm?.mode,
+                }),
+            });
+            if (door.kind === 'line') {
+                chunkEmitter.emit('chunk', door.line + '\n');
+                return;
+            }
+            effectiveInput = door.input;
             const parsed = parseShortcut(effectiveInput);
             // D35 (2026-06-11) — explicit slash naming a skill that isn't in the
             // catalog: print the notice ("did you mean" / builtin-with-args) and
@@ -1310,39 +1350,33 @@ export async function runRepl(opts) {
                 return;
             }
             // Guided clean-core journey (Task 3) — "start clean core on ZFI_AR",
-            // "/abap-clean-core start ZFI_AR", "carry on" in a project folder.
-            // Detected here, before the classifier; any other line is untouched.
-            {
-                const { detectJourney } = await import('./journey/trigger.js');
-                const journey = detectJourney(effectiveInput, { cwd: process.cwd(), session });
-                if (journey) {
-                    const { runJourneyEntry } = await import('./repl/journey-entry.js');
-                    const journeyAbort = new AbortController();
-                    currentTurnAbort = journeyAbort;
-                    interruptCount = 0;
-                    if (pendingCancel.applyTo(journeyAbort))
-                        interruptCount = 1;
-                    turnStatusEmitter.start('clean core');
-                    try {
-                        await runJourneyEntry(journey, {
-                            session, cwd: process.cwd(), adt, sapAlias: selectedAlias, standalone, headless: isHeadless(),
-                            emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
-                            queueNext: (cmd) => pendingDispatchAccessor.set(cmd),
-                            signal: journeyAbort.signal,
-                        });
-                    }
-                    finally {
-                        turnStatusEmitter.stop();
-                        currentTurnAbort = null;
-                        postTurn = true;
-                    }
-                    const queued = pendingDispatchAccessor.get();
-                    if (queued) {
-                        pendingDispatchAccessor.set(null);
-                        autoDispatch(queued);
-                    }
-                    return;
+            // "/abap-clean-core start ZFI_AR", "/run clean-core ZFI_AR", "carry on"
+            // in a project folder. Detected above, before the classifier.
+            if (door.kind === 'run') {
+                const { runJourneyEntry } = await import('./repl/journey-entry.js');
+                const journeyAbort = new AbortController();
+                currentTurnAbort = journeyAbort;
+                interruptCount = 0;
+                if (pendingCancel.applyTo(journeyAbort))
+                    interruptCount = 1;
+                turnStatusEmitter.start('clean core');
+                try {
+                    await runJourneyEntry(door.trigger, {
+                        session, cwd: process.cwd(), adt, sapAlias: selectedAlias, standalone, headless: isHeadless(),
+                        emit: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                        queueNext: (cmd, origin) => pendingDispatchAccessor.set(cmd, origin),
+                        signal: journeyAbort.signal,
+                    });
+                }
+                finally {
+                    turnStatusEmitter.stop();
+                    currentTurnAbort = null;
+                    postTurn = true;
                 }
+                const queued = pendingDispatchAccessor.take();
+                if (queued)
+                    autoDispatch(queued.cmd, false, queued.origin);
+                return;
             }
             // Record the prose body (post-shortcut stripping) for /reroute. Using
             // `parsed.prompt` rather than `trimmed` means:
@@ -1439,6 +1473,8 @@ export async function runRepl(opts) {
                             }
                             return;
                         }
+                        // Defensive (spec §4 step 2): a run label never dispatches in this release.
+                        c = guardRunLabel(c);
                         if (c.screenshot) {
                             chunkEmitter.emit('chunk', formatInfo(`Screenshot: ${c.screenshot}`));
                         }
@@ -1668,10 +1704,9 @@ export async function runRepl(opts) {
                         const { clearPlanGrant } = await import('./approvals/plan-grant.js');
                         clearPlanGrant();
                     }
-                    if (reauditDispatched) {
-                        pendingDispatchAccessor.set(null);
-                        autoDispatch(reauditDispatched, planHops.take(reauditDispatched));
-                    }
+                    const reaudit = pendingDispatchAccessor.take();
+                    if (reaudit)
+                        autoDispatch(reaudit.cmd, planHops.take(reaudit.cmd), reaudit.origin);
                     return;
                 }
                 // 2026-10-04 (continuous run) — a phase boundary is save + COMPACT:
@@ -2161,9 +2196,8 @@ export async function runRepl(opts) {
             // next-phase offer above queued the plan-resume it built itself.
             // Consume the slot and re-enter handleSubmit with that command —
             // no user keypress. The user's consent was the picker pick / y answer.
-            const dispatched = pendingDispatchAccessor.get();
+            const dispatched = pendingDispatchAccessor.take();
             if (dispatched) {
-                pendingDispatchAccessor.set(null);
                 // No context clear here: beginPlanPhaseContext (plan-boundary.ts,
                 // called in the plan-resume prepare branch of handleSubmit) is the
                 // single owner of the phase-boundary compaction — it runs for typed AND dispatched resumes,
@@ -2173,7 +2207,7 @@ export async function runRepl(opts) {
                 // resolves cleanly before the next one starts. Recursion via
                 // setImmediate keeps the call stack flat across long chains.
                 // (autoDispatch skips it when a post-turn Ctrl+C / /exit asked to stop.)
-                autoDispatch(dispatched, planHops.take(dispatched));
+                autoDispatch(dispatched.cmd, planHops.take(dispatched.cmd), dispatched.origin);
             }
         };
         // BUG-2b (2026-07-05 live smoke) — single-flight dispatch guard.
@@ -2819,23 +2853,26 @@ export async function runRepl(opts) {
         // consent was the picker pick, no Enter required. Cleared
         // immediately so a stale value never re-fires.
         classicPlanHop = false; // a typed line is never an in-run hop
-        const dispatchedCmd = pendingDispatchAccessor.get();
-        if (dispatchedCmd) {
-            pendingDispatchAccessor.set(null);
+        const classicQueued = pendingDispatchAccessor.take();
+        if (classicQueued) {
+            const dispatchedCmd = classicQueued.cmd;
             // No context clear here: beginPlanPhaseContext (plan-boundary.ts,
             // called in the plan-resume prepare branch below) is the single owner
             // of the phase-boundary compaction — it runs for typed AND dispatched resumes, and
             // only AFTER preparePlanResume succeeds, so a failed prepare never
             // destroys the session context.
             // Task 13 — no echo for a plan hop: the chain already said "Next: <title>".
+            // Audit M-2 — the Ink mirror: a command CSPeach queued is its own step
+            // (its line, or nothing when its source already said it), never "Auto-routed:".
             {
-                const n = isJourneyHop(session, dispatchedCmd) ? null : autoRoutedNotice(dispatchedCmd);
-                if (n)
-                    console.log(formatInfo(n).trimEnd());
-                // Rehearsal fix 1 — the journey hop says what CSPeach is doing (the Ink mirror).
-                const hop = journeyHopLine(session, dispatchedCmd);
-                if (hop)
-                    console.log(hop);
+                const view = queuedStepView(classicQueued.origin);
+                if (view.echo) {
+                    const n = autoRoutedNotice(dispatchedCmd);
+                    if (n)
+                        console.log(formatInfo(n).trimEnd());
+                }
+                else if (view.line)
+                    console.log(view.line);
                 classicPlanHop = planHops.take(dispatchedCmd);
             }
             line = dispatchedCmd;
@@ -3142,6 +3179,12 @@ export async function runRepl(opts) {
             console.log(chalk.cyan(msg));
             continue;
         }
+        // /rules — the team project's decision rules (step 2, Task 10, D7); cards are typed lines here.
+        if (trimmed === '/rules' || trimmed.startsWith('/rules ')) {
+            const { runRulesSlash } = await import('./repl/rules-menu.js');
+            await runRulesSlash(trimmed, { emit: (line) => console.log(line), headless: isHeadless(), signal: new AbortController().signal });
+            continue;
+        }
         // Task 3 (ux-wave3) — classic-mode /rewind: numbered inquirer list + confirm
         // + gated restore. Reuses the identical candidate collector and executor as
         // the Ink panel (executeRestore); only the surface differs.
@@ -3262,7 +3305,8 @@ export async function runRepl(opts) {
         // Pressing Enter twice used to clear, but users expected Enter
         // to be a no-op when there's nothing to submit, so the
         // double-Enter cancel was confusing.
-        if (resolvedTrimmed.startsWith('/')) {
+        // A bare /run falls through to its usage line below, like /help (M-1).
+        if (resolvedTrimmed.startsWith('/') && !/^\/run$/i.test(resolvedTrimmed)) {
             const splitIdx = resolvedTrimmed.search(/\s/);
             const bodyAfter = splitIdx === -1 ? '' : resolvedTrimmed.slice(splitIdx).trim();
             if (bodyAfter.length === 0) {
@@ -3305,6 +3349,23 @@ export async function runRepl(opts) {
                 resolvedTrimmed = expansion.text;
             }
         }
+        // Guided runs — the same front door as the Ink path: the /run verb
+        // (rewritten to its alias), then today's trigger. The trigger still
+        // decides (spec §4 step 2); the dispatch below is unchanged.
+        const door = await detectRunStart(resolvedTrimmed, {
+            cwd: process.cwd(), session, resume: true,
+            // Shadow (spec §4 step 2): same as the Ink path. Not awaited; counts only.
+            onFreeTextStart: (text) => void shadowStart(text, 'run-clean-core', {
+                classify: (p, c) => classifyPrompt(p, c, { shadowRuns: true }),
+                context: { sap_system: selectedAlias, last_skill: session.last_skill ?? null, last_object: session.last_object ?? null },
+                llmMode: cfg.llm?.mode,
+            }),
+        });
+        if (door.kind === 'line') {
+            console.log(door.line);
+            continue;
+        }
+        resolvedTrimmed = door.input;
         const parsed = parseShortcut(resolvedTrimmed);
         // D35 (2026-06-11) — explicit slash naming a skill that isn't in the
         // catalog: print the notice ("did you mean" / builtin-with-args) and
@@ -3317,29 +3378,25 @@ export async function runRepl(opts) {
         // Guided clean-core journey (Task 3) — classic mirror of the Ink entry.
         // Cards become one typed line here (no card listener); a queued step is
         // picked up by the loop-top dispatch consumer.
-        {
-            const { detectJourney } = await import('./journey/trigger.js');
-            const journey = detectJourney(resolvedTrimmed, { cwd: process.cwd(), session });
-            if (journey) {
-                const { runJourneyEntry } = await import('./repl/journey-entry.js');
-                const journeyAbort = new AbortController();
-                const onJourneySigint = () => { journeyAbort.abort(); };
-                turnInProgress = true;
-                rl.on('SIGINT', onJourneySigint);
-                try {
-                    await runJourneyEntry(journey, {
-                        session, cwd: process.cwd(), adt, sapAlias: selectedAlias, standalone, headless: isHeadless(),
-                        emit: (line) => console.log(line),
-                        queueNext: (cmd) => pendingDispatchAccessor.set(cmd),
-                        signal: journeyAbort.signal,
-                    });
-                }
-                finally {
-                    rl.removeListener('SIGINT', onJourneySigint);
-                    turnInProgress = false;
-                }
-                continue;
+        if (door.kind === 'run') {
+            const { runJourneyEntry } = await import('./repl/journey-entry.js');
+            const journeyAbort = new AbortController();
+            const onJourneySigint = () => { journeyAbort.abort(); };
+            turnInProgress = true;
+            rl.on('SIGINT', onJourneySigint);
+            try {
+                await runJourneyEntry(door.trigger, {
+                    session, cwd: process.cwd(), adt, sapAlias: selectedAlias, standalone, headless: isHeadless(),
+                    emit: (line) => console.log(line),
+                    queueNext: (cmd, origin) => pendingDispatchAccessor.set(cmd, origin),
+                    signal: journeyAbort.signal,
+                });
             }
+            finally {
+                rl.removeListener('SIGINT', onJourneySigint);
+                turnInProgress = false;
+            }
+            continue;
         }
         // Record the prose body (post-shortcut stripping) for /reroute. Using
         // `parsed.prompt` rather than `trimmed` means:
@@ -3400,6 +3457,8 @@ export async function runRepl(opts) {
                             throw err;
                         c = fallback;
                     }
+                    // Defensive (spec §4 step 2): a run label never dispatches in this release.
+                    c = guardRunLabel(c);
                     if (c.screenshot)
                         console.log(formatInfo(`Screenshot: ${c.screenshot}`).trimEnd());
                     // Fix 10 (2026-09-26): routing failed mid-skill → stay in the

package/dist/router/classifier.js

@@ -94,7 +94,7 @@ function transportKindOf(err) {
         return 'timeout';
     return 'network';
 }
-async function tryFetchOnce(proxyUrl, key, prompt, context, images = [], signal) {
+async function tryFetchOnce(proxyUrl, key, prompt, context, images = [], signal, shadowRuns = false) {
     // Review I2 — a cancel that landed before this call (e.g. while prompt
     // images were read) never fires the 'abort' event: honour it here.
     if (signal?.aborted)
@@ -111,7 +111,10 @@ async function tryFetchOnce(proxyUrl, key, prompt, context, images = [], signal)
                 'Authorization': `Bearer ${key}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify(images.length > 0 ? { prompt, context, images } : { prompt, context }),
+            // Guided runs (spec §4 step 2): a shadow call asks the proxy for the
+            // shadow-only router text; a live call's body is unchanged.
+            body: JSON.stringify(shadowRuns ? { prompt, context, shadow: 'runs' }
+                : images.length > 0 ? { prompt, context, images } : { prompt, context }),
             signal: ctrl.signal,
         });
     }
@@ -188,7 +191,8 @@ export async function classifyPrompt(prompt, context, opts = {}) {
         throw new Error('no_api_key');
     if (opts.signal?.aborted)
         throw routingCancelled();
-    const images = await promptImages(prompt, opts.cwd ?? process.cwd());
+    // A shadow call never sends images (spec §4 step 2): text only.
+    const images = opts.shadowRuns ? [] : await promptImages(prompt, opts.cwd ?? process.cwd());
     if (opts.signal?.aborted)
         throw routingCancelled();
     let r;
@@ -201,7 +205,7 @@ export async function classifyPrompt(prompt, context, opts = {}) {
     // they bubble through as before.
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
-            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context, images, opts.signal);
+            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context, images, opts.signal, opts.shadowRuns === true);
             break;
         }
         catch (err) {