@cspeach/cli 1.1.51 → 1.1.53

package/dist/approvals/plan-grant.js

@@ -103,6 +103,14 @@ export function getPlanGrant() { return active; }
 export function isPlanGrantInScope() {
     return active !== null && approvalsMode === 'plan' && inScope(active);
 }
+/**
+ * 2026-10-23 — the grant of THIS plan is in force: installed, not expired, and
+ * approvals = plan. The same test as isPlanGrantInScope without "a step of the
+ * plan is running": the step prompt is built just before its step starts.
+ */
+export function isPlanGrantInForceFor(planId) {
+    return active !== null && active.planId === planId && approvalsMode === 'plan' && isLive(active);
+}
 /**
  * The claims a grant-minted id carries for one covered change: the listed
  * type, the listed row's package, and the bound transport.

package/dist/approvals/render.js

@@ -1,6 +1,6 @@
 import { select, input } from '@inquirer/prompts';
 import chalk from 'chalk';
-import { riskReasonText, shownRiskReasons } from './risk-floor.js';
+import { riskReasonTexts, shownRiskReasons } from './risk-floor.js';
 import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines, behaviourText, behaviourLines } from './op-labels.js';
 import { uiWidth } from '../renderer/ui-width.js';
 import { shouldUseInk } from '../renderer/tty.js';
@@ -12,8 +12,9 @@ import { emitTrace } from '../renderer/trace.js';
 import { getGlyphs } from '../renderer/glyphs.js';
 import { paint } from '../renderer/theme.js';
 import { sanitizeControlChars } from '../renderer/sanitize.js';
-import { collapseImplicitActivates, looksLikeUnifiedDiff } from './visible-changes.js';
+import { planRows, looksLikeUnifiedDiff } from './visible-changes.js';
 import { withSpinnerSuspended } from '../renderer/tool-widget.js';
+import { decodeDisplayEntities, decodeDisplayBlock } from '../renderer/html-entities.js';
 // Piece 2 §1.1 — the brand accent comes from the theme role, not a legacy hex.
 const peach = (s) => paint('brand', s);
 /**
@@ -75,11 +76,21 @@ function colorizeDiff(diff) {
  * compressed. This is what fixes the "what 2 changes?" complaint when the
  * model declares modify+activate of the same object.
  */
-// collapseImplicitActivates lives in ./visible-changes.ts (Task 9: request_approval uses it too).
+// collapseImplicitActivates and planRows (LT-12) live in ./visible-changes.ts (Task 9: request_approval uses the first for its gate count).
+/**
+ * LT-12 fix round 1 — the apply choice. One shown row (a create + modify of
+ * one object, the gate still opens on the raw count) reads "Apply this
+ * change", never "Apply all 1 change".
+ */
+function applyAllLabel(visibleCount, noun) {
+    return visibleCount === 1 ? 'Apply this change' : `Apply all ${visibleCount} ${noun}`;
+}
 export async function renderPlanGate(summary, changes, transport, effectiveRisk, system) {
-    const visibleChanges = collapseImplicitActivates(changes);
+    // LT-12: one row per new object (display only; the changes behind the card are untouched).
+    const visibleChanges = planRows(changes);
     const visibleCount = visibleChanges.length;
     const noun = visibleCount === 1 ? 'change' : 'changes';
+    const applyLabel = applyAllLabel(visibleCount, noun);
     // Ink path (piece 2 §5): the plan gate is an APPROVAL confirm card in the
     // card slot. Same three values, same order, cursor on Apply all; anything
     // else (Esc, no listener) is 'cancel'. Digits pick on an APPROVAL card
@@ -102,7 +113,7 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
         ];
         const shownReasons = shownRiskReasons(effectiveRisk.raisedBy);
         if (shownReasons.length > 0) {
-            facts.push(`Risk raised to ${effectiveRisk.level}: ${shownReasons.map(riskReasonText).join('; ')}`);
+            facts.push(`Risk raised to ${effectiveRisk.level}: ${riskReasonTexts(effectiveRisk).join('; ')}`);
         }
         // Part 2b D7 — a step that names the process it runs in (a BAdI
         // implementation) carries its "Affects:" row right under it. The card's
@@ -158,7 +169,7 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
             title: system ? `Apply this plan on ${system}?` : 'Apply this plan?',
             facts,
             choices: [
-                { value: 'apply_all', label: `Apply all ${visibleCount} ${noun}` },
+                { value: 'apply_all', label: applyLabel },
                 { value: 'review', label: 'Review each change one by one' },
                 { value: 'cancel', label: 'Cancel' },
             ],
@@ -178,6 +189,7 @@ export async function renderPlanGate(summary, changes, transport, effectiveRisk,
 async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk) {
     const visibleCount = visibleChanges.length;
     const noun = visibleCount === 1 ? 'change' : 'changes';
+    const applyLabel = applyAllLabel(visibleCount, noun);
     console.log('');
     console.log(`${peach('Plan')}  ${summary}`);
     const meta = [`${visibleCount} ${noun}`, riskTag(effectiveRisk.level)];
@@ -186,7 +198,7 @@ async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk
     console.log(`      ${chalk.dim(meta.join(' · '))}`);
     const shownReasons = shownRiskReasons(effectiveRisk.raisedBy);
     if (shownReasons.length > 0) {
-        console.log(`      ${chalk.dim(`(risk raised: ${shownReasons.map(riskReasonText).join('; ')})`)}`);
+        console.log(`      ${chalk.dim(`(risk raised: ${riskReasonTexts(effectiveRisk).join('; ')})`)}`);
     }
     visibleChanges.forEach((c, i) => {
         console.log(`        ${chalk.dim(`${i + 1}.`)} ${verbLine(c)}`);
@@ -207,7 +219,7 @@ async function classicPlanGate(summary, visibleChanges, transport, effectiveRisk
         default: 'apply_all',
         theme: inquirerTheme,
         choices: [
-            { value: 'apply_all', name: `Apply all ${visibleCount} ${noun}` },
+            { value: 'apply_all', name: applyLabel },
             { value: 'review', name: 'Review each change individually' },
             { value: 'cancel', name: 'Cancel' },
         ],
@@ -283,11 +295,11 @@ export async function renderPerChangeApproval(change, effectiveRisk, transport)
     // proper diff content.
     if (change.diff) {
         if (looksLikeUnifiedDiff(change.diff)) {
-            console.log('\n' + colorizeDiff(change.diff) + '\n');
+            console.log('\n' + colorizeDiff(decodeDisplayBlock(change.diff)) + '\n');
         }
         else {
             console.log('\n' + chalk.yellow(`${getGlyphs().attention}  Model did not provide a unified diff — only a description:`));
-            console.log(chalk.dim(change.diff) + '\n');
+            console.log(chalk.dim(decodeDisplayEntities(change.diff)) + '\n');
         }
     }
     else {

package/dist/approvals/risk-floor.js

@@ -100,8 +100,13 @@ export function signatureChange(diff) {
         return false;
     let state = 'unknown';
     for (const raw of diff.split('\n')) {
-        if (raw.startsWith('+++') || raw.startsWith('---'))
+        // LT-10 (1A fix wave) — a file header starts another file (a diff can
+        // cover several includes): a declaration still open in the file before
+        // it never carries over.
+        if (raw.startsWith('+++') || raw.startsWith('---')) {
+            state = 'unknown';
             continue;
+        }
         if (raw.startsWith('@@')) {
             // Task 7 (R2) / fix round 1 — a header naming the block
             // (`@@ METHOD to_internal. @@`) hints that the hunk starts in its body.
@@ -157,6 +162,7 @@ export function effectiveRisk(declared, changes, ctx) {
     // a body-only change read "may alter a method signature" when activation
     // was the true reason.
     const applied = [];
+    let syntaxObjectWord;
     const raise = (r, label, always = false) => {
         applied.push({ r, label, always });
     };
@@ -176,6 +182,16 @@ export function effectiveRisk(declared, changes, ctx) {
             // Final review A M-4 — the reason is always shown, even when the floor
             // was already high (policy never, or declared high).
             raise('high', 'syntax_errors', true);
+            // LT-10 — "this class" / "this program" from the RECORDED keys' types
+            // for the hit names (the match is by name, so the row's type may not be
+            // what was checked). Only when they all agree on one known word.
+            const hitNames = new Set(changes.filter(hit).map((c) => c.object.trim().split(/\s+/)[0].toUpperCase()));
+            const words = new Set(ctx.syntaxErrorObjects
+                .filter((k) => hitNames.has(k.slice(k.lastIndexOf(':') + 1).toUpperCase()))
+                .map((k) => ctx.typeWord?.(k.slice(0, k.lastIndexOf(':')))));
+            const [only] = [...words];
+            if (words.size === 1 && only)
+                syntaxObjectWord = only;
         }
     }
     // Part 2b D7 — a BAdI implementation runs inside a standard SAP process:
@@ -231,7 +247,7 @@ export function effectiveRisk(declared, changes, ctx) {
         raisedBy.splice(act, 1);
         raisedBy.splice(sig, 0, 'activation');
     }
-    return { level: floor, raisedBy };
+    return syntaxObjectWord ? { level: floor, raisedBy, syntaxObjectWord } : { level: floor, raisedBy };
 }
 /** Plain words for each risk reason code — the codes stay in audit data only. */
 const RISK_REASON_TEXT = {
@@ -252,15 +268,17 @@ const RISK_REASON_TEXT = {
  * Task 7 (R2) — one sentence on every request_approval result (and once in
  * the journey fix block): the risk line is CSPeach's reading of the diff, so
  * the model relays it rather than telling the person it is wrong.
+ * LT-6 (1A fix wave): the card already shows it, so the model neither repeats
+ * nor explains it unless asked (live: "rated medium only because…").
  */
-export const RISK_NOTE = "The risk line is CSPeach's reading of the diff; relay it, and if you think it is off, say why.";
+export const RISK_NOTE = "The risk line is CSPeach's reading of the diff. Do not repeat, explain or dispute it unless the person asks.";
 /**
  * Task 7 (R2) — the risk fields of every request_approval result:
  * effective_risk and raised_by as before (older readers), plus risk { level,
  * reasons } in plain words and the note.
  */
 export function riskResultFields(eff) {
-    const reasons = eff.raisedBy.map(riskReasonText); // round 8 item 4: plain words, never codes
+    const reasons = eff.raisedBy.map((c) => reasonTextFor(c, eff)); // round 8 item 4: plain words, never codes
     return { effective_risk: eff.level, raised_by: reasons, risk: { level: eff.level, reasons: [...reasons] }, note: RISK_NOTE };
 }
 /** Round 8 item 4 — every code the floor can raise (each has plain words above). */
@@ -279,3 +297,13 @@ const NOT_A_RISK_REASON = new Set(['non_prod_override']);
 export function shownRiskReasons(raisedBy) {
     return raisedBy.filter((c) => !NOT_A_RISK_REASON.has(c));
 }
+/** LT-10 — one reason in plain words; the syntax-errors one names the kind of object when known. */
+function reasonTextFor(code, eff) {
+    if (code === 'syntax_errors' && eff.syntaxObjectWord)
+        return `the last syntax check of this ${eff.syntaxObjectWord} found errors`;
+    return riskReasonText(code);
+}
+/** LT-10 — the shown reasons of a result, in plain words (every approval surface). */
+export function riskReasonTexts(eff) {
+    return shownRiskReasons(eff.raisedBy).map((c) => reasonTextFor(c, eff));
+}

package/dist/approvals/visible-changes.js

@@ -21,6 +21,56 @@ export function collapseImplicitActivates(changes) {
         return !writeKeys.has(`${c.type}:${c.object}`);
     });
 }
+/**
+ * LT-12 (1A fix wave) — the rows a plan list shows. On top of the collapse
+ * above, a `modify` of an object that also has a `create` in the list is
+ * hidden: the create already covers its source write and activation
+ * (approvals/jwt.ts OP_COVERAGE), so "Create X" + "Change X" read as two
+ * changes for one new object. Fix round 1: only a modify with no diff of its
+ * own, or the same diff as the create, is hidden; a modify carrying other
+ * content stays, so the person sees it before "Apply all". When the create
+ * row has no behaviour (or affects) and a hidden modify has one, the row
+ * shows the modify's — a display copy, never the caller's object. Display
+ * only: the `changes[]` behind the card (approval ids, grants) and the gate
+ * count (collapseImplicitActivates) are untouched.
+ */
+export function planRows(changes) {
+    const rows = collapseImplicitActivates(changes);
+    const createOf = new Map();
+    for (const c of rows)
+        if (c.op === 'create' && !createOf.has(`${c.type}:${c.object}`))
+            createOf.set(`${c.type}:${c.object}`, c);
+    const hidden = new Set();
+    const hiddenOf = new Map();
+    for (const c of rows) {
+        if (c.op !== 'modify')
+            continue;
+        const key = `${c.type}:${c.object}`;
+        const cr = createOf.get(key);
+        if (cr && (!c.diff || c.diff === cr.diff)) {
+            hidden.add(c);
+            if (!hiddenOf.has(key))
+                hiddenOf.set(key, c);
+        }
+    }
+    const out = [];
+    for (const c of rows) {
+        if (hidden.has(c))
+            continue;
+        const m = c.op === 'create' ? hiddenOf.get(`${c.type}:${c.object}`) : undefined;
+        if (!m) {
+            out.push(c);
+            continue;
+        }
+        const row = { ...c };
+        if (row.behaviour === undefined && m.behaviour !== undefined)
+            row.behaviour = m.behaviour;
+        if (row.affects === undefined && m.affects !== undefined)
+            row.affects = m.affects;
+        out.push(row);
+    }
+    return out;
+}
 /**
  * Heuristic: a real unified diff has at least one line starting with `+`,
  * `-`, or `@@`. A summary or change description won't. Used to gate

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-chain.js

@@ -34,7 +34,7 @@ import { collectPlannedObjects, plannedObjectFacts } from '../projects/plan-obje
 import { isDeployPhase } from '../projects/plan-lane.js';
 import { askDeployCard } from './deploy-card.js';
 import { decideNextPhaseGate, getAndResetPlanPhaseSubagentDispatches, getAndResetPlanDeviation, } from './plan-gate.js';
-import { applyAuditResult, applyPhaseResolution, buildResumeCommand, offerNextPhaseAutoRun, } from './plan-resume.js';
+import { applyAuditResult, applyPhaseResolution, buildResumeCommand, offerNextPhaseAutoRun, planBuildTransport, } from './plan-resume.js';
 import { formatFailure, formatInfo } from '../renderer/notice-shape.js';
 import { clean } from '../renderer/tool-labels.js';
 import { runBatchAudit, pendingAuditPhaseIds, selectPlanCardAction, } from './plan-batch-audit.js';
@@ -251,7 +251,7 @@ async function postPhaseChain(args) {
             const built = after.content.phases.every((q) => isPhaseSatisfiedForRun(st[q.id], q.audit));
             const nextAfter = computeNextPhaseForRun(after.content.phases, st);
             if (built && !nextAfter) {
-                args.log('', ...planCompletionLines(after.content.phases));
+                args.log('', ...planCompletionLines(after.content.phases, undefined, planBuildTransport(after.content.phases)));
                 // Step 2 (C5): a rebuild whose plan this is now reads "built, not yet checked".
                 await afterPlanComplete(cur);
                 args.log(`Plan file: ${savedLocation(cur, args.cwd)}`);

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 } : {}),
         };
     }
 }