@cspeach/cli 1.1.27 → 1.1.28

package/dist/commands/plan-resume.js

@@ -38,18 +38,22 @@
 // that survives the session, so losing the write-back breaks the plan.
 import { readFileSync, readdirSync, statSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
+import { savedLocation } from '../projects/saved-lines.js';
 import chalk from 'chalk';
 import { readProjectFile } from '../projects/status.js';
 import { resolveAtTokenAsync, formatProjectFileList, ensureWorkspace } from '../projects/workspace.js';
 import { parsePlanContent, phaseWrites } from '../projects/plan-schema.js';
-import { statusesFromItems, computeNextPhase, renderPlanTracker, buildPlanRevision, isPhaseSatisfied, isAuditResolved, planCompletionLines, findServiceBinding, } from '../projects/plan-run.js';
-import { extractPlan } from '../projects/extract-plan.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 { recordFullNotice } from '../renderer/notice-log.js';
+import { isSapUnreachableNoted } from '../sap/reachability-state.js';
 import { saveProject } from '../projects/save.js';
 import { writePlanHandover } from '../projects/handover-md.js';
 import { acquireRunLease, releaseRunLease } from '../projects/run-lease.js';
 import { validateEnvelope } from '../projects/validate.js';
 import { collectTurnAssistantText } from '../agent/turn-assistant-text.js';
 import { getAuthorIdentity } from '../agent/loop.js';
+import { DEFAULT_PLAN_MODE } from './plan-gate.js';
 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';
@@ -58,6 +62,9 @@ import { checkLaneConsistency, checkRequiredDeploy, isDeployPhase, loadPlanLaneF
 import { askDeployCard } from './deploy-card.js';
 import { isCredentialHandoverApproved } from '../repl/credential-handover-gate.js';
 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 { PAUSED_LINE, makeSapProbe, pauseUntilSapReachable, promptLockedChoice, resumeCommandFor } from './plan-sap-pause.js';
 /**
  * Parse and STRIP the per-run chaining-mode (`--guarded` / `--step`) and
  * audit off-switch (`--audit` / `--no-audit`) flags from a plan-resume body.
@@ -102,15 +109,18 @@ export function parsePlanResumeFlags(body) {
     return { mode, audit, body: rest.join(' ') };
 }
 /**
- * A1 (defect D23) — the harness-owned continuation contract, stated to the
- * model verbatim in every resume prompt: the manifest ends the turn; the
- * model must not call dispatch_skill or ask a continuation question — the
- * CLI dispatches the next phase itself. Exported as a named constant so
- * tests pin the prompt to this exact block instead of brittle prose
- * regexes (the old contract let the model keep executing phases in-turn —
- * a 6-phase run once snowballed to a 3.24M-token context).
+ * A1 (defect D23), rewritten 2026-10-04 (continuous run) — the harness owns
+ * continuation. The manifest still ends the turn; CSPeach saves the step,
+ * summarises the conversation and runs the next step itself in the same
+ * session. The model never authors continuation.
  */
-export const PLAN_RESUME_HARNESS_OVERRIDE = 'HARNESS OVERRIDE of the skill\'s Mode 2 step 8: do NOT ask a continuation question, do NOT call dispatch_skill, and NEVER start another phase in this turn. After your manifest is persisted, the CLI itself asks the user whether to run the next phase and dispatches it with the exact saved file in a fresh bounded context. Phase end = turn end.';
+export const PLAN_RESUME_HARNESS_OVERRIDE = 'HARNESS OVERRIDE of the skill\'s Mode 2 step 8: do NOT ask a continuation question, do NOT call dispatch_skill, and never start another step in this turn. '
+    + 'When your manifest is saved, CSPeach runs the next step itself. Step end = turn end. '
+    + 'Never show the user step ids, skill names, file paths under .cspeach/, gap ids or envelope field names — use the step titles and plain words.';
+/** The first instruction line of every phase prompt. */
+export function PLAN_PHASE_INSTRUCTION(id, title) {
+    return `Execute Mode 2 of the abap-plan skill for step "${title}" (phase id "${id}") ONLY — it is the computed next eligible step. Never execute any other step in this turn; CSPeach runs the next one after this one is saved.`;
+}
 /** Harness-owned ui-phase context (Track 1). Same principle as
  * buildResumeCommand (D23): the model must never have to recall the
  * binding name, flavor, or app dir from a prior session — the envelope
@@ -297,7 +307,7 @@ export async function preparePlanResume(args) {
             args.log('Run lease taken over — resuming in this session.');
         }
     }
-    const effectiveMode = flags.mode ?? args.configMode ?? 'step';
+    const effectiveMode = flags.mode ?? args.configMode ?? DEFAULT_PLAN_MODE;
     // Audit off-switch (2026-07-06, owner): per-run flag > config default > 'on'.
     const effectiveAudit = flags.audit ?? args.configAudit ?? 'on';
     // Explicit --no-audit is a strong, deliberate signal — it is the ONLY thing
@@ -330,10 +340,15 @@ export async function preparePlanResume(args) {
             // M5 — name every waived phase, and flag a FAILED-with-findings record
             // loudly: waiving a recorded failure is a bigger call than waiving a
             // never-judged pending, and the user must see which one they made.
-            const names = unresolved.map((p) => p.audit?.state === 'failed'
-                ? `${p.id} (FAILED audit — ${p.audit.findings?.length ?? 0} finding${(p.audit.findings?.length ?? 0) === 1 ? '' : 's'} waived)`
-                : `${p.id} (${p.audit?.state ?? 'unresolved'})`);
-            args.log(formatInfo(`audits off (--no-audit): waived ${unresolved.length} unresolved audit${unresolved.length === 1 ? '' : 's'} from an earlier run — ${names.join(', ')} (reason: audits turned off).`).trimEnd());
+            // Task 13 — step titles, never phase ids.
+            const names = unresolved.map((p) => {
+                const t = phaseDisplayTitle(p, content.phases);
+                const n = p.audit?.findings?.length ?? 0;
+                return p.audit?.state === 'failed'
+                    ? `${t} (FAILED its check — ${n} finding${n === 1 ? '' : 's'} waived)`
+                    : `${t} (not checked yet)`;
+            });
+            args.log(formatInfo(`Checks are off for this run · waived ${unresolved.length} open check${unresolved.length === 1 ? '' : 's'} from an earlier run: ${names.join(', ')}`).trimEnd());
         }
     }
     // Task 6 — hand-edit detection: the newest history entry was NOT authored
@@ -355,39 +370,37 @@ export async function preparePlanResume(args) {
                 ? { ...p, audit: { ...(p.audit ?? {}), state: 'not_audited_hand_edited' } }
                 : p),
         };
-        args.log(formatAttention({ text: `Plan was last edited outside CSPeach (by ${lastHistory?.by?.name ?? 'unknown'})`, fact: 'satisfied phases without an audit show as hand-edited · file not rewritten' }).trimEnd());
+        // 1.1.28 — no "(by <name>)": history names can be the OS account name.
+        args.log(formatAttention({ text: 'Plan was last edited outside CSPeach', fact: 'satisfied phases without an audit show as hand-edited · file not rewritten' }).trimEnd());
     }
-    // Task 6 — re-audit-on-resume: an unresolved persisted audit (a crash
-    // between phase save and verdict save leaves 'pending'; an auditor outage
-    // leaves 'infra_failed') is re-run FIRST — no new phase executes this
-    // dispatch. Scan newest-last so the most recent execution is re-judged.
-    // Fix-wave (item 10a): a persisted 'failed' on a phase that still CLAIMS
-    // satisfied means the session died AT the failure menu (the verdict wrote,
-    // the resolution never did) — re-audit it and re-offer the menu instead of
-    // dead-ending in the "resolve by hand" message. A failed audit on a
-    // non-satisfied phase (forced block / user chose re-run) was already
-    // resolved and is NOT picked up.
+    // Task 6 — re-audit-on-resume. 2026-10-04 (continuous run): audits are
+    // deferred to the END of a run, so a 'pending' written by THIS session is
+    // normal mid-run state — it is left for the end-of-run batch and does not
+    // block the next step (computeNextPhaseForRun). A 'pending' from ANOTHER
+    // session (or with none recorded — a 1.1.27 file) was left by a run that
+    // died: those are checked first, all of them, in plan order, before any new
+    // step. Fix-wave (item 10a): a persisted 'failed' on a phase that still
+    // CLAIMS satisfied means the session died AT the failure menu — re-audit it
+    // and re-offer the menu. A failed audit on a non-satisfied phase (forced
+    // block / user chose re-run) was already resolved and is NOT picked up.
+    // audit-infra-continue (2026-07-09): 'infra_failed' is RESOLVED and never
+    // re-audited here.
     // Audit off-switch: under an explicit --no-audit the persisted unresolved
     // records were already waived above, so this scan finds nothing anyway; the
     // guard keeps the intent explicit. Under config-off the persisted scan STILL
     // runs (a stuck pending must resolve — config-off governs only NEW phases),
     // but the guarded HAND-EDIT re-verification (itself an audit pass) does not.
     let reauditPhaseIds = [];
+    let reauditForce = false;
     if (!auditsExplicitlyOff) {
-        for (let i = content.phases.length - 1; i >= 0; i--) {
-            const p = content.phases[i];
+        reauditPhaseIds = content.phases
+            .filter((p) => {
             const st = p.audit?.state;
-            // audit-infra-continue (2026-07-09): 'infra_failed' is NO LONGER scanned
-            // for re-audit — it is a RESOLVED state (the audit could not run; the
-            // chain already continued past it). Re-auditing it here would wall an
-            // already-continued phase on a later resume. Only a crash-left 'pending'
-            // or a died-at-menu 'failed' on a still-satisfied phase re-audits.
-            if (st === 'pending'
-                || (st === 'failed' && isPhaseSatisfied(statuses[p.id]))) {
-                reauditPhaseIds = [p.id];
-                break;
-            }
-        }
+            if (st === 'failed')
+                return isPhaseSatisfied(statuses[p.id]);
+            return st === 'pending' && p.audit?.sessionId !== args.sessionId;
+        })
+            .map((p) => p.id);
         // Guarded hand-edit re-verification (review I-2): no persisted unresolved
         // audit, but the envelope was hand-touched — re-audit EVERY satisfied phase
         // the hand edit invalidated (plan order: dependencies first), in one pass
@@ -396,28 +409,40 @@ export async function preparePlanResume(args) {
         if (reauditPhaseIds.length === 0 && handEdited && effectiveMode === 'guarded'
             && effectiveAudit === 'on') {
             reauditPhaseIds = content.phases.filter(handEditDowngraded).map((p) => p.id);
+            reauditForce = reauditPhaseIds.length > 0;
         }
     }
+    let next = reauditPhaseIds.length > 0 ? null : computeNextPhaseForRun(content.phases, statuses);
+    // No step left but this session's deferred audits remain: this IS the end of
+    // the run — check them now instead of printing "No eligible phase".
+    if (reauditPhaseIds.length === 0 && !next && !auditsExplicitlyOff) {
+        reauditPhaseIds = pendingAuditPhaseIds(content);
+    }
     const reauditPhaseId = reauditPhaseIds[0];
-    const next = reauditPhaseId ? null : computeNextPhase(content.phases, statuses);
+    if (reauditPhaseId)
+        next = null;
     args.log('');
-    args.log(renderPlanTracker({
-        title: envelope.title,
-        version: envelope.version,
-        content: trackerContent,
-        statuses,
-        currentId: reauditPhaseId ?? next?.id ?? null,
-        auditsOff: effectiveAudit === 'off',
-    }));
+    // Task 13 — an in-run hop prints one progress line; the first hop the board.
+    args.log(args.boardStyle === 'line'
+        ? renderPlanProgressLine({ content: trackerContent, statuses, currentId: reauditPhaseId ?? next?.id ?? null })
+        : renderPlanTracker({
+            title: envelope.title,
+            version: envelope.version,
+            content: trackerContent,
+            statuses,
+            currentId: reauditPhaseId ?? next?.id ?? null,
+            auditsOff: effectiveAudit === 'off',
+        }));
     args.log('');
     if (reauditPhaseId) {
         const reauditPhase = content.phases.find((p) => p.id === reauditPhaseId);
         const st = reauditPhase.audit?.state;
+        const reTitle = phaseDisplayTitle(reauditPhase, content.phases);
         args.log(st === 'failed'
-            ? `Phase ${reauditPhaseId} has a failed audit with no recorded resolution — re-running the audit, then offering re-run / waive / block.`
-            : st === 'pending'
-                ? `Phase ${reauditPhaseId} has an unresolved audit (${st}) — re-running the audit before executing anything.`
-                : `Guarded mode: re-auditing ${reauditPhaseIds.length} hand-edited phase${reauditPhaseIds.length === 1 ? '' : 's'} (${reauditPhaseIds.join(', ')}) before chaining.`);
+            ? `${reTitle} failed its independent check and no choice was recorded — checking it again, then asking what to do.`
+            : reauditForce
+                ? `The plan file was edited outside CSPeach — checking ${reauditPhaseIds.length} step${reauditPhaseIds.length === 1 ? '' : 's'} independently before continuing.`
+                : `Checking ${reauditPhaseIds.length} finished step${reauditPhaseIds.length === 1 ? '' : 's'} independently before continuing.`);
         return {
             path, envelope, statuses,
             nextPhaseId: reauditPhaseId,
@@ -429,10 +454,16 @@ export async function preparePlanResume(args) {
             auditMode: effectiveAudit,
             reauditPhaseId,
             reauditPhaseIds,
+            reauditForce,
             ...(laneRecord ? { laneRecord } : {}),
         };
     }
     if (!next) {
+        // Task 13 — titles on screen, never phase ids.
+        const titleOfId = (id) => {
+            const p = content.phases.find((q) => q.id === id);
+            return p ? phaseDisplayTitle(p, content.phases) : id;
+        };
         // C1 (D30 waiver): 'validated-with-waiver' is satisfied — a plan whose
         // last gate was explicitly waived is complete, not stuck.
         const allValidated = content.phases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit));
@@ -443,7 +474,7 @@ export async function preparePlanResume(args) {
             args.log(...planCompletionLines(content.phases));
         }
         else {
-            const blocked = content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => p.id);
+            const blocked = content.phases.filter((p) => statuses[p.id] === 'blocked').map((p) => titleOfId(p.id));
             // Task 2 review carry-over: a validated-but-audit-unresolved phase used
             // to surface as "Blocked: (none)" — name the real block reason. Rarely
             // reached since the fix-wave: pending/infra_failed AND satisfied-but-
@@ -451,12 +482,12 @@ export async function preparePlanResume(args) {
             // authored state (e.g. a user writing 'not_audited_hand_edited').
             const unresolved = content.phases
                 .filter((p) => isPhaseSatisfied(statuses[p.id]) && !isAuditResolved(p.audit))
-                .map((p) => `${p.id} (audit ${p.audit?.state ?? 'unknown'})`);
-            const unresolvedNote = unresolved.length > 0 ? ` Unresolved audits: ${unresolved.join(', ')}.` : '';
-            args.log(`No eligible phase. Blocked: ${blocked.join(', ') || '(none)'}.${unresolvedNote} Remaining phases wait on them.`);
+                .map((p) => `${titleOfId(p.id)} (check ${p.audit?.state ?? 'unknown'})`);
+            const unresolvedNote = unresolved.length > 0 ? ` Open checks: ${unresolved.join(', ')}.` : '';
+            args.log(`Nothing can run yet. Blocked: ${blocked.join(', ') || '(none)'}.${unresolvedNote} The remaining steps wait on them.`);
             args.log(unresolved.length > 0
-                ? 'Resolve the unresolved audit (waive it or set the phase status back to todo for a re-run) and resume again.'
-                : 'Unblock (fix + edit the envelope status back to todo) and resume again.');
+                ? 'Settle the open check (waive it, or mark the step to run again), then continue the plan.'
+                : 'Fix the blocked step (mark it to run again), then continue the plan.');
         }
         // Task 9 — terminal state: nothing will run this dispatch, so don't
         // leave a lease behind (a completed/deadlocked plan must be freely
@@ -484,13 +515,60 @@ export async function preparePlanResume(args) {
         });
         if (card.outcome !== 'yes') {
             args.log(card.outcome === 'blocked'
-                ? `${next.id} cannot run here: ${card.reason}. Resume later with: ${buildResumeCommand(path)}`
+                ? `${phaseDisplayTitle(next, content.phases)} cannot run here: ${card.reason}. Resume later with: ${buildResumeCommand(path)}`
                 : `Not deployed — resume later with: ${buildResumeCommand(path)}`);
             if (args.sessionId)
                 releaseRunLease(path);
             return null;
         }
     }
+    // 2026-10-04 (continuous run, spec §3.5) — re-check SAP before the step:
+    // 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 = [];
+    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 });
+            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;
+                break;
+            }
+            if (r.reason === 'unreachable') {
+                // The shared pause: spec line, Enter retries once SAP answers, stop pauses.
+                const back = await pauseUntilSapReachable({
+                    probe: makeSapProbe(regroundDeps),
+                    prompt: args.prompt ?? (async () => 'stop'),
+                    interactive: canAsk,
+                    log: args.log,
+                    resumeCommand,
+                });
+                if (back)
+                    continue;
+            }
+            else {
+                args.log('', ...r.lines);
+                // A lock that did not clear never dead-ends the plan: the user may
+                // go on, and the step meets the lock itself (its <sap_state> names it).
+                const choice = canAsk ? await promptLockedChoice(args.prompt) : 'stop';
+                if (choice === 'retry')
+                    continue;
+                if (choice === 'continue') {
+                    sapStateBlock = r.sapStateBlock;
+                    break;
+                }
+                args.log(PAUSED_LINE);
+            }
+            if (args.sessionId)
+                releaseRunLease(path);
+            return null;
+        }
+    }
     // Inline the phase's declared rule files (coarse v1: whole files).
     // Paths resolve against cwd — dogfood runs sit inside a repo carrying
     // .claude/rules/. A missing file is noted, not fatal: the skill falls
@@ -523,7 +601,7 @@ export async function preparePlanResume(args) {
     // Mode 1, item 7a); resume's `changed.work` merge never re-authors it and
     // extractPlan preserves existing phase fields.
     const compactExample = [
-        '<!-- csforge:plan-manifest',
+        '<!-- cspeach:plan-manifest',
         JSON.stringify({
             title: envelope.title,
             statuses: { ...statuses, [next.id]: '<validated | validated-with-waiver | blocked>' },
@@ -551,15 +629,21 @@ 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);
+    // 2026-10-04 (plan sources) — the spec-gap items this phase reads, in full,
+    // from the file the plan was made from (or the plan's creation snapshot).
+    // A phase must never have to hunt the folder for its gap answers.
+    const sourcesBlock = renderPlanSourcesBlock(await resolvePlanSources({ cwd: args.cwd, envelope, content, ...(laneRecord ? { laneRecord } : {}) }), next);
     const llmPrompt = [
         `Resume execution of the project plan "${envelope.title}" (envelope v${envelope.version}).`,
         '',
-        `Execute Mode 2 of the abap-plan skill for phase "${next.id}" ONLY — it is the computed next eligible phase. Never execute any other phase in this turn; the CLI itself offers and dispatches the next phase (in a fresh bounded context) after this one is persisted.`,
+        PLAN_PHASE_INSTRUCTION(next.id, phaseDisplayTitle(next, content.phases)),
         '',
         '<plan_state>',
         planState,
         '</plan_state>',
         '',
+        ...(sourcesBlock.length ? [...sourcesBlock, ''] : []),
+        ...(sapStateBlock.length ? [...sapStateBlock, ''] : []),
         '<phase_rules>',
         ...ruleBlocks,
         '</phase_rules>',
@@ -573,7 +657,7 @@ export async function preparePlanResume(args) {
         // ended. The manifest now ENDS the turn; the harness owns continuation
         // (offerNextPhaseAutoRun) and dispatches the next phase itself with
         // the exact saved path, in reset context.
-        'CRITICAL — the write-back ENDS the turn: emit ONE COMPACT <!-- csforge:plan-manifest --> block as the LAST thing in your output, then END THE TURN. Compact shape = "title" + a "statuses" entry for EVERY phase + a "changed" map carrying ONLY the phase(s) you touched this turn (normally exactly this one). Each "changed" entry holds the phase\'s COMPLETE updated "work" (generated / transport / snapshot / notes — plus, on ui phases: app.dir + service{url,path,version} (ui.build) and deployedUrl (ui.deploy) — put the compact decision register in work.notes when the phase produced decisions rather than SAP objects); it replaces that phase\'s prior work wholesale. Do NOT re-emit "content" or the full phase list — the CLI already holds the full plan, merges your "changed" entries into it, and recomputes the summary. Exact shape for this turn:',
+        'CRITICAL — the write-back ENDS the turn: emit ONE COMPACT <!-- cspeach:plan-manifest --> block as the LAST thing in your output, then END THE TURN. Compact shape = "title" + a "statuses" entry for EVERY phase + a "changed" map carrying ONLY the phase(s) you touched this turn (normally exactly this one). Each "changed" entry holds the phase\'s COMPLETE updated "work" (generated / transport / snapshot / notes — plus, on ui phases: app.dir + service{url,path,version} (ui.build) and deployedUrl (ui.deploy) — put the compact decision register in work.notes when the phase produced decisions rather than SAP objects); it replaces that phase\'s prior work wholesale. Do NOT re-emit "content" or the full phase list — CSPeach already holds the full plan, merges your "changed" entries into it, and recomputes the summary. Exact shape for this turn:',
         '',
         compactExample,
         '',
@@ -582,7 +666,7 @@ export async function preparePlanResume(args) {
         // "validated" the gate never earned (the c1.test AUnit-gap incident).
         'Status rules: "validated" ONLY when the exit gate actually held and was verified. If the gate could NOT be met but the user EXPLICITLY waived it this turn (e.g. "skip the test gate, continue anyway"), use "validated-with-waiver" and record what was waived and why in work.notes — never mark an unmet gate "validated", and never use the waiver status without an explicit user waiver. Otherwise the phase is "blocked".',
         '',
-        'Only if the plan itself must change structurally (a phase added, removed, or re-sequenced) fall back to the full shape with "content" — the CLI accepts both. The manifest block is how the result is persisted; a turn that ends without it LOSES the phase.',
+        '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, ''] : []),
         PLAN_RESUME_HARNESS_OVERRIDE,
@@ -616,6 +700,15 @@ export function recordedPlanTransport(phases) {
     }
     return found;
 }
+/**
+ * The transport an object-list approval binds and its card shows: the plan's
+ * recorded transport, else the session's current transport, else none (the
+ * card then says "a new one for this build" and only the grant's own new
+ * transport can be bound later).
+ */
+export function planBuildTransport(phases) {
+    return recordedPlanTransport(phases) ?? getCurrentTransport() ?? undefined;
+}
 /**
  * On a plan resume, adopt the envelope's recorded dedicated transport into the
  * session so the `tr <TRKORR>` status segment shows it (setCurrentTransport
@@ -673,6 +766,24 @@ export function isPlanResumeCommand(cmd) {
     const c = cmd.trim();
     return /^\/abap-plan\b/.test(c) && /(^|\s)--resume(\s|$)/.test(c);
 }
+/** The "Auto-routed: <cmd>" echo — null for a plan hop (the chain already printed "Next: <title>"). */
+export function autoRoutedNotice(cmd) {
+    return isPlanResumeCommand(cmd) ? null : `Auto-routed: ${cmd}`;
+}
+/** Task 13 — the one message for a step result that could not be saved. */
+function logNotSaved(args, why, detail) {
+    // Task 13 fix round — the raw reason (marker names, phase ids, parser text)
+    // goes to the session's log file for support, never to the screen.
+    recordFullNotice('plan', `step result not saved (${args.prepared.nextPhaseId}): ${detail}`);
+    // 2026-10-04 (F22) — SAP went unreachable during the step: the REPL's pause
+    // line ("press Enter to retry") is the one instruction on screen.
+    if (isSapUnreachableNoted())
+        return;
+    args.log('');
+    args.log(`The step's result was not saved — ${why}`);
+    args.log('The plan file is unchanged. Check what the step built in SAP (transport, active objects), then try again:');
+    args.log(`  ${buildResumeCommand(args.prepared.path)}`);
+}
 /**
  * A1 (defect D23) — the HARNESS builds the next-phase resume command from
  * the exact path finishPlanResume just saved. Single construction site:
@@ -704,19 +815,20 @@ export function resetContextForPlanResume(session) {
 export async function offerNextPhaseAutoRun(args) {
     if (!args.outcome.nextPhaseId)
         return false;
-    const delegate = args.outcome.nextDelegateTo ? ` (${args.outcome.nextDelegateTo})` : '';
+    // F8 (revised) — never a raw phase id on screen: no title, no name in the question.
+    const title = args.outcome.nextTitle;
     if (args.gate?.action === 'auto') {
-        args.log(formatInfo(`Auto-running next phase ${args.outcome.nextPhaseId}${delegate} · guarded mode: declared non-write phase, prior audit clean.`).trimEnd());
+        args.log(formatInfo(title ? `Next: ${title}` : 'Next step').trimEnd());
         args.queueDispatch(args.outcome.resumeCommand);
         return true;
     }
     const answer = await askYesNo({
-        question: `Run next phase ${args.outcome.nextPhaseId}${delegate} now in a fresh context?`,
+        question: title ? `Run the next step now: ${title}?` : 'Run the next step now?',
         confirm: args.confirm,
         prompt: args.prompt,
     });
     if (!isYes(answer)) {
-        args.log(`Exiting — resume later with: ${args.outcome.resumeCommand}`);
+        args.log(`Stopped here. To continue later, open CSPeach in this folder and choose Continue (or type ${args.outcome.resumeCommand}).`);
         return false;
     }
     args.queueDispatch(args.outcome.resumeCommand);
@@ -768,9 +880,12 @@ export function findNewestVersion(path, picked) {
 export async function finishPlanResume(args) {
     const text = args.textOverride ?? collectTurnAssistantText(args.messages, args.messagesStart);
     if (text.trim().length === 0) {
+        // 2026-10-04 (F22) — SAP unreachable: the pause line takes over.
+        if (isSapUnreachableNoted())
+            return null;
         args.log('');
-        args.log('[plan] turn produced no assistant output — plan envelope UNCHANGED.');
-        args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
+        args.log('This step produced no output — the plan file is unchanged.');
+        args.log(`To try again: ${buildResumeCommand(args.prepared.path)}`);
         return null;
     }
     let extract;
@@ -788,11 +903,9 @@ export async function finishPlanResume(args) {
         // Loud by design: the phase may have built real SAP objects, but the
         // envelope write-back failed — the user must know state and file have
         // diverged before the next resume.
-        args.log('');
-        args.log(`[plan] PHASE RESULT NOT PERSISTED — ${e instanceof Error ? e.message : String(e)}`);
-        args.log('[plan] The plan envelope is unchanged. Check what the phase actually built');
-        args.log('[plan] (transport, activated objects), update the envelope statuses by hand or');
-        args.log(`[plan] re-run: /abap-plan --resume @${basename(args.prepared.path)}`);
+        // Task 13 — the parser detail names markers and phase ids; the screen gets plain words.
+        const detail = e instanceof Error ? e.message : String(e);
+        logNotSaved(args, detail === NO_PLAN_MANIFEST_MESSAGE ? 'the step ended without writing its result' : 'its result could not be read', detail);
         return null;
     }
     // App lane routing (Task 6, Review Focus 4) — the write-back may restructure
@@ -803,13 +916,12 @@ export async function finishPlanResume(args) {
         // the rule existed keeps running unchanged (no-regression).
         const priorParsed = parsePlanContent(args.prepared.envelope.content);
         const priorMetDeploy = priorParsed.ok && checkRequiredDeploy(priorParsed.content, args.prepared.laneRecord) === null;
-        const conflict = checkLaneConsistency(extract.content, args.prepared.laneRecord)
-            ?? (priorMetDeploy ? checkRequiredDeploy(extract.content, args.prepared.laneRecord) : null);
-        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)}`);
+        // Task 13 — the lane messages name phase ids and skills; the screen gets plain words.
+        const laneConflict = checkLaneConsistency(extract.content, args.prepared.laneRecord);
+        const deployConflict = !laneConflict && priorMetDeploy
+            ? checkRequiredDeploy(extract.content, args.prepared.laneRecord) : null;
+        if (laneConflict || deployConflict) {
+            logNotSaved(args, laneConflict ? 'a step no longer fits the app type the plan was made for. Re-run /abap-plan to rebuild the plan.' : 'it dropped the deploy step this app needs', (laneConflict ?? deployConflict));
             return null;
         }
     }
@@ -822,7 +934,10 @@ export async function finishPlanResume(args) {
     // post-turn messages and the outcome's nextPhaseId describe the happy path;
     // the post-phase chain (plan-chain.ts) recomputes from the real verdict.
     const provisionalPhases = extract.content.phases.map((p) => p.id === executedId ? { ...p, audit: undefined } : p);
-    const next = computeNextPhase(provisionalPhases, statuses);
+    // 2026-10-04 (F21) — run semantics: an EARLIER step whose audit is deferred
+    // ('pending' until the end of the run) does not hold back its dependants, so
+    // the outcome names the same next step the continuous chain will pick.
+    const next = computeNextPhaseForRun(provisionalPhases, statuses);
     // Task 6 — persist the executed phase WITH audit:'pending' in the SAME
     // revision that records its result. Ordering is the crash-safety design:
     // a crash between this save and the verdict save leaves 'pending', which
@@ -848,6 +963,9 @@ export async function finishPlanResume(args) {
                 // D-B item 1 — the attempt window for re-audits (fresh-session
                 // re-audit of a multi-attempt JSONL must see only THIS attempt).
                 ...(args.attemptStartedAt ? { attemptStartedAt: args.attemptStartedAt } : {}),
+                // 2026-10-04 (continuous run) — the phase's END: bounds the window so a
+                // deferred end-of-run audit sees only this phase's rows.
+                attemptEndedAt: nowIso,
                 // A re-run after a failed audit carries the failure counter through
                 // 'pending' so the NEXT failed verdict counts as consecutive.
                 ...(carried?.state === 'failed' && carried.consecutiveFailures
@@ -860,8 +978,7 @@ export async function finishPlanResume(args) {
     // JSON round-trip simulates disk serialization for the validator.
     const check = validateEnvelope(JSON.parse(JSON.stringify(revision)));
     if (!check.ok) {
-        args.log('');
-        args.log(`[plan] PHASE RESULT NOT PERSISTED — revision failed validation: ${check.error.message}`);
+        logNotSaved(args, 'the updated plan did not pass its own checks', `revision failed validation: ${check.error.message}`);
         return null;
     }
     let outDir;
@@ -877,7 +994,8 @@ export async function finishPlanResume(args) {
     // and never blocks the run (the envelope is the source of truth).
     writePlanHandover(savedPath, args.log);
     args.log('');
-    args.log(`Plan updated: ${savedPath}`);
+    // 1.1.28 — the file name, not the full absolute path.
+    args.log(`Plan updated: ${savedLocation(savedPath, process.cwd())}`);
     // D-E — DON'T render the progress board / tally / "Next:" line here when an
     // audit is pending. Doing so used the PROVISIONAL (audit-erased) view, which
     // counted the just-run phase as done ("2/3") and printed "Next: …" as if the
@@ -891,32 +1009,35 @@ export async function finishPlanResume(args) {
     // phase (honest: the phase IS satisfied, no audit is coming).
     const auditPending = auditEnabled
         && (executedStatus === 'validated' || executedStatus === 'validated-with-waiver');
+    // Task 13 — step titles and one progress line; the post-phase chain prints
+    // "Next: <title>" itself, so nothing here names the next step.
+    const executedPhase = extract.content.phases.find((p) => p.id === executedId);
+    const executedTitle = executedPhase ? phaseDisplayTitle(executedPhase, extract.content.phases) : 'This step';
     if (auditPending) {
-        args.log(chalk.dim('Phase result recorded — audit pending…'));
+        args.log(chalk.dim(`${executedTitle} done · checked independently at the end of the run`));
     }
     else {
         // A blocked / no-audit phase claims nothing to verify, so no verdict will
-        // contradict a board here — render it (and the next-step / completion hint).
+        // contradict the progress line here — render it (and the completion hint).
         args.log('');
-        args.log(renderPlanTracker({
-            title: revision.title,
-            version: revision.version,
-            content: { ...extract.content, phases: provisionalPhases },
-            statuses,
-            currentId: null,
-            auditsOff: !auditEnabled,
-        }));
-        args.log('');
-        if (next) {
-            args.log(`Next: ${next.id} (${next.delegateTo}) — run /abap-plan --resume @${basename(savedPath)} in a fresh session.`);
-        }
-        else if (provisionalPhases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit))) {
+        args.log(renderPlanProgressLine({ content: { ...extract.content, phases: provisionalPhases }, statuses, currentId: null }));
+        if (!next && provisionalPhases.every((p) => isPhaseSatisfied(statuses[p.id], p.audit))) {
             // C2 (D24): same chain as preparePlanResume — single source in plan-run.ts.
             args.log(...planCompletionLines(provisionalPhases));
         }
-        else {
-            const blocked = provisionalPhases.filter((p) => statuses[p.id] === 'blocked').map((p) => p.id);
-            args.log(`No eligible next phase. Blocked: ${blocked.join(', ')}. Unblock, then resume again.`);
+        else if (!next) {
+            const blocked = provisionalPhases.filter((p) => statuses[p.id] === 'blocked').map((p) => phaseDisplayTitle(p, provisionalPhases));
+            // Task 13 fix round — a step with an open check (not blocked) is named
+            // the same way the prepare branch names it, never "Blocked: (none)".
+            const openChecks = provisionalPhases
+                .filter((p) => isPhaseSatisfied(statuses[p.id]) && !isAuditResolved(p.audit))
+                .map((p) => `${phaseDisplayTitle(p, provisionalPhases)} (check ${p.audit?.state ?? 'unknown'})`);
+            const parts = [
+                ...(blocked.length > 0 || openChecks.length === 0 ? [`Blocked: ${blocked.join(', ') || '(none)'}.`] : []),
+                ...(openChecks.length > 0 ? [`Open checks: ${openChecks.join(', ')}.`] : []),
+            ];
+            args.log(`Nothing can run next. ${parts.join(' ')}`);
+            args.log(`Fix it, then continue with: ${buildResumeCommand(savedPath)}`);
         }
     }
     return {
@@ -924,6 +1045,7 @@ export async function finishPlanResume(args) {
         resumeCommand: buildResumeCommand(savedPath),
         nextPhaseId: next?.id ?? null,
         nextDelegateTo: next?.delegateTo ?? null,
+        nextTitle: next ? phaseDisplayTitle(next, extract.content.phases) : null,
     };
 }
 /**
@@ -1031,6 +1153,8 @@ export async function applyAuditResult(envelopePath, phaseId, verdict, opts) {
     // against the SAME attempt, so its window must survive the verdict write.
     if (prior?.attemptStartedAt)
         audit.attemptStartedAt = prior.attemptStartedAt;
+    if (prior?.attemptEndedAt)
+        audit.attemptEndedAt = prior.attemptEndedAt;
     if (verdict.state === 'failed') {
         // Fix-wave (item 10a): a re-confirmed failure (re-audit of an already-
         // 'failed' phase after a menu-death resume) holds the counter — the