@cspeach/cli 1.1.30 → 1.1.31

package/.cspeach/project.json

@@ -0,0 +1,4 @@
+{
+  "id": "032010b3",
+  "createdAt": "2026-10-08T22:43:38.438Z"
+}

package/README.md

@@ -77,6 +77,14 @@ session abc123 │ S4H │ /abap-explain │ 2 turns │ 487 tok │ $0.07 │ s
 
 On `/exit` you get a session summary + the `cspeach --resume <id>` command in plain text so you can pick up where you left off.
 
+To pick up an earlier session:
+
+- `cspeach --continue` (or `-c`) — continue the latest session in this folder
+- `cspeach --resume` — pick a session from this folder, or all folders
+- `cspeach --resume <id>` — works from any folder
+
+Files always save in the folder you start CSPeach in.
+
 ## UI modes
 
 An interactive terminal gets the standard display (the Ink frame). `/ui auto` (the default) picks it for you; `/ui ink` asks for it explicitly. Both save to `~/.cspeach/config.toml` under `[ui]` and apply after a relaunch.
@@ -111,7 +119,9 @@ cspeach whoami                   show signed-in identity + plan/trial
 cspeach logout                   clear local auth
 cspeach config add-sap           add a SAP system
 cspeach doctor                   diagnose install + connectivity
-cspeach --resume                 resume a prior session
+cspeach --continue, -c           continue the latest session in this folder
+cspeach --resume                 pick a session from this folder, or all folders
+cspeach --resume <id>            works from any folder
 cspeach --upgrade                pull the latest CLI release
 cspeach --version
 ```

package/dist/agent/loop.js

@@ -3,6 +3,7 @@ import { basename } from 'node:path';
 import { dispatchTool } from './tool-dispatch.js';
 import { listTools, getTool, isStandalone, toolsForContext, toAnthropicTools } from '../tools/index.js';
 import { saveSession } from '../session/store.js';
+import { tagSessionOnSave } from '../session/project-match.js';
 import { recordCompletedToolCall } from '../session/pending.js';
 import { loadConfig } from '../config/loader.js';
 import { resolveModelRole, resolveEffort, modelAcceptsEffort, resolveAutoCompactThreshold, callModelFor } from '../models/resolve.js';
@@ -17,7 +18,7 @@ import { nextWritingActivity } from '../renderer/fence-state.js';
 import { renderToolCallTop, renderToolCallBottom, startToolSpinner, startThinkingSpinner, isWidgetSuppressedTool, toolActivityText, toolHeartbeatLabel } from '../renderer/tool-widget.js';
 import { formatToolErrorSummary } from '../sap-errors/parse-adt-exception.js';
 import { startThinkingHeartbeat } from '../renderer/thinking-heartbeat.js';
-import { isDeclaredOneShot } from '../renderer/tty.js';
+import { isDeclaredOneShot, isHeadless } from '../renderer/tty.js';
 import { USER_STOP_REASON } from '../session/interrupt-reason.js';
 import { writeStdout, stdoutFlow } from '../renderer/transcript-flow.js';
 import { formatFailure, formatAttention, formatInfo } from '../renderer/notice-shape.js';
@@ -40,6 +41,8 @@ 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 { 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';
@@ -68,6 +71,7 @@ import { CacheKeepalive, snapshotParams, recordLastRequest, isCacheablePrompt, n
 import { maybeColdPrune } from './cold-prune.js';
 import { createAdtLock, serializeAdt } from '../tools/subagent/adt-serial.js';
 import { hasReaderReadTools, INTERRUPTED_LINE } from '../tools/subagent/reader-prompt.js';
+import { openStatusPage } from '../util/open-in-browser.js';
 /**
  * Author identity for project-file metadata. Reads CSPEACH_AUTHOR_NAME first,
  * then platform USER/USERNAME, then a generic fallback. Role is fixed to
@@ -98,11 +102,11 @@ const SAVE_HOOK_SKILLS = new Set([
     'abap-upgrade-fix',
     'abap-upgrade-verify',
     'abap-upgrade-merge',
-    // 2026-05-09: CCA pipeline manifest envelopes. /abap-cca emits a
-    // <!-- csforge:cca-manifest --> block wrapping the heavy project.json
-    // detail at .cspeach/cca/projects/<slug>/. /abap-cca-merge produces
+    // 2026-05-09: CCA pipeline manifest envelopes. /abap-cca-merge produces
     // a consolidated cca-assessment from N parallel consultant slices.
-    'abap-cca',
+    // 2026-10-06: the thin /abap-cca (1.1.31) reads the estate inventory and
+    // writes no envelope, so it is no longer a save-hook skill. An old
+    // cca-manifest in a turn is still offered through detectArtifactSkill.
     'abap-cca-merge',
     // 2026-05-10: v0.7 trio chain. /abap-modernize emits modernize-result;
     // /abap-test emits test-coverage. Both accept cca-assessment via --from
@@ -283,7 +287,10 @@ export async function maybeOfferSave(p) {
         if (!detected)
             return;
         saveSkill = detected;
-        p.emit(formatInfo(`${detected} output found in this turn (routed as ${p.skill}) · offering to save it`).trimEnd());
+        // Inside a journey the triage is saved as part of the step: nothing to offer.
+        if (!(p.journey && detected === p.skill)) {
+            p.emit(formatInfo(`${detected} output found in this turn (routed as ${p.skill}) · offering to save it`).trimEnd());
+        }
     }
     // B5 (2026-06-11) — defect D2: in headless runs the artifact IS the point
     // of the run, so the "Save as project file? [y/N]" prompt defaults YES
@@ -327,6 +334,9 @@ export async function maybeOfferSave(p) {
             // found in another skill's output (detectArtifactSkill) never gets it.
             ...(p.lane && p.skill === saveSkill ? { lane: p.lane } : {}),
             onNotSaved: (reason) => { notSaved = reason; },
+            ...(p.onProjectId ? { onProjectId: p.onProjectId } : {}),
+            // Never headless: a headless journey queues nothing.
+            ...(p.journey && !isHeadless() && p.skill === saveSkill ? { journey: p.journey } : {}),
         });
         // After a spec-gap file is saved, let a developer answer the open BLOCKER
         // questions inline (recorded as `answered` items in the SAME file) — the
@@ -405,6 +415,49 @@ function readerRunFrom(content, start) {
 function stripModelDate(model) {
     return model?.replace(/-\d{8}$/, '');
 }
+/**
+ * Guided clean-core journey (Task 4) — what the triage save needs from the
+ * journey: its card (Ink card slot or a typed line), a typed reason, the
+ * session skips, the pause, and the page the triage was shown.
+ */
+function journeySaveFor(session, emit) {
+    const page = getJourneyFlow(session)?.page;
+    return {
+        card: journeyCardConfirm(emit),
+        // Esc on "Why keep it?" pauses the journey, as Esc on the card does.
+        ask: journeyAsk(),
+        skip: (keys) => addJourneySkips(session, { decide: new Set(keys) }),
+        leaveForLater: (keys) => addJourneyLeftOut(session, keys),
+        pause: () => {
+            const line = pauseJourneyForInterruptedTurn(session);
+            if (line)
+                emit(line);
+        },
+        ...(page ? { page } : {}),
+    };
+}
+/**
+ * Guided clean-core journey (Task 3) — the chain's hooks from a top-level
+ * turn: the session's SAP client, the pending-dispatch slot, the turn's abort
+ * signal (Ctrl-C reaches a running check), the turn's own output.
+ */
+function journeyHooks(params, emit) {
+    const ctx = params.ctx;
+    const standaloneTurn = isStandalone(ctx);
+    return {
+        session: ctx.session,
+        cwd: ctx.cwd,
+        headless: isHeadless(),
+        emit,
+        ...(ctx.pendingDispatch ? { queueNext: (cmd) => ctx.pendingDispatch.set(cmd) } : {}),
+        ...(!standaloneTurn && ctx.adt ? { adt: ctx.adt } : {}),
+        ...(ctx.sapAlias ? { sapAlias: ctx.sapAlias } : {}),
+        ...(standaloneTurn ? { noSap: true } : {}),
+        ...(params.signal ? { signal: params.signal } : {}),
+        // Task 6 — the status page opens in the browser after Yes on its card.
+        openFile: (file) => openStatusPage(file),
+    };
+}
 export async function runTurn(params) {
     // Task 18 — a reader subagent runs INSIDE the parent's turn: it must not
     // reset the parent's Rule 8 batch counter, drain the parent's steering
@@ -470,6 +523,19 @@ export async function runTurn(params) {
         else
             console.log(line);
     }
+    // Guided clean-core journey (Task 3) — the journey survives only its own
+    // queued step (or a plain reply inside it); any other turn ends the chain
+    // with one line. No journey → nothing happens here.
+    if (!readerChild && !params.ctx.subagent) {
+        const journeyGate = gateJourneyForTurn(session, {
+            skill: params.skill,
+            userMessage: params.userMessage,
+            explicitSlash: params.explicitSlash === true,
+            previousSkill: session.skill,
+        });
+        if (journeyGate.ended && journeyGate.line && !isHeadless())
+            emit(journeyGate.line);
+    }
     // Phase J — `--from @<source>` phase promotion.
     // If the user typed `/abap-design --from @./spec-gap.cspeach.json` (or the
     // estimate equivalent), strip the flag, validate + snapshot the source,
@@ -642,6 +708,11 @@ ${imageExpansion.error}`));
         }
         if (laneBlock)
             userMessageForLLM = `${userMessageForLLM}\n\n${laneBlock}`;
+        // Guided clean-core journey (final fix wave) — the queued triage turn says
+        // in its own prompt: no commands, CSPeach asks row by row. '' otherwise.
+        const journeyBlock = params.ctx.subagent ? '' : journeyTurnBlock(session, params.skill);
+        if (journeyBlock)
+            userMessageForLLM = `${userMessageForLLM}\n\n${journeyBlock}`;
     }
     // 2026-05-06: alongside the deterministic prompt-fact extraction
     // (package / transport / etc.), inject the connected SAP system's
@@ -866,7 +937,7 @@ ${imageExpansion.error}`));
     session.turn_seq = (session.turn_seq ?? Math.max(turnNumber - 1, session.lastAutoCompactTurn ?? 0)) + 1;
     // Snapshot session.messages.length at turn start so the save hook can
     // walk every assistant message added during this turn — not just the
-    // final one. Skills like /abap-cca emit their manifest in an early
+    // final one. Skills like /abap-cca-merge emit their manifest in an early
     // message before a closing ask_question widget; the final wrap-up
     // message ends the turn but doesn't carry the manifest. See
     // ./turn-assistant-text.ts for the full rationale.
@@ -1529,6 +1600,13 @@ ${imageExpansion.error}`));
         await turnStreamWriter.close(interruptedError !== null
             ? `_interrupted: ${session.turnInterruptedReason ?? 'unknown'}_`
             : undefined);
+        // Guided clean-core journey (Task 3, fix round 1) — the queued step was
+        // interrupted: pause the journey so "carry on" resumes it on the first try.
+        if (interruptedError !== null && !readerChild && !params.ctx.subagent) {
+            const journeyLine = pauseJourneyForInterruptedTurn(session);
+            if (journeyLine && !isHeadless())
+                emit(journeyLine);
+        }
         // Re-throw AFTER persistence so the outer REPL catch can render the
         // graceful error UX with full session-id + log-path context.
         if (interruptedError !== null)
@@ -1585,7 +1663,7 @@ ${imageExpansion.error}`));
             // a background block on the next REPL prompt.
             //
             // 2026-05-12: collect text from ALL assistant messages added during
-            // this turn, not just the final one. Skills like /abap-cca emit
+            // this turn, not just the final one. Skills like /abap-cca-merge emit
             // their manifest in an early message before a closing ask_question
             // widget; the final wrap-up message ends the turn but doesn't
             // carry the manifest. See ./turn-assistant-text.ts for details.
@@ -1597,6 +1675,7 @@ ${imageExpansion.error}`));
             // while the user was the one being waited on (Laeeq's dry run). Pause
             // for the whole hook — the row hides while paused — and resume after,
             // so any real work that follows (auto-compact) shows again.
+            let projectTagChanged = false;
             status.pause();
             try {
                 if (!params.suppressSaveHook) {
@@ -1618,6 +1697,14 @@ ${imageExpansion.error}`));
                             const flowLane = getAppFlow(session)?.lane;
                             return flowLane ? { lane: { ...flowLane, cwd: params.ctx.cwd } } : {};
                         })(),
+                        // Sessions/folders (Task 6) — the first save tags the session with
+                        // its folder's project id, only when the session belongs to this
+                        // folder (ruling 18). Saved to disk right after the hook.
+                        onProjectId: (id) => { if (tagSessionOnSave(session, process.cwd(), id))
+                            projectTagChanged = true; },
+                        // Guided clean-core journey (Task 4) — the queued triage's rows.
+                        ...(!readerChild && !params.ctx.subagent && getJourneyFlow(session)?.queued?.stage === 'DECIDE'
+                            ? { journey: journeySaveFor(session, emit) } : {}),
                         // Task 7 — subagent / reader turns never drive the app chain.
                         ...(!readerChild && !params.ctx.subagent ? {
                             appChain: {
@@ -1634,6 +1721,32 @@ ${imageExpansion.error}`));
                 keepalive.disarm();
                 status.resume();
             }
+            // Sessions/folders (Task 6) — the session was saved before the hook;
+            // persist the project id the save just filled in. Best-effort.
+            if (projectTagChanged) {
+                try {
+                    await saveSession(session);
+                }
+                catch { /* tagging never fails the turn */ }
+            }
+            // Guided clean-core journey (Task 3) — the queued step's turn ended:
+            // derive the stage from the folder again and go on (the next code
+            // stage, a step card, or the next queued command).
+            if (!readerChild && !params.ctx.subagent && getJourneyFlow(session)?.queued) {
+                try {
+                    await afterJourneyTurn(journeyHooks(params, emit), {
+                        skill: params.skill,
+                        awaitingAnswer: session.awaitingSkillAnswer === true,
+                        assistantText,
+                    });
+                }
+                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.'));
+                }
+            }
             // 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

@@ -67,6 +67,20 @@ export async function main(argv) {
         sapAlias = parsed.sapAlias;
         args = parsed.rest;
     }
+    // 2026-10-08 (sessions/folders) — `--continue` / `-c`: the latest session of this folder.
+    if (args[0] === '--continue' || args[0] === '-c') {
+        if (args[1] !== undefined && !args[1].startsWith('-')) {
+            console.error(chalk.red('error: --continue takes no session id. To pick one: cspeach --resume'));
+            return 1;
+        }
+        // Like --resume: a trailing flag is refused (--sap-alias / --no-sap were taken out above).
+        if (args[1] !== undefined) {
+            console.error(chalk.red(`error: --continue takes no other flag, not '${args[1]}'. Usage: cspeach --continue`));
+            return 1;
+        }
+        const { runContinue } = await import('./session/resume.js');
+        return runContinue({ sapAlias, noSap });
+    }
     if (args[0] === '--resume') {
         // Final batch 5 — `--resume --one-shot "…"`: a flag is never a session id.
         if (args[1]?.startsWith('-')) {
@@ -153,17 +167,10 @@ export async function main(argv) {
         const { input } = await import('@inquirer/prompts');
         const { loadConfig } = await import('./config/loader.js');
         const cfg = await loadConfig();
-        const open = async (url) => {
-            const { spawn } = await import('node:child_process');
-            // On Windows, `start` is a cmd builtin and needs a shell; spawn the URL via cmd /c.
-            if (process.platform === 'win32') {
-                spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' }).unref();
-            }
-            else {
-                const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
-                spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
-            }
-        };
+        // The shared opener (util/open-in-browser.ts): https only, never through
+        // cmd or a shell; rejects when nothing opened, so login prints its own line.
+        const { loginOpener } = await import('./util/open-in-browser.js');
+        const open = loginOpener();
         return runLoginCommand({
             proxyUrl: cfg.proxy_url,
             open,
@@ -234,6 +241,11 @@ export async function main(argv) {
         console.log('Unknown command: cspeach project. Team projects use: cspeach team init|join|lane|refresh|status|outbox|rule|leave');
         return 1;
     }
+    // Sessions/folders (2026-10-08): sort project files from earlier builds into their folders. Copy only.
+    if (args[0] === 'files' && args[1] === 'sort') {
+        const { runFilesSort } = await import('./projects/sort-command.js');
+        return runFilesSort(args.slice(2), { log: (s) => console.log(s), cwd: process.cwd() });
+    }
     if (args[0] === 'analyze' && args[1] === 'project-context') {
         const { runProjectContextImpactCommand } = await import('./commands/project-context-impact.js');
         return runProjectContextImpactCommand(args.slice(2));
@@ -270,7 +282,8 @@ Usage:
   cspeach --one-shot "<prompt>"     Same as above, explicit flag
   cspeach --sap-alias <name>        Use a specific SAP alias (overrides default)
   cspeach --no-sap                  Start without a SAP system (paste-mode skills only)
-  cspeach --resume [id]             Resume a previous session (list if no id)
+  cspeach --continue, -c            Continue the latest session in this folder
+  cspeach --resume [id]             Pick a session from this folder (or all folders); an id works anywhere
   cspeach config add-sap            Add a SAP system interactively
   cspeach config standalone         Set the standalone SAP profile (no system)
   cspeach standards init            Capture your team's ABAP development standards
@@ -283,18 +296,27 @@ Usage:
   cspeach login                     Sign in via device-code flow
   cspeach logout                    Sign out (keep keychain key, if any)
   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 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 lane add|list        Lead: who owns which packages
+  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
+  cspeach team plan move|scope|defer|set|note|history   Lead: per-object plan changes, each with a reason
+  cspeach team plan import <file.xlsx> [--yes]   Lead: read back the Plan sheet edited in Excel; shows the changes, asks once
   cspeach team refresh --lane <id>  Measure with ATC: what is verified, what did not hold
+  cspeach team refresh --all --per-package [--again]   One record per package; skips packages already measured
   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
-  cspeach team decide T N <d>       Record a clean-core decision: keep, fix, rebuild, retire or exception
+  cspeach team rule T N <d>         Lead: settle a conflicting decision (a retire needs --reason)
+  cspeach team decide T N <d>       Record a clean-core decision: keep, fix, rebuild, retire or exception (a retire needs --reason)
   cspeach team fixed T N            Claim a fix; the next refresh checks it
   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 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
   cspeach --upgrade                 Upgrade to latest via npm
   cspeach --version                 Print version

package/dist/commands/config-set.js

@@ -212,7 +212,7 @@ const UNSET_ONLY_KEYS = new Set(['standalone']);
  * remains), keeping the top-level entry in `file_keys` is what stops sparse
  * save from dropping the now-default-equal parent table.
  */
-function unsetConfigKey(cfg, key) {
+export function unsetConfigKey(cfg, key) {
     const parts = key.split('.');
     const top = parts[0];
     const obj = cfg;

package/dist/commands/plan-continue.js

@@ -119,7 +119,7 @@ export async function preparePlanContinuation(args) {
     // App lane routing — same gate as preparePlanResume: pinned read, record
     // re-validation, stored phases checked against the lane. Before the lease,
     // so a paused plan never leaves a lock behind. Lane-less plans pass.
-    const laneGate = await loadPlanLaneForRun(args.cwd ?? process.cwd(), parsed.content);
+    const laneGate = await loadPlanLaneForRun(args.cwd ?? process.cwd(), parsed.content, path);
     if (!laneGate.ok) {
         args.log(...laneGate.lines);
         return { prepared: null, stale: false, paused: true };

package/dist/commands/plan-gate.js

@@ -31,8 +31,15 @@ let guardedRunActive = false;
 export function setGuardedRunActive(active) {
     guardedRunActive = active;
 }
+/* Guided clean-core journey (2026-10-07, Task 3) — the journey's own share of
+ * the same override, kept apart so a plan turn's set/clear and the journey's
+ * start/end never undo each other. Off ⇒ byte-identical to before. */
+let journeyRunActive = false;
+export function setJourneyRunActive(active) {
+    journeyRunActive = active;
+}
 export function isGuardedRunActive() {
-    return guardedRunActive;
+    return guardedRunActive || journeyRunActive;
 }
 /* ── 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

@@ -260,7 +260,7 @@ export async function preparePlanResume(args) {
     // skip this entirely.
     // R5 fix round: the stored phases must also fit the lane, checked here
     // before any phase, lease or transport work.
-    const laneGate = await loadPlanLaneForRun(args.cwd, content);
+    const laneGate = await loadPlanLaneForRun(args.cwd, content, path);
     if (!laneGate.ok) {
         args.log(...laneGate.lines);
         return null;
@@ -632,7 +632,7 @@ export async function preparePlanResume(args) {
     // 2026-10-04 (plan sources) — the spec-gap items this phase reads, in full,
     // from the file the plan was made from (or the plan's creation snapshot).
     // A phase must never have to hunt the folder for its gap answers.
-    const sourcesBlock = renderPlanSourcesBlock(await resolvePlanSources({ cwd: args.cwd, envelope, content, ...(laneRecord ? { laneRecord } : {}) }), next);
+    const sourcesBlock = renderPlanSourcesBlock(await resolvePlanSources({ cwd: args.cwd, envelope, content, planPath: path, ...(laneRecord ? { laneRecord } : {}) }), next);
     const llmPrompt = [
         `Resume execution of the project plan "${envelope.title}" (envelope v${envelope.version}).`,
         '',
@@ -981,14 +981,9 @@ export async function finishPlanResume(args) {
         logNotSaved(args, 'the updated plan did not pass its own checks', `revision failed validation: ${check.error.message}`);
         return null;
     }
-    let outDir;
-    try {
-        outDir = await ensureWorkspace();
-    }
-    catch {
-        outDir = process.cwd();
-    }
-    const savedPath = await saveProject(revision, { cwd: outDir });
+    // 2026-10-08 — the new version is saved beside the plan file, wherever it
+    // is (an old git root, a copied folder), so a plan family never splits.
+    const savedPath = await savePlanVersion(revision, args.prepared.path, args.log);
     // Task 8 — regenerate the write-only markdown handover projection beside
     // the envelope. Best-effort: a failed projection write logs one dim line
     // and never blocks the run (the envelope is the source of truth).
@@ -1048,6 +1043,23 @@ export async function finishPlanResume(args) {
         nextTitle: next ? phaseDisplayTitle(next, extract.content.phases) : null,
     };
 }
+/**
+ * Final fix wave, item 5 — save a new plan version beside the plan file. When
+ * that write fails (a read-only or missing folder), save it in the working
+ * folder instead, so the run's progress is never lost, and say where.
+ */
+async function savePlanVersion(revision, planPath, log) {
+    const beside = dirname(planPath);
+    try {
+        return await saveProject(revision, { cwd: beside });
+    }
+    catch {
+        const ws = await ensureWorkspace();
+        const saved = await saveProject(revision, { cwd: ws });
+        log(`Could not save beside the plan in ${beside}. Saved in ${ws} instead.`);
+        return saved;
+    }
+}
 /**
  * Shared revision writer for audit verdicts and chain-stop records: load the
  * envelope, patch ONE phase (audit and/or status) + content.lastStop,
@@ -1103,14 +1115,8 @@ async function savePlanPatch(envelopePath, phaseId, patch, log) {
     if (!check.ok) {
         throw new Error(`audit revision failed validation: ${check.error.message}`);
     }
-    let outDir;
-    try {
-        outDir = await ensureWorkspace();
-    }
-    catch {
-        outDir = dirname(envelopePath);
-    }
-    const saved = await saveProject(revision, { cwd: outDir });
+    // 2026-10-08 — saved beside the plan file (the working folder only as a fallback).
+    const saved = await savePlanVersion(revision, envelopePath, log ?? console.log);
     // Task 8 — every envelope save in the plan flow regenerates the markdown
     // handover. This is the single chokepoint for ALL chain writes:
     // applyAuditResult and applyPhaseResolution both route through here.

package/dist/commands/plan-startup.js

@@ -1,15 +1,45 @@
+// cspeach-cli/src/commands/plan-startup.ts
+//
+// 2026-10-04 (continuous run, spec §3.5) — typing `cspeach` in the project
+// folder offers to continue an unfinished plan:
+//   one plan  → "Continue 'FI Document Aging' (3 of 6 done, next: Service)?"
+//   several   → "Continue an unfinished plan?", newest first (max 5), + "Not now"
+// Approvals do not survive a restart (the session is new), so Continue shows
+// the plan's object list again and installs a fresh object-list grant
+// (installPlanGrant: same policy as "Build this now?"), then submits the plain
+// resume command (no mode flag: the user's plan_mode decides).
+//
+// F13 — a resume the user typed in guarded mode, with no grant for that plan,
+// shows the same object list once before the step (offerObjectListOnResume).
+// Yes installs the grant; No runs the step with a card per write. Never on a
+// chain-queued hop, never twice for one Continue.
+import { basename, dirname } from 'node:path';
 import { readProjectFile } from '../projects/status.js';
 import { parsePlanContent } from '../projects/plan-schema.js';
 import { computeNextPhaseForRun, isPhaseSatisfiedForRun, phaseDisplayTitle, statusesFromItems, } from '../projects/plan-run.js';
 import { collectPlannedObjects, plannedObjectFacts, planGrantFactLines } from '../projects/plan-objects.js';
 import { adoptPlanTransportOnResume, buildResumeCommand, planBuildTransport } from './plan-resume.js';
 import { newestPlanFamilyFiles } from '../session/recap.js';
+import { legacyDirsFor } from '../projects/project-folder.js';
 import { getPlanGrant, installPlanGrant, planGrantAllowed } from '../approvals/plan-grant.js';
 import { DEFAULT_PLAN_MODE } from './plan-gate.js';
-/** Plans in the folder with a step left to build, newest first. */
-export function listUnfinishedPlans(workspaceDir, max = 5) {
+/**
+ * Plans in the folder with a step left to build, newest first. With `cwd`,
+ * the old save locations for that folder are read too (Task 11, one
+ * release), after the new folder; a same-name file in the new folder wins.
+ */
+export function listUnfinishedPlans(workspaceDir, max = 5, cwd) {
     const out = [];
-    for (const f of newestPlanFamilyFiles(workspaceDir)) {
+    const dirs = [workspaceDir, ...(cwd ? safeLegacyDirs(cwd) : [])];
+    const seen = new Set();
+    const files = dirs.flatMap((d, i) => newestPlanFamilyFiles(d).map((f) => ({ ...f, earlier: i > 0 }))).filter((f) => {
+        const name = basename(f.path).toLowerCase();
+        if (seen.has(name))
+            return false;
+        seen.add(name);
+        return true;
+    });
+    for (const f of files) {
         if (out.length >= max)
             break;
         let env;
@@ -42,13 +72,23 @@ export function listUnfinishedPlans(workspaceDir, max = 5) {
             nextTitle: phaseDisplayTitle(next, phases),
             objects: collectPlannedObjects(pc.content),
             ...(transport ? { transport } : {}),
+            ...(f.earlier ? { earlier: true } : {}),
         });
     }
     return out;
 }
+function safeLegacyDirs(cwd) {
+    try {
+        return legacyDirsFor(cwd);
+    }
+    catch {
+        return [];
+    }
+}
 function progress(p) {
     return `${p.done} of ${p.total} done, next: ${p.nextTitle ?? 'the independent check'}`;
 }
+const EARLIER = '(earlier location)';
 export function continueQuestion(p) {
     return `Continue '${p.title}' (${progress(p)})?`;
 }
@@ -97,7 +137,7 @@ function grantInstalledFor(planId, sessionId) {
         && typeof g.expiresAt === 'number' && Date.now() < g.expiresAt;
 }
 export async function offerContinueAtStartup(a) {
-    const plans = listUnfinishedPlans(a.workspaceDir);
+    const plans = listUnfinishedPlans(a.workspaceDir, 5, a.cwd);
     if (plans.length === 0)
         return 'none';
     const allowed = a.grantAllowed ?? planGrantAllowed;
@@ -109,7 +149,10 @@ export async function offerContinueAtStartup(a) {
         grantable = p.objects.length > 0 && await allowed(a.sapAlias).catch(() => false);
         const v = await a.choose({
             title: continueQuestion(p),
-            facts: objectListFacts(p.objects, p.transport, grantable),
+            facts: [
+                ...(p.earlier ? [`This plan is in an earlier location: ${dirname(p.path)}`] : []),
+                ...objectListFacts(p.objects, p.transport, grantable),
+            ],
             choices: [{ value: 'continue', label: 'Continue' }, { value: 'later', label: 'Not now' }],
         });
         if (v === 'continue') {
@@ -122,7 +165,7 @@ export async function offerContinueAtStartup(a) {
             title: 'Continue an unfinished plan?',
             facts: ['Newest first.'],
             choices: [
-                ...plans.map((p, i) => ({ value: String(i), label: `${p.title} (${progress(p)})` })),
+                ...plans.map((p, i) => ({ value: String(i), label: `${p.title} (${progress(p)})${p.earlier ? ` ${EARLIER}` : ''}` })),
                 { value: 'later', label: 'Not now' },
             ],
         });