@cspeach/cli 1.1.30 → 1.1.32

package/dist/journey/session-deps.js

@@ -0,0 +1,81 @@
+import { activeProject } from '../register/store.js';
+const CANCELLED = { value: null, cancelled: true };
+/** The confirm card the session shows; headless never shows one. */
+export function journeyConfirm(headless, confirm) {
+    if (headless)
+        return async () => CANCELLED;
+    return confirm ?? (async (req) => {
+        const { askConfirm } = await import('../ui/confirm-request.js');
+        return askConfirm(req);
+    });
+}
+/**
+ * A team body's [y/n] question as a Yes/No card: 'y', 'n', or '' when the card
+ * was put away or nobody is there. A question that wants words (a variant
+ * name) gets '' without a card: a card cannot answer it, and '' assumes nothing.
+ */
+function askWith(confirm) {
+    let n = 0;
+    return async (question) => {
+        const yn = /\s*\[y\/n\]\s*$/i;
+        if (!yn.test(question))
+            return '';
+        const res = await confirm({
+            id: `journey-ask-${(n += 1)}`,
+            tag: 'QUESTION',
+            title: question.replace(yn, ''),
+            choices: [{ value: 'y', label: 'Yes' }, { value: 'n', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'y', n: 'n' },
+        });
+        return res.cancelled || res.value === null ? '' : res.value;
+    };
+}
+/** Stop on the turn's abort signal; an abort that already happened stops at once. */
+function interruptOn(signal) {
+    return (stop) => {
+        if (signal.aborted) {
+            stop();
+            return () => { };
+        }
+        const handler = () => stop();
+        signal.addEventListener('abort', handler, { once: true });
+        return () => signal.removeEventListener('abort', handler);
+    };
+}
+export async function sessionTeamDeps(o) {
+    if (!o.headless && !o.signal)
+        throw new Error('A live journey step needs the turn abort signal, so Ctrl-C can stop a check.');
+    const said = [];
+    const confirm = journeyConfirm(o.headless, o.confirm);
+    let identity = o.identity;
+    if (!identity) {
+        const { getAuthorIdentity } = await import('../agent/loop.js');
+        // Read at each call, so it follows a join made during the journey: once this
+        // laptop records into a project, the name given for that project is the seat name.
+        identity = () => ({ name: activeProject()?.name ?? getAuthorIdentity().name });
+    }
+    const adt = o.adt;
+    const noSap = !!o.noSap || !adt;
+    const deps = {
+        print: (line) => said.push(line),
+        identity,
+        noSap,
+        // The session is connected to one system; that is the one used.
+        connect: noSap ? undefined : async () => ({
+            sql: (q, max) => adt.sqlQuery(q, max),
+            ...(o.sapAlias && o.sapAlias !== 'none' ? { system: { sid: o.sapAlias } } : {}),
+            atc: {
+                runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts),
+                // The finding's own document names the API it uses, when its worklist entry does not.
+                ...(adt.atcFindingDocument ? { findingDocument: (href) => adt.atcFindingDocument(href) } : {}),
+            },
+        }),
+        ask: askWith(confirm),
+        ...(o.signal ? { onInterrupt: interruptOn(o.signal) } : {}),
+        ...(o.now ? { now: o.now } : {}),
+        ...(o.rand ? { rand: o.rand } : {}),
+        ...(o.machine ? { machine: o.machine } : {}),
+    };
+    return { deps, said, confirm };
+}

package/dist/journey/trigger.js

@@ -0,0 +1,153 @@
+/**
+ * Guided clean-core journey, Task 3 — the sentences that start or resume a
+ * journey, detected in the CLI before the classifier (no proxy change).
+ *
+ * The rule, one sentence at a time:
+ *   - never a question: no sentence that ends in "?" or opens with a question
+ *     word (what, how, is, can, explain, tell, …);
+ *   - it opens with a start/check verb on clean core ("start clean core on …",
+ *     "let's begin a clean-core run on …"), or — with no verb on clean core
+ *     itself — it is ONLY names: "clean core for ZFI_AR and ZFI_GL",
+ *     "check ZFI_AR for clean core (and keep track of it)", a polite ending
+ *     allowed. "clean core for ZFI_AR is overdue" is a statement, not a start;
+ *   - it names at least one package, by code: ZFI_AR, zfi_ar, /NS/NAME.
+ *     A word like "your" is not a package: a name needs an underscore, a
+ *     digit, a namespace, or capitals as typed.
+ * Or the explicit form "/abap-clean-core start <PKG…>".
+ * A pattern (*, %, ?) in such a sentence is refused in one line; no journey.
+ *
+ * Resume, in a folder that holds a project with no plan step pending: any of
+ * "carry on" / "continue" / "continue clean core" picks up a journey this
+ * session paused; "continue clean core" also resumes after a clean turn with
+ * no answer pending; bare "carry on" / "continue" only as the session's first
+ * words. Otherwise "continue" keeps its old meaning.
+ */
+import { folderKind } from './clean-core.js';
+import { isJourneyPaused, isJourneyPausedJustNow, userTurnCount } from './flow.js';
+/** The runner's own words for a pattern (run.ts START). */
+export const PATTERN_LINE = 'Name each package in full, for example ZFI_AR — not a pattern.';
+const CC = String.raw `clean[\s-]?core`;
+const CLEAN_CORE = new RegExp(CC, 'i');
+/** Words in front of the verb that do not change what is asked. */
+const FILLER = new RegExp(String.raw `^(?:(?:let'?s|let us|please|now|ok(?:ay)?|so|then|and|right|go ahead and|time to|(?:i|we)(?:'d| would)? (?:like|want) to|(?:i|we) need to)[,]?\s+)+`, 'i');
+const QUESTION = /^(?:what|why|how|is|are|was|were|can|could|would|should|does|did|will|explain|tell|describe|which|when|where|who|whether|show)\b/i;
+/**
+ * Package names joined by "and", "," or "&" — nothing else. A name may hold
+ * *, % or ? here only so a pattern is caught and refused in its own words.
+ */
+const NAME = String.raw `(?:\/[A-Za-z0-9_]{1,10}\/[A-Za-z0-9_*%?]{1,30}|[ZzYy][A-Za-z0-9_*%?]{0,29})`;
+const NAMES = String.raw `${NAME}(?:(?:\s*,\s*|\s*&\s*|\s+and\s+|\s+)${NAME})*`;
+/** What may follow the names: a polite ending, never more sentence. */
+const TAIL = String.raw `(?:[\s,]+(?:please|now|today|for me|thanks|thank you))*`;
+/** After "check <names> for clean core": "and keep track of it" and the like. */
+const TRACK = String.raw `(?:\s+and\s+(?:keep\s+(?:a\s+)?track|track)(?:\s+of)?(?:\s+(?:it|them))?)?`;
+/** A verb on clean core opens the sentence: the names can follow in any words. */
+const VERB_OPENINGS = [
+    new RegExp(String.raw `^(?:start|begin|kick off|launch|set up|run)\s+(?:(?:a|the|our|my|up|with|on)\s+){0,2}${CC}\b`, 'i'),
+    new RegExp(String.raw `^check\s+(?:the\s+)?${CC}\b`, 'i'),
+];
+/**
+ * No verb on clean core itself: the sentence must hold only names (and a
+ * polite ending) — a statement ("clean core for ZFI_AR is overdue") never
+ * starts a paid step. Group 1 is the names slot; every word in it must look
+ * like a package as typed ("yes", "yet", "you" do not).
+ */
+const NAMES_OPENINGS = [
+    new RegExp(String.raw `^check\s+(${NAMES})\s+for\s+${CC}${TRACK}${TAIL}$`, 'i'),
+    new RegExp(String.raw `^${CC}\s+(?:for|on|with|of)\s+(${NAMES})${TAIL}$`, 'i'),
+];
+/** The package test, as typed: /NS/…, an underscore or a digit, or capitals. */
+const looksLikePackage = (typed) => typed.startsWith('/') || /[_\d]/.test(typed) || typed === typed.toUpperCase();
+/** True when the sentence opens a journey: a verb on clean core, or only package names. */
+function opensJourney(s) {
+    if (VERB_OPENINGS.some((re) => re.test(s)))
+        return true;
+    for (const re of NAMES_OPENINGS) {
+        const slot = re.exec(s)?.[1];
+        if (slot === undefined)
+            continue;
+        const words = slot.split(/\s*[,&]\s*|\s+/).filter((w) => w && w.toLowerCase() !== 'and');
+        if (words.length && words.every(looksLikePackage))
+            return true;
+    }
+    return false;
+}
+const EXPLICIT = /^\/(?:abap-)?clean-core\s+start(?:\s+([\s\S]*))?$/i;
+const PATTERN = /[*%]|[A-Za-z0-9_]\?[A-Za-z0-9_]/;
+/** A package as typed: /NS/NAME, or Z… / Y… (letters, digits, underscores). */
+const PACKAGE_TOKEN = /(?<![A-Za-z0-9_/])(\/[A-Za-z0-9_]{1,10}\/[A-Za-z0-9_]{1,30}|[ZzYy][A-Za-z0-9_]{1,29})(?![A-Za-z0-9_/])/g;
+const unique = (names) => [...new Set(names)];
+/** The sentences of a message: split after . ! ? and at line breaks. */
+function sentences(text) {
+    return text.replace(/[‘’]/g, "'").split(/(?<=[.!?])\s+|\r?\n+/).map((s) => s.trim()).filter(Boolean);
+}
+/** Package-looking names in a sentence, upper-cased, each once. */
+export function packagesIn(sentence) {
+    const out = [];
+    for (const m of sentence.matchAll(PACKAGE_TOKEN)) {
+        const typed = m[1];
+        if (looksLikePackage(typed))
+            out.push(typed.toUpperCase());
+    }
+    return unique(out);
+}
+/** A start sentence (or the explicit form), a refused pattern, or null. Pure. */
+export function parseJourneyStart(input) {
+    const text = input.trim();
+    const explicit = EXPLICIT.exec(text);
+    if (explicit) {
+        const rest = (explicit[1] ?? '').trim();
+        if (PATTERN.test(rest))
+            return { kind: 'refuse', line: PATTERN_LINE };
+        // As typed, upper-cased: the runner checks each one against the system.
+        const named = rest.split(/[\s,;]+/).filter((w) => w && !/^(and|or)$/i.test(w)).map((w) => w.toUpperCase());
+        return { kind: 'start', packages: unique(named) };
+    }
+    if (text.startsWith('/'))
+        return null;
+    for (const raw of sentences(text)) {
+        if (/\?\s*$/.test(raw) || QUESTION.test(raw))
+            continue;
+        const s = raw.replace(FILLER, '').replace(/[.!]+$/, '').trim();
+        if (QUESTION.test(s) || !opensJourney(s))
+            continue;
+        if (PATTERN.test(s))
+            return { kind: 'refuse', line: PATTERN_LINE };
+        const packages = packagesIn(s);
+        if (packages.length)
+            return { kind: 'start', packages };
+    }
+    return null;
+}
+/** "carry on", "continue", "continue (with) clean core". */
+export function isResumePhrase(input) {
+    const t = input.trim().toLowerCase().replace(/[.!]+$/, '').replace(/\s+/g, ' ');
+    return new RegExp(String.raw `^(?:carry on|continue)(?: (?:with )?(?:the )?${CC})?$`).test(t);
+}
+/**
+ * The journey this input asks for, or null (the input goes on as before).
+ * Resume needs a project in `cwd` and no plan step in flight. Then:
+ *   - right after a pause line, with no turn of the person's since, any of the
+ *     words resumes — even after an interrupted step (that is what paused it);
+ *   - otherwise nothing interrupted, no answer pending, and: a journey this
+ *     session paused, or the words name clean core, or it is the session's
+ *     first turn (text and image turns count; tool results do not).
+ */
+export function detectJourney(input, ctx) {
+    const start = parseJourneyStart(input);
+    if (start)
+        return start;
+    if (!isResumePhrase(input))
+        return null;
+    const s = ctx.session;
+    // Only whether a project file is there; the stage machine reads the rest.
+    if (s.plan_in_flight || folderKind(ctx.cwd, '').kind === 'none')
+        return null;
+    // Right after the pause line ("Say carry on"), with no turn of the person's
+    // since, the pause wins over an interrupted or waiting turn.
+    if (isJourneyPausedJustNow(ctx.session))
+        return { kind: 'resume' };
+    if (s.turnInterrupted || s.awaitingSkillAnswer)
+        return null;
+    return isJourneyPaused(ctx.session) || CLEAN_CORE.test(input) || userTurnCount(ctx.session) === 0 ? { kind: 'resume' } : null;
+}

package/dist/lane/app-chain.js

@@ -29,10 +29,16 @@ import { chainFromToken } from './chain-token.js';
 import { containSpecPath, specDisplayPath, SpecProtectedError } from './roots.js';
 import { resolveAtTokenAsync } from '../projects/workspace.js';
 import { parseFromFlag } from '../skills/promotion-dispatch.js';
+import { rebuildStartedAfterPlanSave } from '../journey/rebuild.js';
 export const STEP_1 = 'Step 1 of 3: finding the gaps in the spec.';
 export const STEP_2 = 'Step 2 of 3: choosing the build lane.';
 export const STEP_3 = 'Step 3 of 3: planning the build.';
 export const START_QUESTION = 'Build this now?';
+/**
+ * Audit M-2 — who queued the chain's commands: CSPeach. No line of its own: the
+ * step lines (Step 2/3) and the plan board already stand for the step.
+ */
+const APP_ORIGIN = { by: 'app' };
 /** Trailing characters a sentence puts after a token: `see @spec.md.` / `(@spec.md)`. */
 const TRAILING_PUNCT = /[.,;:!?)\]}>]+$/;
 /**
@@ -64,12 +70,14 @@ export function cleanSpecToken(raw) {
 const NOT_STARTED = 'The app flow did not start.';
 /**
  * Resolve the /abap-app spec token to a stable path (forward slashes):
- * cwd-relative inside cwd, absolute for a spec in the workspace folder outside
- * cwd. The token is looked up with resolveAtTokenAsync — the same lookup the
- * @-attachment expansion uses — so the pinned spec and the analysed spec are
- * the same file. Refused, with one plain line, when the message names no
- * file, the name is ambiguous, the file leaves cwd and the workspace folder
- * (also through a link), sits in a protected place, or does not exist. The
+ * relative to the folder you started in; absolute only for a spec in the
+ * working `.cspeach` folder when that sits outside it (a team seat's work
+ * folder). 2026-10-08: a configured workspace_folder is ignored. The token is looked up
+ * with resolveAtTokenAsync — the same lookup the @-attachment expansion uses —
+ * so the pinned spec and the analysed spec are the same file. Refused, with
+ * one plain line, when the message names no file, the name is ambiguous, the
+ * file is outside this folder (also through a link), sits in a protected
+ * place, or does not exist. The
  * stored value is what app_lane_resolve's `sameFile` compares, and that check
  * (like readSpecText) uses the same containment (lane/roots.ts).
  */
@@ -80,7 +88,7 @@ export async function resolveAppSpec(cwd, message) {
     if (tok === '')
         return { ok: false, line: `Name the spec file with @, for example: /abap-app @specs/my-app.docx\n${NOT_STARTED}` };
     const shown = cardLine(tok);
-    const outside = { ok: false, line: `The spec file must be inside this folder or the workspace folder: ${shown}. ${NOT_STARTED}` };
+    const outside = { ok: false, line: `The spec file must be inside this folder: ${shown}. ${NOT_STARTED}` };
     const missing = { ok: false, line: `Spec file not found: ${shown}. ${NOT_STARTED}` };
     if (tok.includes('\0'))
         return outside;
@@ -298,7 +306,7 @@ export async function afterSpecGapSave(h, savedPath) {
         h.emit(`Next: ${cmd}`);
         return;
     }
-    h.queueNext(cmd);
+    h.queueNext(cmd, APP_ORIGIN);
     h.emit(STEP_2);
 }
 /** The result was written but could not be read as a spec-gap: the flow waits at step 1. */
@@ -346,6 +354,10 @@ export async function afterPlanSave(h, savedPath) {
         || canonicalLanePath(flow.lane.path) !== canonicalLanePath(lane.path) || flow.lane.sha256 !== lane.sha256)) {
         return;
     }
+    // Step 2 (I6): a plan saved for a rebuild brief under <project>/rebuilds/<APP>/
+    // moves that rebuild to `started`, with this plan's file name as its link.
+    if (flow)
+        await rebuildStartedAfterPlanSave({ cwd: h.cwd, specToken: cleanSpecToken(flow.specToken), savedPath, emit: h.emit });
     const end = () => { if (flow)
         clearAppFlow(h.session); };
     const cmd = startCommand(savedPath);
@@ -395,7 +407,7 @@ export async function afterPlanSave(h, savedPath) {
                 h.emit(OBJECT_LIST_FAILED);
             }
         }
-        h.queueNext(cmd);
+        h.queueNext(cmd, APP_ORIGIN);
     }
     else {
         h.emit(`Start it later with: ${cmd}`);

package/dist/lane/chain-token.js

@@ -9,16 +9,18 @@
 //   optional `-N` collision suffix saveProject adds);
 // - the path has no `"` and no control character (it rides in a command);
 // - the real file exists inside realpath(cwd) or realpath(workspace folder),
-//   so a link out of the save root is refused.
+//   so a link out of the save root is refused;
+// - Task 14: a path in the CLI home is accepted ONLY in the read-only seat
+//   shape (`<seat>/work/<id>/.cspeach/<name>.cspeach.json`, isSeatReadOnlyFile)
+//   — the seat is reached deliberately, never by absence of a guard.
 // Round trip: parseFromFlag reads `@"…"` / `@\S+`; resolveAtTokenAsync takes a
 // path with a separator or an absolute path verbatim; coerceDocFromFlagToAttachment
 // leaves `.cspeach.json` alone.
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { assertRealPathContained } from '../tools/_filesystem-shared.js';
-import { workspaceFolderFor } from './roots.js';
-/** `<slug>-spec-gap-<4 hex>-v<N>[-<n>].cspeach.json` — titleSlug is `[a-z0-9-]`, possibly empty. */
-export const SPEC_GAP_NAME_RE = /^[a-z0-9-]*-spec-gap-[0-9a-f]{4}-v\d+(?:-\d+)?\.cspeach\.json$/;
+import { assertRealPathContained, isCliHomePath, isSeatReadOnlyFile } from '../tools/_filesystem-shared.js';
+import { workspaceFolderFor, SPEC_GAP_NAME_RE } from './roots.js';
+export { SPEC_GAP_NAME_RE };
 // eslint-disable-next-line no-control-regex
 const UNSAFE = /["\u0000-\u001f\u007f-\u009f]/;
 /** A segment after whitespace (or at the start) that begins with `--`. */
@@ -47,6 +49,8 @@ export async function chainFromToken(cwd, savedPath) {
     const ws = await workspaceFolderFor(cwd).catch(() => undefined);
     if (!(await containedIn(abs, root)) && !(await containedIn(abs, ws)))
         return undefined;
+    if (isCliHomePath(abs) && !isSeatReadOnlyFile(abs))
+        return undefined;
     const rel = path.relative(root, abs);
     let p = rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel.split(path.sep).join('/') : abs;
     if (!path.isAbsolute(p) && !p.includes('/'))

package/dist/lane/roots.js

@@ -1,23 +1,25 @@
 // App lane routing — final fix wave I3. The ONE root the lane decision folder
 // hangs off, and the spec containment rule, shared by every caller:
 //
-// - laneRootFor(cwd): the folder that contains the workspace `.cspeach` —
-//   the git root (or cwd) for the default workspace, the configured
-//   `workspace_folder` itself otherwise (R17; never the CLI home). The lane write, every pinned read
-//   and the relative `from.lane.path` (`.cspeach/lane/<id>.json`) all use it,
-//   so a lane written from a repo subfolder is found by a resume from the
-//   repo root (plans already resolve through the workspace folder).
+// - laneRootFor(cwd): the folder that holds the working `.cspeach` — the
+//   folder you start in, or the seat work root (`<CSPEACH_HOME>/work/<id>`)
+//   for a team folder, or ~/CSPeach when you start in the home folder
+//   (2026-10-08: no git walk, workspace_folder ignored; never the CLI home).
+//   The lane write, every pinned read and the relative `from.lane.path`
+//   (`.cspeach/lane/<id>.json`) all use it.
 // - containSpecPath(cwd, p): a spec is accepted inside cwd OR the workspace
 //   folder, string-contained AND realpath-contained (no link escapes), and
 //   refused when ANY of those roots (or the lane root) would denylist it.
-import { promises as fs } from 'node:fs';
+import { promises as fs, realpathSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { resolveWorkspacePathFor } from '../projects/workspace.js';
-import { loadConfig } from '../config/loader.js';
-import { cspeachRoot } from '../config/paths.js';
-import { isDenylistedPath, PathOutsideRootError } from '../tools/_filesystem-shared.js';
-/** The workspace folder for this cwd (config override > git root > cwd), absolute. */
+import { resolveProjectFolderSync, SAFE_PROJECT_ID } from '../projects/project-folder.js';
+import { cspeachRoot, defaultCspeachRoot } from '../config/paths.js';
+import { isDenylistedPath, isSeatReadOnlyFile, PathOutsideRootError } from '../tools/_filesystem-shared.js';
+/** `<slug>-spec-gap-<4 hex>-v<N>[-<n>].cspeach.json` — titleSlug is `[a-z0-9-]`, possibly empty. */
+export const SPEC_GAP_NAME_RE = /^[a-z0-9-]*-spec-gap-[0-9a-f]{4}-v\d+(?:-\d+)?\.cspeach\.json$/;
+/** The workspace folder (the working `.cspeach`) for this cwd, absolute. */
 export async function workspaceFolderFor(cwd) {
     try {
         return path.resolve(await resolveWorkspacePathFor(cwd));
@@ -28,48 +30,96 @@ export async function workspaceFolderFor(cwd) {
 }
 /**
  * The folder whose `.cspeach/lane/` (and `.cspeach/conventions.toml`, R18)
- * belong to this project.
- * - R17: a configured `workspace_folder` is the root ITSELF
- *   (`<workspace_folder>/.cspeach/lane`), never its parent — so `~/CSPeach`
- *   never puts lane files in the CLI home `~/.cspeach`.
- * - Default workspace (`<git-root or cwd>/.cspeach`): the git root (or cwd).
+ * belong to this project: the working root for this start folder.
  */
 export async function laneRootFor(cwd) {
-    let configured;
-    try {
-        configured = (await loadConfig()).workspace_folder?.trim() || undefined;
-    }
-    catch {
-        configured = undefined;
-    }
-    if (configured)
-        return workspaceFolderFor(cwd);
-    return path.dirname(await workspaceFolderFor(cwd));
+    return resolveProjectFolderSync(cwd).workRoot;
 }
 /**
- * R17 — refuse a lane root whose `.cspeach` is the CLI home (`~/.cspeach`,
- * config + credentials): no lane or conventions file is ever written there.
+ * R17 — why a lane root (or a plan's pin root) may not be used, or null when
+ * it may. Refused: the home folder; a root whose `.cspeach` is a CLI home;
+ * the CLI home itself or anything under it — with ONE exception: a team
+ * seat's private working root `<cspeachRoot()>/work/<project id>`, exactly.
+ *
+ * Task 14 — compared on REAL paths of the nearest existing ancestor (a root
+ * that does not exist yet, spelled through a link or an 8.3 name, cannot
+ * slip past); BOTH homes are guarded (`cspeachRoot()` and `~/.cspeach`);
+ * the hard refusals run BEFORE the work-root allow; a path whose real form
+ * cannot be known is refused. The message names the seat folder.
  */
-export async function assertNotCliHome(root) {
-    // Final residual 2 — compare REAL paths, so a junction / symlink to home
-    // (or to ~/.cspeach) cannot slip past a string compare. `.cspeach` may not
-    // exist yet: then the root itself must not be the home folder.
-    const key = async (p) => {
-        const r = await realOr(p);
-        return process.platform === 'win32' ? r.toLowerCase() : r;
-    };
-    const [dot, cliHome, rootReal, home] = await Promise.all([
-        key(path.join(root, '.cspeach')), key(cspeachRoot()), key(root), key(os.homedir()),
-    ]);
-    if (dot === cliHome || rootReal === home) {
-        throw new Error('the lane folder would be inside the cspeach home folder (~/.cspeach). Set workspace_folder to a project folder.');
+export function cliHomeRefusal(root) {
+    const seats = [cspeachRoot(), defaultCspeachRoot()].filter((s, i, a) => a.indexOf(s) === i);
+    const msg = (seat) => `the lane folder would be inside the cspeach home folder (${seat}). Start CSPeach in your project folder.`;
+    const rootReal = caseKey(realForm(root));
+    const dot = caseKey(realForm(path.join(root, '.cspeach')));
+    const home = caseKey(realForm(os.homedir()));
+    if (rootReal === null || dot === null || home === null)
+        return msg(seats[0]);
+    // Hard refusals first: the home folder, or a `.cspeach` that is a CLI home.
+    if (rootReal === home)
+        return msg(defaultCspeachRoot());
+    const seatKeys = seats.map((s) => [s, caseKey(realForm(s))]);
+    for (const [s, k] of seatKeys) {
+        if (k === null || dot === k)
+            return msg(s);
+    }
+    // 2026-10-08 — a team member's private working root, exactly
+    // <cspeachRoot()>/work/<id> (never under ~/.cspeach when CSPEACH_HOME moved it).
+    // Its `.cspeach` must be its own (not a link elsewhere in the seat).
+    const chosen = seatKeys[0][1];
+    const rel = path.relative(chosen, rootReal);
+    const parts = rel.split(path.sep);
+    if (!path.isAbsolute(rel) && parts.length === 2 && parts[0] === 'work' && SAFE_PROJECT_ID.test(parts[1])) {
+        return dot === caseKey(path.join(rootReal, '.cspeach')) ? null : msg(seats[0]);
+    }
+    // Anything else in a CLI home — the root, or a `.cspeach` that links into one.
+    for (const [s, k] of seatKeys) {
+        if (rootReal === k || inside(rootReal, k) || inside(dot, k))
+            return msg(s);
     }
+    return null;
+}
+/** Throws when `root` may not be a lane root (see cliHomeRefusal). */
+export async function assertNotCliHome(root) {
+    const refusal = cliHomeRefusal(root);
+    if (refusal)
+        throw new Error(refusal);
 }
 const inside = (p, root) => {
     const rel = path.relative(root, p);
     return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
 };
 const realOr = async (p) => fs.realpath(p).catch(() => path.resolve(p));
+/**
+ * Task 14 — the real form of a folder that may not exist yet: the nearest
+ * EXISTING ancestor realpath'd (links followed, 8.3 names expanded), the
+ * missing tail re-attached. Null — the caller refuses — on any lookup error
+ * other than "does not exist", or (win32) a missing segment with '~' (a
+ * possible 8.3 name we cannot decode).
+ */
+function realForm(p) {
+    let cur = path.resolve(p);
+    const tail = [];
+    for (;;) {
+        try {
+            const r = realpathSync.native(cur);
+            return tail.length ? path.join(r, ...tail) : r;
+        }
+        catch (e) {
+            if (e?.code !== 'ENOENT')
+                return null;
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                return null;
+            const name = path.basename(cur);
+            if (process.platform === 'win32' && name.includes('~'))
+                return null;
+            tail.unshift(name);
+            cur = parent;
+        }
+    }
+}
+const caseKey = (p) => (p === null ? null : process.platform === 'win32' ? p.toLowerCase() : p);
 export class SpecProtectedError extends Error {
     constructor(specPath) {
         super(`spec file is in a protected location and cannot be read: ${specPath}`);
@@ -95,6 +145,12 @@ export async function containSpecPath(cwd, specPath) {
     const realRoots = await Promise.all(roots.map(realOr));
     if (!realRoots.some((r) => inside(real, r)))
         throw new PathOutsideRootError(specPath, cwd);
+    // Ruling 14 (Task 14) — the one explicit opening into the seat: a spec-gap
+    // ENVELOPE saved directly in <seat>/work/<id>/.cspeach, read-only (the
+    // read-only seat shape, judged on the spelled and the real path). Anything
+    // else in the seat (a raw .md, other envelopes, lane files) stays refused.
+    if (SPEC_GAP_NAME_RE.test(path.basename(real)) && isSeatReadOnlyFile(abs) && isSeatReadOnlyFile(real))
+        return { abs, real };
     const guards = [...realRoots, await realOr(await laneRootFor(cwd))];
     for (const r of guards) {
         if (inside(real, r) && isDenylistedPath(real, r).blocked)

package/dist/one-shot.js

@@ -69,12 +69,16 @@ 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 } from './session/project-match.js';
+import { detectRunStart } from './runs/front-door.js';
+import { guardRunLabel } from './runs/shadow.js';
 export async function runOneShot(prompt, opts) {
     applyColorMode(); // NO_COLOR (piece 2 §1.2)
     const cfg = await loadConfig();
@@ -192,9 +196,28 @@ export async function runOneShot(prompt, opts) {
         }
         adt = new AdtClient(conn);
     }
-    const session = newSession(makeSessionId(), alias, null, resolveModelRole('session_default', cfg));
+    const session = newSession(makeSessionId(), alias, null, resolveModelRole('session_default', cfg), folderTag(process.cwd()));
     await saveSession(session);
-    const parsed = parseShortcut(prompt);
+    // Guided runs — the same front door as both REPLs (audit G-2). One-shot is
+    // headless: a start sentence prints its next step and queues nothing; no
+    // model call. A bare "continue" / "carry on" keeps its old meaning here
+    // (resume: false — final fix wave).
+    const door = await detectRunStart(prompt, { cwd: process.cwd(), session, resume: false });
+    if (door.kind === 'line') {
+        console.error(door.line);
+        return 1;
+    }
+    const input = door.input;
+    if (door.kind === 'run') {
+        const { runJourneyEntry } = await import('./repl/journey-entry.js');
+        await runJourneyEntry(door.trigger, {
+            session, cwd: process.cwd(), adt, sapAlias: alias, standalone, headless: true,
+            emit: (line) => writeStdout(line + '\n'),
+            signal: new AbortController().signal,
+        });
+        return 0;
+    }
+    const parsed = parseShortcut(input);
     const body = parsed.prompt;
     let skill;
     if (parsed.skill) {
@@ -241,6 +264,9 @@ export async function runOneShot(prompt, opts) {
         finally {
             routingBeat.stop();
         }
+        // Defensive (spec §4 step 2): a run label never dispatches in this release.
+        // No shadow here: one-shot exits when the turn ends (ruling 5).
+        c = guardRunLabel(c);
         if (c.offline) {
             // Remote classify failed twice — local-rules fallback fired. Print
             // to stderr so it doesn't pollute stdout for scripted callers, but