@cspeach/cli 1.1.30 → 1.1.32

package/dist/repl.js

@@ -10,7 +10,7 @@ import { select, password as promptPassword } from './repl/themed-prompts.js';
 import { loadConfig, resolveLocalBuild, resolveStandalone, DEFAULT_CONFIG } from './config/loader.js';
 import { getLook, setLook, setBackground } from './renderer/look.js';
 import { applyColorMode } from './renderer/color-mode.js';
-import { startEarlyBrand, aliasSourceNote, panelsHintLine, panelsResumeLine, panelsStartTail, panelsInterruptedNote, formatPromptEcho } from './renderer/startup-lines.js';
+import { startEarlyBrand, aliasSourceNote, panelsHintLine, panelsResumeLine, panelsStartTail, panelsInterruptedNote, lastSessionHereLine, formatPromptEcho } from './renderer/startup-lines.js';
 import { formatAttention, formatFailure, formatInfo } from './renderer/notice-shape.js';
 import { formatPanel } from './renderer/panel-rows.js';
 import { sanitizeControlChars } from './renderer/sanitize.js';
@@ -21,6 +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 } 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';
@@ -79,10 +81,12 @@ import { registerReadline, withInquirer } from './repl/inquirer-guard.js';
 import { pipeRevivedStdin } from './repl/reset-tty-stdin.js';
 import { logsDir } from './config/paths.js';
 import { noticeLogPathFor, pruneNoticeLogs, setNoticeLogPath } from './renderer/notice-log.js';
-import { maybePromptWorkspaceMigration, maybeOfferAbapforgeMigration } from './projects/migration.js';
-import { findProjectRoot } from './projects/workspace.js';
+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';
@@ -170,12 +174,15 @@ 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/rules_propose.js';
 import './tools/subagent/_background-shared.js';
 import './tools/subagent/background_run.js';
 import './tools/subagent/monitor_emit.js';
 import './tools/subagent/schedule_draft_create.js';
 import './tools/subagent/agent_run.js';
 import './tools/subagent/read_agent.js';
+import { folderTag, currentFolderKey } from './session/project-match.js';
 const HISTORY_SIZE = 500;
 // Persistence (read + dedup-guarded append) lives in ./repl/history.ts —
 // the single writer shared with the Ink Footer (Task 8, ux-wave1).
@@ -390,22 +397,52 @@ export async function runRepl(opts) {
     const earlyBrand = getLook() === 'panels'
         ? startEarlyBrand({ version: CLI_VERSION, tty: process.stdout.isTTY === true, write: (s) => { process.stdout.write(s); } })
         : undefined;
+    // 2026-10-08 (Task 12) — once, tag sessions saved before folders existed so
+    // the lines below and the pickers see them. Both looks; capped, never throws.
+    try {
+        const { backfillSessionFolders } = await import('./session/backfill.js');
+        await backfillSessionFolders().catch(() => { });
+    }
+    catch { /* best effort */ }
     // v0.6 — surface interrupted sessions at startup so the developer doesn't
     // have to remember the session id from the crash UX. Like `git stash list`
     // for resilience: if you have any unfinished work, you see it immediately.
     // Skip when --resume is already in flight (the user is resuming right now).
+    // 2026-10-08 (sessions/folders) — both lines are scoped to THIS folder; the
+    // dim "Last session here" line points at `cspeach --continue`.
     if (!opts?.resumedSession) {
         try {
-            const { countInterruptedSessions } = await import('./session/store.js');
-            const n = await countInterruptedSessions();
+            const { countInterruptedSessions, latestSessionHere } = await import('./session/store.js');
+            const here = currentFolderKey(process.cwd());
+            const n = await countInterruptedSessions(here);
             if (n > 0) {
                 if (getLook() === 'panels')
                     startupNotices.push(panelsInterruptedNote(n) + '\n');
                 else
-                    console.log(formatAttention({ text: `You have ${n} interrupted session${n === 1 ? '' : 's'}`, next: 'cspeach --resume  (picks the right one from a list)' }));
+                    console.log(formatAttention({ text: `You have ${n} interrupted session${n === 1 ? '' : 's'}`, next: 'cspeach --resume  (this folder\'s sessions)' }));
+            }
+            const last = await latestSessionHere(here);
+            if (last) {
+                if (getLook() === 'panels')
+                    startupNotices.push(lastSessionHereLine(last) + '\n');
+                else
+                    console.log(lastSessionHereLine(last));
             }
         }
         catch { /* startup banner is best-effort */ }
+        // Task 11 — files left in old save locations: point to `cspeach files
+        // sort`, at most once per folder per day.
+        try {
+            const { legacyHintLine, claimLegacyHintToday } = await import('./projects/workspace.js');
+            const hint = legacyHintLine(process.cwd());
+            if (hint && claimLegacyHintToday(process.cwd())) {
+                if (getLook() === 'panels')
+                    startupNotices.push(formatAttention({ text: hint }));
+                else
+                    console.log(chalk.dim(hint));
+            }
+        }
+        catch { /* the hint is best-effort */ }
     }
     // Phase 2.1 of Track B — when CSPEACH_PROJECT_CONTEXT=on the dogfooder
     // is on the experimental enrichment path. Surface that visibly so they
@@ -726,7 +763,7 @@ export async function runRepl(opts) {
     // through the same role resolution new sessions use (after the awaited
     // served config), marks it 'predicted', saves, then stays pinned. Every
     // resume entry (picker, --resume <id>) lands here via session/resume.ts.
-    const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg));
+    const session = opts?.resumedSession ?? newSession(makeSessionId(), selectedAlias, null, resolveModelRole('session_default', cfg), folderTag(process.cwd()));
     // Round 6 item 4c — a resumed session keeps its skill for the first plain prompt.
     let resumeKeepsSkill = Boolean(opts?.resumedSession?.skill);
     // Round 7 item 8c — the footer shows a resumed session's spend at once.
@@ -860,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)
@@ -962,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);
@@ -974,10 +1011,11 @@ export async function runRepl(opts) {
                 return;
             }
             // Task 13 — no echo for a plan hop: the chain already said "Next: <title>".
-            const notice = 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
@@ -1003,7 +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') {
-                chunkEmitter.emit('chunk', 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;
@@ -1213,6 +1258,7 @@ export async function runRepl(opts) {
                 session.todos = [];
                 todoEmitter.emit('update', []);
                 clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
+                clearJourneyFlow(session); // Task 3 — and a clean-core journey
                 chunkEmitter.emit('chunk', '\n' + formatInfo('Fresh start · the next prompt picks a skill again'));
                 return;
             }
@@ -1237,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
@@ -1262,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
@@ -1271,6 +1349,35 @@ export async function runRepl(opts) {
             if (rejectUnknownSkill(parsed, (m) => chunkEmitter.emit('chunk', chalk.yellow(`\n${m}\n`)))) {
                 return;
             }
+            // Guided clean-core journey (Task 3) — "start clean core on ZFI_AR",
+            // "/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:
             //   - plain prose: `parsed.prompt === trimmed`, stored as-is
@@ -1366,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}`));
                         }
@@ -1595,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:
@@ -2088,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,
@@ -2100,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.
@@ -2355,6 +2462,17 @@ export async function runRepl(opts) {
         // sits in this folder. Best-effort: never blocks the prompt.
         if (!isHeadless()) {
             void (async () => {
+                // 2026-10-08 — one-time offer to retire the old `workspace_folder`
+                // setting, before the plan offer so the two never overlap.
+                try {
+                    const { maybeOfferWorkspaceRetire } = await import('./projects/workspace-retire.js');
+                    const { inkAwareConfirm } = await import('./agent/loop.js');
+                    await maybeOfferWorkspaceRetire({
+                        confirm: async (q) => (await inkAwareConfirm(q, { default: 'y' })) === 'y',
+                        log: (line) => chunkEmitter.emit('chunk', line + '\n'),
+                    });
+                }
+                catch { /* the offer is best-effort */ }
                 try {
                     const { offerContinueAtStartup, inkStartupChooser } = await import('./commands/plan-startup.js');
                     const { resolveWorkspacePath } = await import('./projects/workspace.js');
@@ -2363,6 +2481,7 @@ export async function runRepl(opts) {
                         return;
                     await offerContinueAtStartup({
                         workspaceDir: ws,
+                        cwd: process.cwd(),
                         sessionId: session.id,
                         sapAlias: session.sap_system ?? undefined,
                         choose: inkStartupChooser(),
@@ -2663,40 +2782,40 @@ export async function runRepl(opts) {
     registerReadline(rl, (v) => {
         suppressRlClose = v;
     }, { input: pasteInput });
-    // 2026-05-08: one-time workspace-default migration. The default workspace
-    // changed from `~/CSPeach/` to project-rooted `<git-root>/.cspeach/`.
-    // Existing users with files in ~/CSPeach/ get asked once how to handle
-    // them. After that the flag is set and this becomes a no-op.
-    // Wrapped in withInquirer because it opens a select() sub-prompt.
-    await maybePromptWorkspaceMigration({
-        prompt: async ({ fileCount, oldWorkspace, newWorkspace }) => withInquirer(() => select({
-            message: `Found ${fileCount} file(s) in ${oldWorkspace}. CSPeach now defaults to project-rooted workspaces — what should we do?`,
-            default: 'move',
-            choices: [
-                { value: 'move', name: `Move all to ${newWorkspace} (recommended for this project)` },
-                { value: 'keep_global', name: `Keep using ${oldWorkspace} as global workspace (pins config workspace_folder)` },
-                { value: 'leave', name: `Leave ${oldWorkspace} alone — start fresh in ${newWorkspace}` },
-            ],
-        })),
-        log: (line) => console.log(chalk.dim(line)),
-    });
+    // 2026-10-08: one-time offer to retire the old `workspace_folder` setting
+    // (files now save in the folder you start in). Best-effort, never blocks.
+    if (!isHeadless()) {
+        try {
+            const { maybeOfferWorkspaceRetire } = await import('./projects/workspace-retire.js');
+            const { inkAwareConfirm } = await import('./agent/loop.js');
+            await maybeOfferWorkspaceRetire({
+                confirm: async (q) => (await inkAwareConfirm(q, { default: 'y' })) === 'y',
+                log: (line) => console.log(chalk.dim(line)),
+            });
+        }
+        catch { /* best-effort */ }
+    }
     // 2026-06-15: one-time output-namespace migration. The customer-output
     // root was renamed from the dead-brand `.abapforge/` to `.cspeach/`.
     // Workspaces that still have a top-level `.abapforge/` get offered a
     // one-time merge-move into `.cspeach/`. The dual-read resolver keeps old
     // projects working if the user declines; "never" suppresses future offers.
-    await maybeOfferAbapforgeMigration(findProjectRoot(process.cwd()) ?? process.cwd(), {
-        prompt: async ({ legacyDir, newDir }) => withInquirer(() => select({
-            message: `Found legacy CSPeach outputs in ${legacyDir}. The output folder is now '.cspeach/'. Move them?`,
-            default: 'move',
-            choices: [
-                { value: 'move', name: `Move everything into ${newDir} (recommended)` },
-                { value: 'skip', name: `Not now — ask me again next time` },
-                { value: 'never', name: `Leave it and never ask again` },
-            ],
-        })),
-        log: (line) => console.log(chalk.dim(line)),
-    });
+    // 2026-10-08: solo folders only — a team folder must not merge into the
+    // shared team .cspeach, and a home start must not target the CLI home.
+    if (shouldOfferAbapforgeMigration(process.cwd())) {
+        await maybeOfferAbapforgeMigration(process.cwd(), {
+            prompt: async ({ legacyDir, newDir }) => withInquirer(() => select({
+                message: `Found legacy CSPeach outputs in ${legacyDir}. The output folder is now '.cspeach/'. Move them?`,
+                default: 'move',
+                choices: [
+                    { value: 'move', name: `Move everything into ${newDir} (recommended)` },
+                    { value: 'skip', name: `Not now — ask me again next time` },
+                    { value: 'never', name: `Leave it and never ask again` },
+                ],
+            })),
+            log: (line) => console.log(chalk.dim(line)),
+        });
+    }
     // 2026-10-04 (spec §3.5) — "Continue '<plan>'?" (classic: numbered
     // choices, Enter = the first). Continue queues the resume for the loop.
     if (!isHeadless()) {
@@ -2708,6 +2827,7 @@ export async function runRepl(opts) {
             if (ws) {
                 await offerContinueAtStartup({
                     workspaceDir: ws,
+                    cwd: process.cwd(),
                     sessionId: session.id,
                     sapAlias: session.sap_system ?? undefined,
                     choose: classicStartupChooser(inkAwarePrompt, (...l) => l.forEach((x) => console.log(x))),
@@ -2733,19 +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 = autoRoutedNotice(dispatchedCmd);
-                if (n)
-                    console.log(formatInfo(n).trimEnd());
+                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;
@@ -3041,6 +3168,7 @@ export async function runRepl(opts) {
             session.awaitingSkillAnswer = false;
             session.todos = []; // P2 — /new clears the plan (spec §4)
             clearAppFlow(session); // Task 7 — /new ends an /abap-app flow
+            clearJourneyFlow(session); // Task 3 — and a clean-core journey
             console.log(formatInfo('Fresh start · the next prompt picks a skill again').trimEnd());
             continue;
         }
@@ -3051,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.
@@ -3171,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) {
@@ -3214,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
@@ -3223,6 +3375,29 @@ export async function runRepl(opts) {
         if (rejectUnknownSkill(parsed, (m) => console.log(chalk.yellow(`\n${m}\n`)))) {
             continue;
         }
+        // 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.
+        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:
         //   - plain prose: `parsed.prompt === trimmed`, stored as-is
@@ -3282,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) {