@cspeach/cli 1.1.22 → 1.1.24

package/dist/agent/loop.js

@@ -37,6 +37,10 @@ import { enrichUserMessage } from '../router/intent-extractor.js';
 import { resetRule8State, shouldGateRule8 } from '../repl/rule8-detector.js';
 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 { afterPlanSave, 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';
 import { input } from '@inquirer/prompts';
 import { withInquirer } from '../repl/inquirer-guard.js';
@@ -312,6 +316,10 @@ export async function maybeOfferSave(p) {
             confirm: isHeadless() ? undefined : inkAwareConfirm,
             log: (...lines) => lines.forEach((l) => p.emit(l)),
             promotedFrom: p.promotedFrom ?? null,
+            // Task 7 review round 2 — the app-flow lane only for the turn routed to
+            // the skill it saves (the /abap-plan turn that got the lane block); a plan
+            // found in another skill's output (detectArtifactSkill) never gets it.
+            ...(p.lane && p.skill === saveSkill ? { lane: p.lane } : {}),
         });
         // 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
@@ -328,6 +336,18 @@ export async function maybeOfferSave(p) {
                 log: (...lines) => lines.forEach((l) => p.emit(l)),
             });
         }
+        // App lane routing (Task 7) — the harness-owned /abap-app chain. Built
+        // from the exact saved path, never from model text. Outside an app flow
+        // (spec-gap) or without from.lane (plan) these do nothing. Review round 1:
+        // only when the turn was routed to the skill it saved — an artefact found
+        // in another skill's output (detectArtifactSkill) never moves the chain.
+        if (savedPath && p.appChain && p.skill === saveSkill) {
+            const hooks = { ...p.appChain, headless: isHeadless(), emit: p.emit };
+            if (saveSkill === 'abap-spec-gap')
+                await afterSpecGapSave(hooks, savedPath);
+            else if (saveSkill === 'abap-plan')
+                await afterPlanSave(hooks, savedPath);
+        }
     }
     catch (err) {
         p.emit('\n' + formatAttention({ text: 'Not saved as a project file', fact: String(err?.message ?? err) }).trimEnd());
@@ -444,6 +464,64 @@ export async function runTurn(params) {
     // prepend a "Promoted from..." block to the LLM input, and stash the
     // snapshot for the post-turn save hook so the saved envelope's
     // promotedFrom field is populated.
+    // App lane routing (Task 7) — stage 1 of the /abap-app chain. `/abap-app
+    // @<spec>` (no --from) starts the session's app flow with the cleaned,
+    // workspace-relative spec path and runs as abap-spec-gap, so the spec-gap
+    // skill body does the work. A spec that is missing or outside the workspace
+    // is refused with one line: no flow (a stale one is dropped), and the turn
+    // still runs as spec-gap so the skill can say what is wrong.
+    // I1 (final review) — only an explicit slash command, or a fresh classifier
+    // pick (the session was not already in abap-app), or any turn with no flow
+    // at the lane step (final residual 3), starts stage 1. A plain reply at the
+    // lane step ("ok", "use RAP") falls through to the gate and stays in the flow.
+    if (!readerChild && !params.ctx.subagent && params.skill === 'abap-app' && !parseFromFlag(params.userMessage).fromPath
+        && (params.explicitSlash === true || session.skill !== 'abap-app' || getAppFlow(session)?.expect !== 'lane')) {
+        // I5 — the lane step needs app_lane_resolve (flag-gated: local_build or
+        // standalone). Check the same visible list the turn would send, and
+        // refuse before any model call rather than failing at stage 2.
+        if (!toolsForContext(listTools(), params.ctx).some((t) => t.name === 'app_lane_resolve')) {
+            clearAppFlow(session);
+            const raw = extractSpecToken(params.userMessage);
+            const tok = raw === undefined ? '' : cleanSpecToken(raw);
+            emit(chalk.yellow('/abap-app needs local build tools.'));
+            emit(chalk.yellow('Run: cspeach config set local_build on'));
+            emit(chalk.yellow(`Then restart cspeach and run /abap-app ${shownToken(tok || undefined, 'spec')} again.`));
+            return;
+        }
+        const spec = await resolveAppSpec(params.ctx.cwd, params.userMessage);
+        if (spec.ok) {
+            startAppFlow(session, spec.rel);
+            emit(STEP_1);
+        }
+        else {
+            clearAppFlow(session);
+            emit(chalk.yellow(spec.line));
+        }
+        params = { ...params, skill: 'abap-spec-gap' };
+    }
+    else if (!readerChild && !params.ctx.subagent) {
+        // R11 (review round 1) — any turn that is not part of the flow's current
+        // step ends the flow, so a stale flow never changes a later run.
+        const gate = await gateAppFlowForTurn(session, {
+            skill: params.skill,
+            userMessage: params.userMessage,
+            explicitSlash: params.explicitSlash === true,
+            previousSkill: session.skill,
+            cwd: params.ctx.cwd,
+        });
+        // I4(a) — the flow ends here: say once, plainly, that this plan will not
+        // use the build lane. Interactive only (headless / one-shot keep no flow).
+        if (gate.ended && gate.hadState) {
+            const { isHeadless } = await import('../renderer/tty.js');
+            if (!isHeadless())
+                emit(chalk.yellow(FLOW_ENDED_LINE));
+        }
+    }
+    // Stage 3 — the /abap-plan --from turn of an app flow at its plan step.
+    if (!readerChild && !params.ctx.subagent && params.skill === 'abap-plan' && params.suppressSaveHook !== true
+        && parseFromFlag(params.userMessage).fromPath && getAppFlow(session)?.expect === 'plan') {
+        emit(STEP_3);
+    }
     let promotedFromForSave = null;
     let userMessageForLLM = params.userMessage;
     let userMessageForSave = params.userMessage;
@@ -463,12 +541,23 @@ export async function runTurn(params) {
         }
         const { fromPath, rest } = parseFromFlag(docAttach ? '' : params.userMessage);
         if (fromPath) {
+            // M4 — inside an /abap-app flow the open-items question is asked once:
+            // a yes at stage 2 (lane step) is recorded on the flow, and stage 3
+            // (plan step) skips it when it promotes the same real file.
+            const flowNow = !params.ctx.subagent ? getAppFlow(session) : undefined;
+            const confirmedGap = flowNow?.gapConfirmed;
             const result = await runPromoteCommand({
                 sourcePath: fromPath,
                 targetSkill: params.skill,
                 prompt: inkAwarePrompt,
                 confirm: inkAwareConfirm,
                 log: (...lines) => lines.forEach((l) => emit(l)),
+                // Final residual 4 — the same folder gateAppFlowForTurn resolves @X against.
+                cwd: params.ctx.cwd,
+                ...(flowNow?.expect === 'lane' && params.skill === 'abap-app'
+                    ? { onOpenWarningsConfirmed: (p) => setGapConfirmed(session, p) } : {}),
+                ...(flowNow?.expect === 'plan' && params.skill === 'abap-plan' && confirmedGap
+                    ? { skipOpenWarnings: (p) => sameRealFile(p, confirmedGap) } : {}),
             });
             if (!result) {
                 // User declined, source invalid, or unsupported target — skip the turn.
@@ -519,6 +608,27 @@ ${imageExpansion.error}`));
     if (!readerChild) {
         userMessageForLLM = await expandTextFileAttachments(userMessageForLLM, params.ctx.cwd, (line) => emit(chalk.dim(line)));
     }
+    // App lane routing (Task 6) — the /abap-plan creation turn inside an app
+    // flow gets the confirmed <lane_decision> block (read with the app-flow sha;
+    // a changed file is refused with a plain line). '' on every other turn, so
+    // the model input is unchanged. Resume turns add their own block.
+    if (!readerChild) {
+        const laneBlock = await planLaneBlockForTurn({
+            skill: params.skill,
+            session,
+            cwd: params.ctx.cwd,
+            emit: (line) => emit(chalk.yellow(line)),
+            resumeTurn: params.suppressSaveHook === true,
+        });
+        // M5 — the lane cannot be used: the refusal line is out; end the turn
+        // now (no model call) and end the flow, which cannot reach a saved plan.
+        if (laneBlock === null) {
+            clearAppFlow(session);
+            return;
+        }
+        if (laneBlock)
+            userMessageForLLM = `${userMessageForLLM}\n\n${laneBlock}`;
+    }
     // 2026-05-06: alongside the deterministic prompt-fact extraction
     // (package / transport / etc.), inject the connected SAP system's
     // release + platform + ABAP version. One CVERS query the first time
@@ -1454,6 +1564,18 @@ ${imageExpansion.error}`));
                         model: params.modelOverride ?? resolveModelRole('session_default', cfg) ?? session.model ?? 'unknown',
                         emit,
                         promotedFrom: promotedFromForSave,
+                        ...(() => {
+                            const flowLane = getAppFlow(session)?.lane;
+                            return flowLane ? { lane: { ...flowLane, cwd: params.ctx.cwd } } : {};
+                        })(),
+                        // Task 7 — subagent / reader turns never drive the app chain.
+                        ...(!readerChild && !params.ctx.subagent ? {
+                            appChain: {
+                                session,
+                                cwd: params.ctx.cwd,
+                                ...(params.ctx.pendingDispatch ? { queueNext: (cmd) => params.ctx.pendingDispatch.set(cmd) } : {}),
+                            },
+                        } : {}),
                     });
                 }
             }
@@ -1691,6 +1813,8 @@ ${imageExpansion.error}`));
                     })();
                     const isInteractiveTool = block.name === 'ask_question' ||
                         block.name === 'request_approval' ||
+                        // App lane routing (Task 5): shows the lane card from inside the handler.
+                        block.name === 'app_lane_resolve' ||
                         willTripBatchGate;
                     // Interactive tools block on the USER. PAUSE the turn-status row (don't
                     // just relabel it): a live 250ms tick repaints the dynamic frame and

package/dist/agent/tool-dispatch.js

@@ -38,6 +38,8 @@ export async function dispatchTool(name, args, ctx) {
     // silent). Headless runs are declined, never auto-approved.
     // The hook may be async (it reads the app's files). A hook that throws is
     // doubt — never let the call through unprompted: fail the call instead.
+    // `scope` (optional) keys the approval per tool too — sap_link sets it so a
+    // fiori_preview approval for the same alias does not cover it (Task 8 M-2).
     let handover = null;
     try {
         handover = (await tool.credentialHandover?.(args, ctx)) ?? null;
@@ -49,7 +51,7 @@ export async function dispatchTool(name, args, ctx) {
         };
     }
     const sessionId = ctx.session?.id;
-    if (handover && !isCredentialHandoverApproved(sessionId, handover.alias)) {
+    if (handover && !isCredentialHandoverApproved(sessionId, handover.alias, handover.scope)) {
         const r = await presentSafetyConfirmation({
             rule: 'CREDENTIAL_HANDOVER',
             op: tool.name,
@@ -61,7 +63,7 @@ export async function dispatchTool(name, args, ctx) {
         });
         if (!r.confirmed)
             return declined(r);
-        markCredentialHandoverApproved(sessionId, handover.alias);
+        markCredentialHandoverApproved(sessionId, handover.alias, handover.scope);
     }
     // Rule 8 — no batch without plan. 2nd+ mutating call this turn requires
     // explicit confirmation. Fires regardless of /safety-mode toggle (batch

package/dist/classifier/client.js

@@ -1,7 +1,27 @@
 const RULES = [
+    // abap-app (app lane routing slice 1, 2026-10-01) — building an app FROM a
+    // spec / requirements document. FIRST so a spec-document build beats every
+    // stack-specific rule below (fiori-build, rap, cap, spec-gap, generate). A
+    // direct request without a spec document never matches and keeps its skill.
+    // Review round 1 (I2): a whole-prompt guard keeps "spec gap(s)" prompts on
+    // abap-spec-gap (whitespace only — a hyphenated spec-gap-….json file name
+    // does not trip it).
+    { skill: 'abap-app', patterns: [
+            /^(?![\s\S]*\bspec\s+gaps?\b)[\s\S]*?\b(build|create|make|develop)\b[^.?!\n]{0,60}\b(app|application)\b[^.?!\n]{0,60}(\bspec(s|ification)?\b|\brequirements?\s+(doc|document|file|sheet)\b|\.(docx|pdf|xlsx)\b)/i,
+            /^(?![\s\S]*\bspec\s+gaps?\b)[\s\S]*?(\bspec(s|ification)?\b|\brequirements?\s+(doc|document|file|sheet)\b|\.(docx|pdf|xlsx)\b)[^.?!\n]{0,60}\b(build|create|make|develop)\b[^.?!\n]{0,30}\b(app|application)\b/i,
+        ] },
     { skill: 'abap-atc-fix', patterns: [/atc\s+(fix|auto\s+fix)|abap\s+test\s+cockpit.*fix/i] },
     { skill: 'abap-cca', patterns: [/custom\s+code\s+analysis|\bcca\b|clean\s+core\s+(assessment|analysis)/i] },
     { skill: 'abap-cloud-check', patterns: [/cloud\s+ready|clean\s+core(?!\s+(assessment|analysis))|s\/4hana\s+cloud\s+check/i] },
+    // abap-cap (2026-10-01) MUST precede abap-data-model ("CDS domain model"
+    // would hit its bare `domain`) and abap-fiori-build / abap-rap (a CAP app
+    // ships a Fiori Elements UI). Side-by-side / BTP framing → CAP.
+    // Review round 1 (I1): narrowed so no prompt that routed before abap-cap
+    // existed changes skill — "a cap on the quantity", "RAP/Fiori on BTP",
+    // "BTP destination in ZCL_X", "the CDS model ZI_X", "side by side" diffs.
+    // A bare BTP mention counts only when no RAP/ABAP/Fiori/UI5/Z-object word
+    // appears anywhere in the prompt.
+    { skill: 'abap-cap', patterns: [/\b(sap\s+)?cap\b(?=\s+(app|application|project|service|model|backend|extension|handler)s?\b)|\b(in|with|using|use)\s+(sap\s+)?cap\b|cloud\s+application\s+programming|\bcds\s+(model|service)\b(?!\s+(definition|[zy]\w*))|side.?by.?side\s+(app|application|extension)|^(?![\s\S]*\b(rap|abap|fiori|ui5|[zy]\w*_\w+)\b)[\s\S]*\bbtp\b/i] },
     { skill: 'abap-data-model', patterns: [/data\s+model|ddic\s+(design|structure)|domain|data\s+element|create\s+(a\s+)?z[_\w]*\s+(table|structure)|new\s+(z[_\w]*\s+)?(table|structure|domain)/i] },
     { skill: 'abap-design', patterns: [/solution\s+architecture|object\s+list|design\s+the\s+solution/i] },
     { skill: 'abap-handover', patterns: [/technical\s+documentation|object\s+catalog|doc(ument)?\s+package|handover/i] },
@@ -61,12 +81,17 @@ const RULES = [
     { skill: 'abap-transport-analysis', patterns: [/transport\s+analysis|pre.release\s+transport|transport\s+readiness/i] },
     { skill: 'abap-transport', patterns: [/transport\s+(create|release|list)|\bcts\b|release.*request/i] },
 ];
-if (RULES.length !== 33) {
+/** The skill each offline rule routes to, in rule order (one rule per skill). */
+export const RULE_SKILLS = Object.freeze(RULES.map((r) => r.skill));
+// 2026-10-01: 33 + abap-app + abap-cap = 35. The four merged-away donors
+// (abap-cloud-check, abap-document, abap-performance, abap-radar) keep their
+// rules: their .claude/skills folders are still on disk and still resolve.
+if (RULES.length !== 35) {
     // Warn-not-throw — managed-mode users never exercise classify() (the proxy
     // does server-side classification), so a module-load crash would break
     // them for a local-only consistency check. Unit tests assert the exact
     // count.
-    console.warn(`[classifier] RULES drift: expected 33, got ${RULES.length} — reconcile with .claude/skills/`);
+    console.warn(`[classifier] RULES drift: expected 35, got ${RULES.length} — reconcile with .claude/skills/`);
 }
 export function classify(prompt) {
     for (const rule of RULES) {

package/dist/cli.js

@@ -203,6 +203,18 @@ export async function main(argv) {
             },
         });
     }
+    // CAP phase 2 — run the SAP link in the foreground for a local CAP app.
+    if (args[0] === 'sap' && args[1] === 'link') {
+        const { runSapLinkCommand } = await import('./commands/sap-link.js');
+        return runSapLinkCommand(args.slice(2), {
+            print: (s) => console.log(s),
+            defaultAlias: sapAlias,
+            standalone: async () => {
+                const { loadConfig, resolveStandalone } = await import('./config/loader.js');
+                return resolveStandalone(await loadConfig(), noSap);
+            },
+        });
+    }
     // Typed from yesterday's notes. Without this the words fall through to the
     // one-shot path at the bottom of this function and are sent to the model as
     // a PAID prompt on a machine that is configured and logged in. A hint, not
@@ -255,6 +267,7 @@ Usage:
   cspeach config set <key> <value>  Update a config key
   cspeach config unset <key>        Remove a config key (revert to default)
   cspeach config show [key]         Show config (full or single key)
+  cspeach sap link [alias] [--project dir]  Let a local CAP app reach its S/4 services (Ctrl+C stops)
   cspeach doctor                    Diagnose install + connectivity
   cspeach login                     Sign in via device-code flow
   cspeach logout                    Sign out (keep keychain key, if any)

package/dist/commands/plan-audit-evidence.js

@@ -69,6 +69,52 @@ const PROTECTED_TOOL_RE = /^sap_(set_source|update_method|create_object|delete_o
 const EXISTENCE_READ_RE = /^sap_(object_structure|get_source|transport_for_object)/;
 /** Any row the auditor may see is the union of the two tiers. */
 const EVIDENCE_TOOL_RE = new RegExp(`${PROTECTED_TOOL_RE.source}|${EXISTENCE_READ_RE.source}`);
+/**
+ * CAP phase 2 (2026-09-30): a CAP phase writes LOCAL files and proves itself
+ * with `cds build` + the Fiori/CAP smokes — none of which are sap_* rows. Without
+ * these the auditor sees the "(no ...)" sentinel and B4-blocks a finished phase.
+ * PROTECTED tier: they are the proof, never evicted by reads.
+ *
+ * R26: the CAP-only tools (and `cds build` rows) exist only in CAP work, so they
+ * are admitted always. The fiori_* smokes also run in RAP/Fiori sessions; they
+ * are admitted ONLY when the audited phase is a cap.* phase, so RAP/Fiori audits
+ * stay byte-identical to main.
+ */
+export const CAP_PROOF_TOOL_RE = /^(cap_metadata_import|cap_link_smoke)$/;
+/** Fiori smokes: CAP proof only in a cap.* phase audit (R26). */
+export const CAP_PHASE_SMOKE_TOOL_RE = /^(fiori_render_smoke|fiori_draft_smoke|fiori_metadata_audit)$/;
+/** True for a CAP proof row (tool name + args), given whether the audited phase is cap.*. */
+function isCapProof(toolName, args, capPhase) {
+    if (CAP_PROOF_TOOL_RE.test(toolName))
+        return true;
+    if (capPhase && CAP_PHASE_SMOKE_TOOL_RE.test(toolName))
+        return true;
+    return toolName === 'shell_exec' && isCapBuildShellRow(args);
+}
+/**
+ * A shell_exec row is CAP proof only for `cds build|compile|import`, with `cds`
+ * matched BY POSITION (controller ruling R6): argv[0] (`cds build`), argv[1]
+ * after `npx`, or argv[2] after `npm exec` / `pnpm exec`. Not `pnpm dlx cds`: it
+ * fetches the registry package `cds`, not @sap/cds-dk, so it proves nothing. Matching
+ * `cds` anywhere would let a safelisted row such as
+ * `git commit -m cds build` or `node x.js cds build` pass as PROTECTED build proof.
+ */
+export function isCapBuildShellRow(args) {
+    if (!args || typeof args !== 'object')
+        return false;
+    const a = args;
+    const argv = [a.command, ...(Array.isArray(a.args) ? a.args : [])].map(String);
+    let i = -1;
+    if (argv[0] === 'cds')
+        i = 0;
+    else if (argv[0] === 'npx' && argv[1] === 'cds')
+        i = 1;
+    else if ((argv[0] === 'npm' || argv[0] === 'pnpm') && argv[1] === 'exec') {
+        if (argv[2] === 'cds')
+            i = 2;
+    }
+    return i >= 0 && ['build', 'compile', 'import'].includes(argv[i + 1] ?? '');
+}
 const NO_LOG_SENTINEL = '(no tool-call log found for this session)';
 const NO_EVIDENCE_ROWS = '(tool-call log present, but no write/verify calls recorded for this session)';
 const DEFAULT_MAX_ROWS = 60;
@@ -101,7 +147,7 @@ function resultCapFor(toolName) {
         return ATC_RESULT_CAP;
     return RESULT_EXCERPT_CHARS;
 }
-function normalizeRow(raw) {
+function normalizeRow(raw, capPhase) {
     if (raw === null || typeof raw !== 'object')
         return null;
     const r = raw;
@@ -119,9 +165,19 @@ function normalizeRow(raw) {
     // PROTECTED is checked first: it is a strict-enough family that no
     // existence-read name can collide with it, but ordering makes the tiering
     // explicit for the reader.
-    const kind = PROTECTED_TOOL_RE.test(toolName) ? 'protected' : 'existence';
+    const kind = PROTECTED_TOOL_RE.test(toolName) || isCapProof(toolName, r.args, capPhase)
+        ? 'protected' : 'existence';
     return { toolName, args: r.args, result: r.result, isError, at, kind };
 }
+/**
+ * Admission filter: the sap_* write/verify + existence-read tiers, plus CAP
+ * proof (cap_link_smoke / cap_metadata_import, the fiori_* smokes in a cap.*
+ * phase only, and shell_exec ONLY for `cds build|compile|import` — never
+ * arbitrary shell rows).
+ */
+function isEvidenceRow(row, capPhase) {
+    return EVIDENCE_TOOL_RE.test(row.toolName) || isCapProof(row.toolName, row.args, capPhase);
+}
 /** Render the args as `name/type` when available, else a compact fallback. */
 function renderArgs(args) {
     if (args === null || args === undefined || typeof args !== 'object')
@@ -201,6 +257,7 @@ function renderRow(row) {
  */
 export async function extractAuditEvidence(sessionId, opts) {
     const maxRows = opts?.maxRows ?? DEFAULT_MAX_ROWS;
+    const capPhase = opts?.capPhase === true;
     const sinceIso = opts?.sinceIso;
     const filePath = path.join(checkpointsRoot(), sessionId, 'tool-calls.jsonl');
     let content;
@@ -222,8 +279,8 @@ export async function extractAuditEvidence(sessionId, opts) {
         catch {
             continue; // malformed line — skip silently
         }
-        const row = normalizeRow(parsed);
-        if (!row || !EVIDENCE_TOOL_RE.test(row.toolName))
+        const row = normalizeRow(parsed, capPhase);
+        if (!row || !isEvidenceRow(row, capPhase))
             continue;
         // D-B attempt-window: drop rows recorded before this attempt started.
         // ISO-8601 UTC strings compare correctly lexicographically. A row with no

package/dist/commands/plan-audit.js

@@ -189,6 +189,13 @@ export const PLAN_AUDIT_PROMPT_CONTRACT = [
     '- Transport (infra, not a deliverable): recorded in work.transport (and/or an sap_transport',
     '  row). A transport is NEVER required in work.generated and is NEVER activated — do not flag',
     '  a transport for having no write and no activation.',
+    '- Local CAP work (phase layer cap.link / cap.model / cap.service / cap.ui): NO SAP object is',
+    '  written and NO sap_activate is expected — its absence is NEVER a finding for these layers.',
+    '  Proof is: an ok shell_exec `cds build` (or `cds compile`) row for the build, and for',
+    '  cap.link an ok cap_link_smoke live read leg (a result saying "mock only" does not count);',
+    '  for cap.model and cap.service an ok `cds build` plus an ok cap_link_smoke mock; for cap.ui',
+    '  ok fiori_render_smoke, ok fiori_draft_smoke when the app has draft, and ok cap_link_smoke.',
+    '  A cap_link_smoke result that says "mock only" proves the offline gate, not the live one.',
     'If you cannot map a type code to one of these classes, that is a W3 warn, not a block.',
     '',
     'ESCALATION EXCEPTION (§6, governs B3) — recognized from GROUND TRUTH, not the manifest\'s',
@@ -427,7 +434,12 @@ async function buildAuditPrompt(args) {
         manifest: phase.manifest,
         work: phase.work ?? null,
     }, null, 2);
-    const evidence = await extractAuditEvidence(sessionId, sinceIso ? { sinceIso } : undefined);
+    // R26: fiori_* smoke rows are evidence only when the audited phase is a CAP phase.
+    const capPhase = typeof phase.layer === 'string' && phase.layer.startsWith('cap.');
+    const evidence = await extractAuditEvidence(sessionId, {
+        ...(sinceIso ? { sinceIso } : {}),
+        ...(capPhase ? { capPhase } : {}),
+    });
     const windowAttr = sinceIso ? ` window="this attempt only, since ${sinceIso}"` : '';
     return [
         `Independent audit of plan phase "${phaseId}" — plan "${envelope.title}" (envelope v${envelope.version}).`,

package/dist/commands/plan-continue.js

@@ -16,6 +16,7 @@ import { findNewestVersion } from './plan-resume.js';
 import { collectTurnAssistantText } from '../agent/turn-assistant-text.js';
 import { finishPlanResume } from './plan-resume.js';
 import { runPostPhaseChain } from './plan-chain.js';
+import { loadPlanLaneForRun } from '../projects/plan-lane.js';
 /**
  * The same block shape loop.ts's manifest-on-interrupt hook scans for.
  * E2 dual-read: accept both the legacy `csforge:` and current `cspeach:` prefixes.
@@ -76,7 +77,7 @@ export function classifyContinuationText(text, envelopeTitle) {
  * never leaves a fresh lock behind. Every null return means "run a normal
  * turn"; `stale` additionally tells the caller to clear the marker.
  */
-export function preparePlanContinuation(args) {
+export async function preparePlanContinuation(args) {
     const { marker } = args;
     let path = marker.path;
     if (!existsSync(path))
@@ -99,6 +100,14 @@ export function preparePlanContinuation(args) {
     const phase = parsed.content.phases.find((p) => p.id === marker.phaseId);
     if (!phase)
         return { prepared: null, stale: true };
+    // 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);
+    if (!laneGate.ok) {
+        args.log(...laneGate.lines);
+        return { prepared: null, stale: false, paused: true };
+    }
     // Lease LAST: a stale marker (missing file / unknown phase) must never leave
     // a fresh lock behind. A LIVE other-session holder is contention, NOT stale —
     // the marker stays so the user can finish there or take over via --resume.
@@ -122,6 +131,7 @@ export function preparePlanContinuation(args) {
         ...(marker.effectiveMode ? { effectiveMode: marker.effectiveMode } : {}),
         ...(marker.auditFlag ? { auditFlag: marker.auditFlag } : {}),
         ...(marker.auditMode ? { auditMode: marker.auditMode } : {}),
+        ...(laneGate.rec ? { laneRecord: laneGate.rec } : {}),
     };
     return { prepared };
 }

package/dist/commands/plan-resume.js

@@ -54,6 +54,7 @@ import { FLOORPLAN_TO_TEMPLATE } from '../tools/fiori/floorplan-map.js';
 import { getCurrentTransport, setCurrentTransport } from '../repl/current-transport.js';
 import { askYesNo, isYes } from '../projects/yes-no.js';
 import { formatAttention, formatInfo } from '../renderer/notice-shape.js';
+import { checkLaneConsistency, loadPlanLaneForRun, renderLaneBlock } from '../projects/plan-lane.js';
 /**
  * Parse and STRIP the per-run chaining-mode (`--guarded` / `--step`) and
  * audit off-switch (`--audit` / `--no-audit`) flags from a plan-resume body.
@@ -227,6 +228,19 @@ export async function preparePlanResume(args) {
         return null;
     }
     let content = pc.content;
+    // App lane routing (Task 6, Review Focus 3) — a plan made for a lane reads
+    // the decision file with the sha it recorded, BEFORE anything else happens
+    // (no transport adoption, no lease, no phase). A changed or missing file
+    // pauses the plan; the edited lane is never used. Plans without from.lane
+    // 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);
+    if (!laneGate.ok) {
+        args.log(...laneGate.lines);
+        return null;
+    }
+    const laneRecord = laneGate.rec;
     // Transport display on resume (2026-07-09) — adopt the plan's dedicated
     // transport into the session so the `tr <TRKORR>` status segment shows it.
     // A fresh process resuming mid-plan runs no sap_transport_create (the
@@ -400,6 +414,7 @@ export async function preparePlanResume(args) {
             auditMode: effectiveAudit,
             reauditPhaseId,
             reauditPhaseIds,
+            ...(laneRecord ? { laneRecord } : {}),
         };
     }
     if (!next) {
@@ -449,7 +464,13 @@ export async function preparePlanResume(args) {
             ruleBlocks.push(`<rule file="${rel}" missing="true"/>  <!-- not found locally — apply built-in Forge defaults -->`);
         }
     }
-    const planState = JSON.stringify({ title: envelope.title, version: envelope.version, statuses, content }, null, 2);
+    // App lane routing (Task 6): the lane ref is CLI-owned — the model sees the
+    // <lane_decision> block below, never the decision file path. A lane-less
+    // plan passes `content` itself (byte-identical plan_state).
+    const stateContent = content.from.lane
+        ? { ...content, from: (({ lane: _lane, ...rest }) => rest)(content.from) }
+        : content;
+    const planState = JSON.stringify({ title: envelope.title, version: envelope.version, statuses, content: stateContent }, null, 2);
     // A2 (defects D23/D30) — compact write-back: the model re-emitting the
     // full plan content every phase cost ~6–10k output tokens/phase at Opus
     // pricing for data the envelope already holds. The resume turn emits
@@ -502,6 +523,9 @@ export async function preparePlanResume(args) {
         ...ruleBlocks,
         '</phase_rules>',
         '',
+        // App lane routing (Task 6): the lane decision, so design and build phases
+        // stay in the lane. Absent ⇒ nothing added (byte-identical prompt).
+        ...(laneRecord ? [renderLaneBlock(laneRecord), ''] : []),
         // A1 (2026-06-10, defect D23): the old contract let the model ask a
         // continuation question and keep executing phases in-turn — a 6-phase
         // run snowballed to a 3.24M-token context because the turn never
@@ -531,6 +555,7 @@ export async function preparePlanResume(args) {
         nextPhaseWrites: phaseWrites(next),
         llmPrompt, mode: flags.mode, effectiveMode,
         auditFlag: flags.audit, auditMode: effectiveAudit,
+        ...(laneRecord ? { laneRecord } : {}),
     };
 }
 /**
@@ -729,6 +754,18 @@ export async function finishPlanResume(args) {
         args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
         return null;
     }
+    // App lane routing (Task 6, Review Focus 4) — the write-back may restructure
+    // the plan (full shape) or overlay a phase; it must still fit the lane.
+    if (args.prepared.laneRecord) {
+        const conflict = checkLaneConsistency(extract.content, args.prepared.laneRecord);
+        if (conflict) {
+            args.log('');
+            args.log(`[plan] PHASE RESULT NOT PERSISTED — ${conflict}`);
+            args.log('[plan] The plan envelope is unchanged. Check what the phase actually built, then');
+            args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
+            return null;
+        }
+    }
     const nowIso = new Date().toISOString();
     const statuses = extract.statuses;
     const executedId = args.prepared.nextPhaseId;

package/dist/commands/sap-link.js

@@ -0,0 +1,52 @@
+// cspeach-cli/src/commands/sap-link.ts
+//
+// CAP phase 2, Task 8 — `cspeach sap link [alias] [--project dir]`: run the SAP
+// link in the foreground for a local CAP app. Ctrl+C stops it and exits 0.
+// Never prompts for a password; refuses in standalone (no-SAP) mode; prints
+// only plain registry messages, never raw exception text.
+import { ensureSapLink, stopSapLink, SapLinkError } from '../sap-link/registry.js';
+import { LinkConfigError } from '../sap-link/project.js';
+function waitForSignal() {
+    return new Promise((resolve) => {
+        const done = () => {
+            process.off('SIGINT', done);
+            process.off('SIGTERM', done);
+            resolve();
+        };
+        process.once('SIGINT', done);
+        process.once('SIGTERM', done);
+    });
+}
+export async function runSapLinkCommand(argv, deps) {
+    if (deps.standalone && (await deps.standalone())) {
+        deps.print('The SAP link needs a SAP system. CSPeach is running without one (standalone).');
+        return 1;
+    }
+    const pi = argv.indexOf('--project');
+    const projectDir = pi >= 0 ? argv[pi + 1] ?? '.' : '.';
+    const alias = argv.find((a, i) => !a.startsWith('--') && argv[i - 1] !== '--project') ?? deps.defaultAlias;
+    if (!alias) {
+        deps.print('Name the SAP system: cspeach sap link <alias>');
+        return 1;
+    }
+    try {
+        const r = await ensureSapLink(projectDir, alias, deps.linkDeps);
+        deps.print(`SAP link on: ${r.handle.url} → ${alias}`);
+        deps.print(`Services: ${r.services.join(', ')}`);
+        if (r.roleNote)
+            deps.print(r.roleNote);
+        if (r.tlsNote)
+            deps.print(r.tlsNote);
+        if (r.httpNote)
+            deps.print(r.httpNote);
+        deps.print('Start your app with: cds watch --profile s4   (Ctrl+C here stops the link)');
+    }
+    catch (e) {
+        deps.print(e instanceof SapLinkError || e instanceof LinkConfigError ? e.message : 'The SAP link could not start.');
+        return 1;
+    }
+    await (deps.waitForStop ?? waitForSignal)();
+    await stopSapLink(projectDir);
+    deps.print('SAP link stopped.');
+    return 0;
+}