@cspeach/cli 1.1.30 → 1.1.31

package/dist/repl/at-picker.js

@@ -48,7 +48,7 @@ export function listWorkspaceFileChoices(opts) {
     const seen = new Set();
     // Workspace half (takes precedence on name collisions).
     try {
-        const ws = opts?.workspace ?? ensureWorkspaceSync();
+        const ws = opts?.workspace ?? ensureWorkspaceSync(opts?.cwd);
         for (const f of listProjectFilesSync(ws)) {
             if (seen.has(f.filename))
                 continue;

package/dist/repl/journey-entry.js

@@ -0,0 +1,25 @@
+import { enterJourney } from '../journey/chain.js';
+import { openStatusPage } from '../util/open-in-browser.js';
+export async function runJourneyEntry(trigger, a) {
+    const hooks = {
+        session: a.session,
+        cwd: a.cwd,
+        headless: a.headless,
+        emit: a.emit,
+        ...(a.queueNext && !a.headless ? { queueNext: a.queueNext } : {}),
+        ...(!a.standalone && a.adt ? { adt: a.adt } : {}),
+        sapAlias: a.sapAlias,
+        ...(a.standalone ? { noSap: true } : {}),
+        signal: a.signal,
+        // Task 6 — the status page opens in the browser after Yes on its card.
+        openFile: (file) => openStatusPage(file),
+    };
+    try {
+        await enterJourney(trigger, hooks);
+    }
+    catch (err) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw err;
+        a.emit('The clean-core steps stopped here. Say carry on to continue.');
+    }
+}

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,7 @@ 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 { applyResumedSkill, isShortFollowUp } from './router/resume-routing.js';
 import { readableInterruptReason, isUserStopReason } from './session/interrupt-reason.js';
 import { getStore } from './auth/api-key.js';
@@ -79,8 +80,8 @@ 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 { openAtPicker, pendingAtTokenPrefix } from './repl/at-picker.js';
@@ -170,12 +171,14 @@ 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/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 +393,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 +759,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.
@@ -974,7 +1007,8 @@ export async function runRepl(opts) {
                 return;
             }
             // Task 13 — no echo for a plan hop: the chain already said "Next: <title>".
-            const notice = autoRoutedNotice(cmd);
+            // Journey hops (Task 3) — the journey already said its step line.
+            const notice = isJourneyHop(session, cmd) ? null : autoRoutedNotice(cmd);
             if (notice)
                 chunkEmitter.emit('chunk', formatInfo(notice));
             setImmediate(() => { void handleSubmit(cmd, { planHop }); });
@@ -1003,7 +1037,10 @@ 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 — 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));
             }
             if (trimmed === '/exit' || trimmed === '/quit') {
                 done = true;
@@ -1213,6 +1250,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;
             }
@@ -1271,6 +1309,41 @@ 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", "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;
+                }
+            }
             // Record the prose body (post-shortcut stripping) for /reroute. Using
             // `parsed.prompt` rather than `trimmed` means:
             //   - plain prose: `parsed.prompt === trimmed`, stored as-is
@@ -2355,6 +2428,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 +2447,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 +2748,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 +2793,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))),
@@ -2743,9 +2829,13 @@ export async function runRepl(opts) {
             // destroys the session context.
             // Task 13 — no echo for a plan hop: the chain already said "Next: <title>".
             {
-                const n = autoRoutedNotice(dispatchedCmd);
+                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);
                 classicPlanHop = planHops.take(dispatchedCmd);
             }
             line = dispatchedCmd;
@@ -3041,6 +3131,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;
         }
@@ -3223,6 +3314,33 @@ 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.
+        {
+            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;
+            }
+        }
         // Record the prose body (post-shortcut stripping) for /reroute. Using
         // `parsed.prompt` rather than `trimmed` means:
         //   - plain prose: `parsed.prompt === trimmed`, stored as-is