@cspeach/cli 1.1.51 → 1.1.52

package/dist/cli.js

@@ -157,12 +157,20 @@ export async function main(argv) {
             // Task 12 — the full dump ends with "# model set by your account admin"
             // when /v1/me/model-config says the admin's model is enforced. Capped at
             // 1.5 s and fail-open: offline / signed out ⇒ the output is unchanged.
-            const [{ loadConfig }, { getStore }, { loadCustomerModelConfig }] = await Promise.all([
+            const [{ loadConfig }, { getStore }, { loadCustomerModelConfig, loadServerModelConfig }] = await Promise.all([
                 import('./config/loader.js'),
                 import('./auth/api-key.js'),
                 import('./models/server-config.js'),
             ]);
-            await loadCustomerModelConfig(await loadConfig(), async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }).catch(() => { });
+            const showCfg = await loadConfig();
+            await Promise.all([
+                loadCustomerModelConfig(showCfg, async () => (await (await getStore()).get()) ?? '', { timeoutMs: 1500 }).catch(() => { }),
+                // Stage 1A — only a stored `assistant.skills = inline` needs the served
+                // flag (the "not active" comment). Managed only, same cap, fail-open.
+                showCfg.assistant?.skills === 'inline'
+                    ? loadServerModelConfig(showCfg, { timeoutMs: 1500 }).catch(() => { })
+                    : Promise.resolve(),
+            ]);
         }
         await runConfigShow(args.slice(2));
         return 0;

package/dist/commands/compact.js

@@ -33,6 +33,7 @@ import { paint } from '../renderer/theme.js';
 import { getGlyphs } from '../renderer/glyphs.js';
 import { saveSession } from '../session/store.js';
 import { isUserPrompt } from '../session/user-prompt.js';
+import { stripSkillBlocksInMessage } from '../agent/inline-skill-block.js';
 import { rebuildCliMarksAfterCompact, COMPACT_LINE } from '../session/cli-record.js';
 import { getActiveDeployments } from '../models/model-identity.js';
 /** Keep this many recent user-prompt anchored turns verbatim. */
@@ -131,7 +132,11 @@ export function buildSummarisationPrompt() {
  */
 export function serialiseForSummariser(messages) {
     const out = [];
-    for (const msg of messages) {
+    for (const original of messages) {
+        // Stage 1A (S-A, M-3) — a playbook body never reaches the summariser: a
+        // hash-passing <skill> block in user text becomes [skill block: <name>].
+        // A message without one is the same object (byte-identical output).
+        const msg = stripSkillBlocksInMessage(original);
         if (typeof msg.content === 'string') {
             out.push({ role: msg.role, content: msg.content });
         }

package/dist/commands/config-set.js

@@ -19,6 +19,7 @@ const MUTABLE_KEYS = new Set([
     'assistant.lane',
     'assistant.style',
     'assistant.level',
+    'assistant.skills',
     'local_build',
     'local_files', // deprecated alias for local_build (2026-06-13) — still accepted
     'show_cogs',
@@ -83,6 +84,7 @@ const PLAN_MODE_VALUES = ['step', 'guarded'];
 const PLAN_AUDIT_VALUES = ['on', 'off'];
 const USAGE_REPORTING_VALUES = ['on', 'off'];
 const ASSISTANT_LANE_VALUES = ['chat', 'skills'];
+const ASSISTANT_SKILLS_VALUES = ['system', 'inline'];
 const APPROVALS_VALUES = ['plan', 'per-write'];
 /**
  * Thrown on validation failure. The outer CLI dispatcher converts to
@@ -547,6 +549,15 @@ export async function runConfigSet(args) {
             cfg.assistant.lane = lane;
             break;
         }
+        // Stage 1A — explicit, like the lane. markExplicit below keeps the table.
+        case 'assistant.skills': {
+            const skills = value.trim().toLowerCase();
+            if (skills !== 'system' && skills !== 'inline') {
+                err(`assistant.skills must be one of: ${ASSISTANT_SKILLS_VALUES.join(', ')}`);
+            }
+            cfg.assistant.skills = skills;
+            break;
+        }
         case 'assistant.style': {
             const style = parseStyle(value);
             if (!style)
@@ -800,6 +811,8 @@ export function validateValue(key, value) {
             return value === 'true' || value === 'false';
         case 'assistant.lane':
             return ASSISTANT_LANE_VALUES.includes(value.trim().toLowerCase());
+        case 'assistant.skills':
+            return ASSISTANT_SKILLS_VALUES.includes(value.trim().toLowerCase());
         case 'assistant.style':
             return parseStyle(value) !== null;
         case 'assistant.level':

package/dist/commands/config-show.js

@@ -3,6 +3,7 @@ import { loadConfig } from '../config/loader.js';
 import { paint } from '../renderer/theme.js';
 import { formatAttention } from '../renderer/notice-shape.js';
 import { getCustomerModelConfig } from '../models/server-config.js';
+import { inlineInactiveReason, inlineServed } from '../repl/inline-mode.js';
 /**
  * Dotted paths of keys that must never appear in plaintext config output.
  * SAP passwords live in the keychain and should never land in config.toml,
@@ -74,7 +75,11 @@ function printLlmMissingHints(llm) {
         console.log(`ai_hub_router_model = ${paint('dim', '<not set — skill routing uses ai_hub_model_alias>')}`);
     }
 }
-function printConfigAsToml(cfg, prefix = '') {
+/**
+ * `notes` maps a dotted key to a trailing comment (Stage 1A: a stored
+ * `assistant.skills = inline` that would not be active).
+ */
+function printConfigAsToml(cfg, prefix = '', notes = {}) {
     // Emit scalars before nested objects — otherwise a top-level scalar that
     // follows a nested table (e.g. `write_mode` declared after `ui` in the
     // config shape) would render underneath `[ui]` in TOML, which reparses as
@@ -91,7 +96,8 @@ function printConfigAsToml(cfg, prefix = '') {
             console.log(`${k} = [REDACTED]`);
         }
         else {
-            console.log(`${k} = ${formatTomlValue(v)}`);
+            const note = notes[fullKey];
+            console.log(`${k} = ${formatTomlValue(v)}` + (note ? chalk.gray(`  # ${note}`) : ''));
             // Surface an explanatory hint for advisory-only mode so users understand
             // the implication (writes proposed, never executed) without having to
             // read the docs.
@@ -104,7 +110,7 @@ function printConfigAsToml(cfg, prefix = '') {
         const fullKey = prefix ? `${prefix}.${k}` : k;
         console.log('');
         console.log(chalk.bold(`[${fullKey}]`));
-        printConfigAsToml(v, fullKey);
+        printConfigAsToml(v, fullKey, notes);
         // Mode-aware extras for the `[llm]` section — print required keys that
         // are empty as `<not set>` so a user who ran `cspeach config set llm.mode
         // ai-hub` without also setting the base URL can see what is still
@@ -165,7 +171,13 @@ export async function runConfigShow(args) {
         // Full config dump
         console.log('');
         console.log(chalk.gray('# ~/.cspeach/config.toml'));
-        printConfigAsToml(cfg);
+        // Stage 1A — say when a stored `inline` would not be active in an
+        // interactive session (the served flag is loaded by cli.ts).
+        // Read defensively: a config without an [assistant] table means the defaults.
+        const inlineNote = cfg.assistant?.skills === 'inline'
+            ? inlineInactiveReason({ skills: 'inline', lane: cfg.assistant.lane, served: inlineServed(cfg.llm?.mode) })
+            : null;
+        printConfigAsToml(cfg, '', inlineNote ? { 'assistant.skills': inlineNote } : {});
         console.log('');
         // Task 12 — one trailing line when the account admin's model is enforced
         // by the proxy (/v1/me/model-config). No snapshot ⇒ output unchanged.

package/dist/commands/export-conversation.js

@@ -20,7 +20,7 @@ import path from 'node:path';
 import { metaFromMarkdown } from '../docx/doc-meta.js';
 import { writeDocxNextTo, writeNoClobber } from '../docx/write-docx.js';
 import { normalizeAskInput } from '../tools/ask-question.js';
-import { isUserPrompt, userPromptText } from '../session/user-prompt.js';
+import { INJECTED_CONTEXT_TAGS, isUserPrompt, userPromptText } from '../session/user-prompt.js';
 import { resolveCliMarks, startsTurn } from '../session/cli-record.js';
 import { docxFileFromReplArgs, runExportDocxCommand } from './export-docx.js';
 // The usage line lives in the light export-audit module (final-review I-2); re-exported here.
@@ -30,11 +30,14 @@ const OUT_DIR = 'cspeach-out';
 function readerText(text) {
     return text.replace(/<!--[\s\S]*?-->/g, '').replace(/\n{3,}/g, '\n\n').trim();
 }
-/** Context blocks the CLI adds to a prompt; the developer never typed them. */
-const INJECTED_TAGS = ['session_context', 'project_context', 'journey', 'lane_decision', 'system_switch', 'sap_system', 'sap_connection'];
+/**
+ * Context blocks the CLI adds to a prompt (the developer never typed them) are
+ * dropped with the shared INJECTED_CONTEXT_TAGS list (session/user-prompt.ts),
+ * which carries Stage 1A's inline `<skill>` playbook blocks too.
+ */
 function typedText(text) {
     let out = text;
-    for (const tag of INJECTED_TAGS) {
+    for (const tag of INJECTED_CONTEXT_TAGS) {
         out = out.replace(new RegExp(`<${tag}(?:\\s[^>]*)?>[\\s\\S]*?</${tag}>`, 'g'), '');
     }
     out = out.replace(/<attached file="([^"]*)">[\s\S]*?<\/attached>/g, (_m, f) => `@${f}`);

package/dist/commands/finish-check-guard.js

@@ -0,0 +1,124 @@
+// cspeach-cli/src/commands/finish-check-guard.ts
+//
+// Finish-check guard (2026-10-23, inline-waiver findings §6 Option A).
+// A plan step may not be saved "validated" while that turn's LAST
+// rap_finish_check said fewer than 5 of 5 passed. The write-back
+// downgrades it to "blocked" (never refuses: a refusal would cost another
+// model turn). "validated-with-waiver" is kept only when the step's notes
+// name every failed item id.
+//
+// The guard acts only when it reads the check confidently. No check this
+// turn, an unreadable last check, a 5 of 5, or any other status → null
+// (today's behaviour).
+const TOOL_NAME = 'rap_finish_check';
+// The real handler's shape (tools/rap/finish-check.ts formatFinish):
+//   Finish check: <n> of 5 passed
+//   F<k> <title> — passed | needs work: <problems>
+const HEADER_RE = /^Finish check: (\d+) of (\d+) passed$/;
+const ITEM_RE = /^(F[1-5]) .*? — (passed|needs work:.*)$/;
+const ITEM_IDS = ['F1', 'F2', 'F3', 'F4', 'F5'];
+function resultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const b of content) {
+        if (b?.type === 'text' && typeof b.text === 'string')
+            parts.push(b.text);
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+}
+/** The text of this turn's LAST rap_finish_check tool result, or null when there is none. */
+export function lastFinishCheckText(messages, messagesStart) {
+    const checkIds = new Set();
+    let last = null;
+    for (let i = Math.max(0, messagesStart); i < messages.length; i++) {
+        const m = messages[i];
+        if (!Array.isArray(m.content))
+            continue;
+        for (const b of m.content) {
+            if (!b || typeof b !== 'object')
+                continue;
+            if (m.role === 'assistant' && b.type === 'tool_use' && b.name === TOOL_NAME && typeof b.id === 'string') {
+                checkIds.add(b.id);
+            }
+            else if (m.role === 'user' && b.type === 'tool_result' && typeof b.tool_use_id === 'string' && checkIds.has(b.tool_use_id)) {
+                // An unreadable last result still counts as the last one: it makes the guard stand down.
+                last = resultText(b.content) ?? '';
+            }
+        }
+    }
+    return last;
+}
+/** Parses a rap_finish_check result; null unless every line agrees with the handler's shape. */
+export function parseFinishCheck(text) {
+    const lines = text.split(/\r?\n/).map((l) => l.trimEnd());
+    const head = HEADER_RE.exec(lines[0] ?? '');
+    if (!head)
+        return null;
+    const passed = Number(head[1]);
+    const total = Number(head[2]);
+    if (total !== ITEM_IDS.length || passed > total)
+        return null;
+    const seen = [];
+    const failed = [];
+    for (const line of lines.slice(1)) {
+        const m = ITEM_RE.exec(line);
+        if (!m)
+            continue;
+        seen.push(m[1]);
+        if (m[2] !== 'passed')
+            failed.push(m[1]);
+    }
+    if (seen.join(',') !== ITEM_IDS.join(','))
+        return null;
+    if (failed.length !== total - passed)
+        return null;
+    return { passed, total, failed };
+}
+const namesId = (notes, id) => new RegExp(`\\b${id}\\b`).test(notes);
+/**
+ * The guard's note: one place for its wording. It goes into the step's
+ * work.notes and is shown as the run line.
+ *   <step>: finish check 3 of 5, F1, F4 failed. Saved as blocked.
+ *   <step>: finish check 3 of 5, F1, F4 failed. The notes do not waive F4. Saved as blocked.
+ */
+const GUARD_NOTE_TAIL = 'Saved as blocked.';
+const GUARD_NOTE_HEAD = 'finish check';
+const GUARD_NOTE_RE = new RegExp(`: ${GUARD_NOTE_HEAD} \\d+ of \\d+, .* ${GUARD_NOTE_TAIL.replace(/\./g, '\\.')}$`);
+export function formatFinishGuardNote(a) {
+    const waiver = a.notWaived && a.notWaived.length > 0 ? ` The notes do not waive ${a.notWaived.join(', ')}.` : '';
+    return `${a.step}: ${GUARD_NOTE_HEAD} ${a.score.passed} of ${a.score.total}, ${a.score.failed.join(', ')} failed.${waiver} ${GUARD_NOTE_TAIL}`;
+}
+/** True for a line the guard wrote itself (it never counts as a waiver). */
+export function isFinishGuardNoteLine(line) {
+    return GUARD_NOTE_RE.test(line.trim());
+}
+/** The notes without the guard's own lines: only what the model or developer wrote. */
+function notesWithoutGuardLines(notes) {
+    return notes.split(/\r?\n/).filter((l) => !isFinishGuardNoteLine(l)).join('\n');
+}
+/**
+ * The guard's ruling for the executed step: `{ status: 'blocked', note }` when
+ * the claimed status must be downgraded, otherwise null (save as written).
+ * A waiver counts from any turn's notes, but never from the guard's own lines.
+ */
+export function finishCheckGuard(args) {
+    if (args.status !== 'validated' && args.status !== 'validated-with-waiver')
+        return null;
+    const text = lastFinishCheckText(args.messages, args.messagesStart);
+    if (text === null)
+        return null;
+    const score = parseFinishCheck(text);
+    if (!score || score.failed.length === 0)
+        return null;
+    let notWaived;
+    if (args.status === 'validated-with-waiver') {
+        const notes = notesWithoutGuardLines(args.notes ?? '');
+        notWaived = score.failed.filter((id) => !namesId(notes, id));
+        if (notWaived.length === 0)
+            return null;
+    }
+    return { status: 'blocked', note: formatFinishGuardNote({ step: args.step, score, notWaived }) };
+}

package/dist/commands/plan-reground.js

@@ -99,10 +99,28 @@ export async function regroundPlan(a) {
                 stillLocked.push(o.name);
         }
         let transportClosed = false;
+        let listed = null;
+        const isListed = (t, tr) => t.list.some((x) => x.trim().toUpperCase() === tr.trim().toUpperCase());
         if (transport) {
             const t = await a.deps.openTransports();
-            transportClosed = t.complete && !t.list.some((x) => x.trim().toUpperCase() === transport.trim().toUpperCase());
+            listed = t;
+            transportClosed = t.complete && !isListed(t, transport);
         }
+        // The step transport counts as open only when SAP lists it. Any failure
+        // here keeps the old text and a "not open" verdict.
+        const step = a.stepTransport?.trim();
+        let stepOpen = false;
+        if (step) {
+            try {
+                listed = listed ?? await a.deps.openTransports();
+                stepOpen = isListed(listed, step);
+            }
+            catch (err) {
+                recordFullNotice('plan', `Transport check before a plan step failed: ${errText(err)}`);
+            }
+        }
+        const openStepTransport = !transport && stepOpen ? step : null;
+        const verdict = step ? { stepTransportOpen: stepOpen } : {};
         // An object left inactive gets the inactive instruction only, never the
         // "do not rewrite" one as well.
         const inactiveNames = new Set(inactive.map((o) => o.name));
@@ -124,7 +142,9 @@ export async function regroundPlan(a) {
                 ? (transportClosed
                     ? `- The plan's transport ${transport} is no longer open. Do not write to it. Creating a new transport needs the developer's approval (it is not on the approved list).`
                     : `- Transport ${transport} is still open: use it.`)
-                : '- No transport is recorded yet: the first writing step creates one.',
+                : openStepTransport
+                    ? `- Transport ${openStepTransport} is open: use it.`
+                    : '- No transport is recorded yet: the first writing step creates one.',
             '</sap_state>',
         ];
         if (stillLocked.length > 0) {
@@ -133,12 +153,14 @@ export async function regroundPlan(a) {
                 ok: false, reason: 'locked',
                 lines: [`${stillLocked.join(', ')} ${one ? 'is' : 'are'} still locked by another session. SAP frees ${one ? 'it' : 'them'} when that session ends or times out, usually within a few minutes.`],
                 sapStateBlock: block,
+                ...verdict,
             };
         }
         const n = inactive.length;
         const summary = `Checked SAP before continuing: ${n} object${n === 1 ? '' : 's'} left inactive`
-            + (transport ? `, transport ${transport} ${transportClosed ? 'no longer open' : 'still open'}` : '') + '.';
-        return { ok: true, summary, quiet: n === 0 && !transportClosed, sapStateBlock: block };
+            + (transport ? `, transport ${transport} ${transportClosed ? 'no longer open' : 'still open'}` : '')
+            + (openStepTransport ? `, transport ${openStepTransport} open` : '') + '.';
+        return { ok: true, summary, quiet: n === 0 && !transportClosed, sapStateBlock: block, ...verdict };
     }
     catch (err) {
         const code = unreachableOf(err);
@@ -158,6 +180,7 @@ export async function regroundPlan(a) {
                 built.length > 0 ? `- Already built by earlier steps of this plan: ${built.join(', ')}.` : '- No earlier step of this plan has built SAP objects yet.',
                 '</sap_state>',
             ],
+            ...(a.stepTransport?.trim() ? { stepTransportOpen: false } : {}),
         };
     }
 }

package/dist/commands/plan-resume.js

@@ -45,6 +45,7 @@ import { resolveAtTokenAsync, formatProjectFileList, ensureWorkspace } from '../
 import { parsePlanContent, phaseWrites } from '../projects/plan-schema.js';
 import { statusesFromItems, computeNextPhase, computeNextPhaseForRun, pendingAuditPhaseIds, renderPlanTracker, renderPlanProgressLine, buildPlanRevision, isPhaseSatisfied, isAuditResolved, planCompletionLines, findServiceBinding, phaseDisplayTitle, } from '../projects/plan-run.js';
 import { extractPlan, NO_PLAN_MANIFEST_MESSAGE } from '../projects/extract-plan.js';
+import { finishCheckGuard } from './finish-check-guard.js';
 import { recordFullNotice } from '../renderer/notice-log.js';
 import { isSapUnreachableNoted } from '../sap/reachability-state.js';
 import { saveProject } from '../projects/save.js';
@@ -66,6 +67,8 @@ import { isCredentialHandoverApproved } from '../repl/credential-handover-gate.j
 import { FIORI_DEPLOY_HANDOVER_SCOPE } from '../tools/fiori/deploy/scope.js';
 import { resolvePlanSources, renderPlanSourcesBlock } from '../projects/plan-sources.js';
 import { regroundPlan } from './plan-reground.js';
+import { getGrantTransport, isPlanGrantInForceFor } from '../approvals/plan-grant.js';
+import { projectTransport, transportForWrite } from '../register/project-transport.js';
 import { PAUSED_LINE, makeSapProbe, pauseUntilSapReachable, promptLockedChoice, resumeCommandFor } from './plan-sap-pause.js';
 /**
  * Parse and STRIP the per-run chaining-mode (`--guarded` / `--step`) and
@@ -166,6 +169,51 @@ export function buildUiPhaseContext(phases, next) {
     }
     return lines;
 }
+const sameTransport = (a, b) => !!a && !!b && a.trim().toUpperCase() === b.trim().toUpperCase();
+/**
+ * 2026-10-23 (owner-approved fix, review round 1) — the transport a create in
+ * this step would go to, by the write path's own order, so the step prompt can
+ * name it. Never the step's own work.transport ahead of that order.
+ *   - A plan grant of THIS plan is in force: its transport (writes under the
+ *     grant are held to it; a grant whose new transport is not bound yet names
+ *     none).
+ *   - Guarded mode, no grant yet: the grant offered for this step would bind
+ *     the plan's recorded transport, else the session one; if it is not
+ *     installed, writes take transportForWrite's order. Named only when the
+ *     two agree.
+ *   - Otherwise (step mode): transportForWrite for a create: the joined team
+ *     project's request, else the session transport (an explicit /transport).
+ * Resolve-mode writes (set_source, update_method, delete) never fall back to
+ * the session transport, and an object's owning lock still wins over any
+ * transport passed. Pure.
+ */
+export function resolveStepWriteTransport(i) {
+    if (i.grantInstalled)
+        return i.grantTransport?.trim() || undefined;
+    const perWrite = transportForWrite({ op: 'create', project: i.project, session: i.session }).request;
+    if (i.mode !== 'guarded')
+        return perWrite || undefined;
+    const planned = recordedPlanTransport(i.phases) ?? i.session ?? undefined;
+    return sameTransport(planned, perWrite) ? perWrite : undefined;
+}
+/**
+ * The step-prompt line naming the transport. `transport` is passed only when
+ * it is the one the write path uses AND the pre-step SAP check listed it as
+ * open. Returns [] (prompt unchanged) with no transport, for read-only steps
+ * (writes:false), design steps, and UI/CAP steps (local files; a UI deploy
+ * names its own).
+ */
+export function buildStepTransportLine(next, transport) {
+    if (!transport)
+        return [];
+    if (!phaseWrites(next))
+        return [];
+    if (next.delegateTo === 'abap-design')
+        return [];
+    if (next.layer === 'ui' || next.layer.startsWith('cap.'))
+        return [];
+    return [`Transport for this step: ${transport} (already settled: use it, do not ask the developer which transport).`];
+}
 /** Compact-example work keys for ui phases — the write-back contract
  * (review C3). Returns an OBJECT fragment because compactExample renders
  * via JSON.stringify: it is spread into the `work` object exactly like the
@@ -528,17 +576,31 @@ export async function preparePlanResume(args) {
     // what this plan built, what a dead run left inactive (a stale lock is
     // waited out, then reported), and whether the transport is still open.
     let sapStateBlock = [];
+    // 2026-10-23 — the transport this step's writes would use (write-path
+    // order). It is named in the prompt only when the re-check lists it open.
+    // A grant counts only while it is in force (this plan, not expired, approvals
+    // = plan); otherwise writes take the per-write order, and so does the line.
+    const stepWriteTransport = resolveStepWriteTransport({
+        phases: content.phases,
+        mode: effectiveMode,
+        grantInstalled: isPlanGrantInForceFor(envelope.id),
+        grantTransport: getGrantTransport(),
+        project: projectTransport(args.cwd),
+        session: getCurrentTransport(),
+    });
+    let stepTransportOpen = false;
     if (args.reground) {
         const regroundDeps = args.reground;
         const canAsk = args.interactive === true && !!args.prompt;
         const resumeCommand = resumeCommandFor({ path, mode: flags.mode, auditFlag: flags.audit });
         for (;;) {
-            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log });
+            const r = await regroundPlan({ content, statuses, deps: regroundDeps, log: args.log, ...(stepWriteTransport ? { stepTransport: stepWriteTransport } : {}) });
             if (r.ok) {
                 // An in-run hop stays quiet unless something needs attention.
                 if (!r.quiet || args.boardStyle !== 'line')
                     args.log(formatInfo(r.summary).trimEnd());
                 sapStateBlock = r.sapStateBlock;
+                stepTransportOpen = r.stepTransportOpen === true;
                 break;
             }
             if (r.reason === 'unreachable') {
@@ -562,6 +624,7 @@ export async function preparePlanResume(args) {
                     continue;
                 if (choice === 'continue') {
                     sapStateBlock = r.sapStateBlock;
+                    stepTransportOpen = r.stepTransportOpen === true;
                     break;
                 }
                 args.log(PAUSED_LINE);
@@ -631,6 +694,10 @@ export async function preparePlanResume(args) {
     // '' already ends the prior element). Spread the blank AFTER the block so
     // context keeps single-blank separation on both sides.
     const uiContext = buildUiPhaseContext(content.phases, next);
+    // Named only when it is the transport the write uses, it is listed open, and
+    // it does not contradict the plan's recorded transport in <sap_state>.
+    const recordedTr = recordedPlanTransport(content.phases);
+    const stepTransport = buildStepTransportLine(next, stepTransportOpen && (!recordedTr || sameTransport(recordedTr, stepWriteTransport)) ? stepWriteTransport : undefined);
     // 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.
@@ -671,6 +738,7 @@ export async function preparePlanResume(args) {
         'Only if the plan itself must change structurally (a phase added, removed, or re-sequenced) fall back to the full shape with "content" — CSPeach accepts both. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase.',
         '',
         ...(uiContext.length ? [...uiContext, ''] : []),
+        ...(stepTransport.length ? [...stepTransport, ''] : []),
         PLAN_RESUME_HARNESS_OVERRIDE,
     ].join('\n');
     return {
@@ -935,6 +1003,12 @@ export async function finishPlanResume(args) {
             return null;
         }
     }
+    // 2026-10-23 — finish-check guard (inline-waiver findings §6 Option A): a
+    // step claimed "validated" while this turn's LAST rap_finish_check is below
+    // 5 of 5 is saved "blocked" (a waiver only when its notes name every failed
+    // item). Downgrade, never refuse. No check this turn, a 5 of 5, an
+    // unreadable result or any other status → saved exactly as written.
+    applyFinishCheckGuard(extract, args);
     const nowIso = new Date().toISOString();
     const statuses = extract.statuses;
     const executedId = args.prepared.nextPhaseId;
@@ -1056,6 +1130,42 @@ export async function finishPlanResume(args) {
         nextTitle: next ? phaseDisplayTitle(next, extract.content.phases) : null,
     };
 }
+/**
+ * The finish-check guard's write: when finishCheckGuard rules the executed
+ * step down, set it to 'blocked' in the status map, the item list and the
+ * summary, append the note to its work.notes and log the same line.
+ */
+function applyFinishCheckGuard(extract, args) {
+    const executedId = args.prepared.nextPhaseId;
+    const executed = extract.content.phases.find((p) => p.id === executedId);
+    if (!executed)
+        return;
+    const ruling = finishCheckGuard({
+        messages: args.messages,
+        messagesStart: args.messagesStart,
+        status: extract.statuses[executedId],
+        step: phaseDisplayTitle(executed, extract.content.phases),
+        notes: executed.work?.notes,
+    });
+    if (!ruling)
+        return;
+    extract.statuses[executedId] = ruling.status;
+    for (const it of extract.items)
+        if (it.id === executedId)
+            it.status = ruling.status;
+    const prevNotes = executed.work?.notes;
+    executed.work = { ...(executed.work ?? {}), notes: prevNotes ? `${prevNotes}\n${ruling.note}` : ruling.note };
+    const phases = extract.content.phases;
+    const next = computeNextPhase(phases, extract.statuses);
+    extract.content.summary = {
+        ...extract.content.summary,
+        validated: phases.filter((p) => isPhaseSatisfied(extract.statuses[p.id], p.audit)).length,
+        blocked: phases.filter((p) => extract.statuses[p.id] === 'blocked').length,
+        next: next?.id ?? null,
+    };
+    args.log('');
+    args.log(ruling.note);
+}
 /**
  * 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

package/dist/config/loader.js

@@ -45,7 +45,8 @@ export const DEFAULT_CONFIG = {
     // (staged rollout, owner 2026-10-17; users opt in with /chat on, a later
     // release flips this); 'professional' sends no style; 'developer' sends no
     // level (§10 D13).
-    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL },
+    // Stage 1A — 'system' is today's request; 'inline' is opt-in (config set).
+    assistant: { lane: 'skills', style: DEFAULT_STYLE, level: DEFAULT_LEVEL, skills: 'system' },
     // Default `approval-gated` — preserves current UX (user approves each write).
     write_mode: 'approval-gated',
     // Default `managed` — lowest-friction entry point; uses the cspeach.dev proxy.
@@ -321,6 +322,9 @@ async function readConfig() {
             merged.assistant.lane = DEFAULT_CONFIG.assistant.lane;
         merged.assistant.style = parseStyle(merged.assistant.style) ?? DEFAULT_CONFIG.assistant.style;
         merged.assistant.level = parseLevel(merged.assistant.level) ?? DEFAULT_CONFIG.assistant.level;
+        // Stage 1A — unknown values fall back, like the lane.
+        if (merged.assistant.skills !== 'system' && merged.assistant.skills !== 'inline')
+            merged.assistant.skills = DEFAULT_CONFIG.assistant.skills;
         if (merged.ui.background !== undefined && merged.ui.background !== 'dark' && merged.ui.background !== 'light') {
             delete merged.ui.background;
         }

package/dist/cost/cost-log.js

@@ -87,6 +87,12 @@ export function buildEntry(opts) {
         entry.skill = opts.skill;
     if (opts.system_block !== undefined)
         entry.system_block = opts.system_block;
+    if (opts.system_mode !== undefined)
+        entry.system_mode = opts.system_mode;
+    if (opts.skill_appended !== undefined && opts.skill_appended.length > 0)
+        entry.skill_appended = opts.skill_appended;
+    if (opts.tools_surfaced !== undefined && opts.tools_surfaced.length > 0)
+        entry.tools_surfaced = opts.tools_surfaced;
     return entry;
 }
 /**

package/dist/cost/system-block.js

@@ -11,6 +11,12 @@
  * Kept in a module WeakMap, never in the session file (no schema change). A
  * resumed session therefore starts at 'first' again.
  */
+/**
+ * Stage 1A, Task 1A.2 (M2) — the skill part of the key on an inline call: the
+ * system block is the one conversation prompt whatever the skill header says,
+ * and no delegate is composed into it (the delegate rides in the conversation).
+ */
+export const INLINE_SYSTEM_BLOCK_SKILL = '_inline';
 export function systemBlockKey(p) {
     return `${p.skill}|${p.delegateSkill ?? ''}|${p.style}|${p.level}`;
 }

package/dist/models/server-config.js

@@ -284,7 +284,7 @@ export function managedProxyServesNewShapes() {
  * conversation prompt? True only when its served config says
  * `inline_skills: true`; false with no snapshot or an older proxy. Managed
  * snapshot only: BYOK builds its own system prompt and never needs it.
- * Dormant — nothing calls it until stage 2 (pinned by
+ * Read only by repl/inline-mode.ts `inlineServed` (Stage 1A; pinned by
  * __tests__/served-inline-skills-pin.test.ts). Pure sync read.
  */
 export function servedInlineSkills() {

package/dist/projects/save-command.js

@@ -398,7 +398,11 @@ export async function runSaveCommand(args) {
     // maybeOfferSave never does headless — so the blanket 'y' never reaches it.)
     // Inside a journey a triage is saved without the question: the journey needs the rows.
     const journey = spec.artefactType === 'clean-core-decision' ? args.journey : undefined;
-    const answer = journey ? 'y' : await askYesNo({ question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt });
+    const answer = journey ? 'y' : await askYesNo({
+        question: 'Save as project file?', confirm: args.confirm, prompt: args.prompt,
+        // F-A (live check 2026-10-26) — a plan is only built from its saved file.
+        ...(spec.artefactType === 'plan' ? { defaultYes: true } : {}),
+    });
     if (!isYes(answer)) {
         args.onNotSaved?.('declined');
         return null;

package/dist/projects/yes-no.js

@@ -1,8 +1,12 @@
 export async function askYesNo(a) {
     if (a.confirm)
-        return a.confirm(a.question, { default: 'n' });
+        return a.confirm(a.question, { default: a.defaultYes ? 'y' : 'n' });
     if (!a.prompt)
         return '';
+    if (a.defaultYes) {
+        const reply = (await a.prompt(`${a.question} [Y/n]: `)).trim().toLowerCase();
+        return reply === '' ? 'y' : reply;
+    }
     return (await a.prompt(`${a.question} [y/N]: `)).trim().toLowerCase();
 }
 /** Today's decision rule at all six sites. */

package/dist/renderer/change-card.js

@@ -14,7 +14,9 @@ const DIFF_LINES = 6;
 /** Myers diff is O(N·D) and synchronous: past this budget we show no diff
  *  at all (object + footer only), never a partial one. */
 const DIFF_TIMEOUT_MS = 200;
-const defaultDiffer = (a, b) => diffLines(a, b, { timeout: DIFF_TIMEOUT_MS });
+// LT-7: a last line that only gains a newline (because lines follow it) is
+// the same line, never a -/+ pair.
+const defaultDiffer = (a, b) => diffLines(a, b, { timeout: DIFF_TIMEOUT_MS, ignoreNewlineAtEof: true });
 // eslint-disable-next-line no-control-regex
 const ANSI = /\x1b\[[0-9;]*m/g;
 const visibleLen = (s) => s.replace(ANSI, '').length;