@pareto4/pp-core 1.20.0 → 1.21.1

package/pp-core/bin/lib/check-command-router.cjs

@@ -23,6 +23,8 @@ const phaseScopeMod = require("./phase-scope.cjs");
 const { resolvePhaseForRead } = phaseScopeMod;
 const decisions_cjs_1 = require("./decisions.cjs");
 const ui_safety_gate_cjs_1 = require("./ui-safety-gate.cjs");
+const plan_sizing_cjs_1 = require("./plan-sizing.cjs");
+const test_substance_cjs_1 = require("./test-substance.cjs");
 const semver_compare_cjs_1 = require("./semver-compare.cjs");
 // Quick 261003-lqi (FIX-C): the ship-time drift check resolves the platform tag
 // through the init-time owner, so it and init cannot disagree about the tag.
@@ -663,6 +665,57 @@ function cmdUiPlanGate(projectDir, args, raw) {
     }
     output(computeUiPlanGate(projectDir, phase), raw, undefined);
 }
+// ─── plan-sizing ──────────────────────────────────────────────────────────────
+/**
+ * plan-sizing: reads a phase's PLAN.md files and `context_window` and reports plans
+ * over the 6-task ceiling, plans over the per-plan budget, and serial splits that
+ * have neither a parallelism nor a budget reason (Phase 36, D-14).
+ *
+ * Invocable as: pp_run check plan-sizing <phase>
+ * Exits 0 on every analysed phase; `block` carries the verdict in the payload.
+ */
+function cmdPlanSizing(projectDir, args, raw) {
+    // args[0] = 'check', args[1] = 'plan-sizing', args[2] = phase
+    const phase = args[2] || '';
+    if (!phase) {
+        error('plan-sizing requires a phase argument: check plan-sizing <phase>', ERROR_REASON.SDK_MISSING_ARG);
+        return;
+    }
+    output((0, plan_sizing_cjs_1.computePlanSizing)(projectDir, phase), raw, undefined);
+}
+// ─── test-substance ───────────────────────────────────────────────────────────
+/**
+ * test-substance: reads a phase's PLAN.md files and reports, per task, a missing or
+ * generic <behavior>, a verify command that can pass without asserting, a MISSING
+ * test file no task creates and a scaffold that describes a vacuous test
+ * (Phase 38, D-06).
+ *
+ * Invocable as: pp_run check test-substance <phase>
+ * Exits 0 on every analysed phase; `block` carries the verdict in the payload.
+ *
+ * The scan mode, `check test-substance --scan <file...>`, counts assertions per test
+ * case in the given test files (Phase 38, D-14): the validation-time half, read by
+ * validate-phase. It exits 0 on every scanned list; a file the scanner cannot read
+ * reports `unknown` with a reason.
+ */
+function cmdTestSubstance(projectDir, args, raw) {
+    // args[0] = 'check', args[1] = 'test-substance', args[2..] = phase (flags skipped) or --scan <file...>
+    if (args[2] === '--scan') {
+        const files = args.slice(3).filter((a) => !a.startsWith('--'));
+        if (files.length === 0) {
+            error('test-substance --scan requires at least one test file: check test-substance --scan <file...>', ERROR_REASON.SDK_MISSING_ARG);
+            return;
+        }
+        output((0, test_substance_cjs_1.scanTestFiles)(projectDir, files), raw, undefined);
+        return;
+    }
+    const phase = args.slice(2).find((a) => !a.startsWith('--')) || '';
+    if (!phase) {
+        error('test-substance requires a phase argument or test files: check test-substance <phase> | check test-substance --scan <file...>', ERROR_REASON.SDK_MISSING_ARG);
+        return;
+    }
+    output((0, test_substance_cjs_1.computeTestSubstance)(projectDir, phase), raw, undefined);
+}
 // ─── ui-safety-gate ───────────────────────────────────────────────────────────
 /**
  * ui-safety-gate: post-wave check that verifies UI-changed files conform to
@@ -3105,6 +3158,14 @@ function routeCheckCommand({ args, cwd, raw }) {
         cmdUiPlanGate(cwd, args, raw);
         return;
     }
+    if (subcommand === 'plan-sizing') {
+        cmdPlanSizing(cwd, args, raw);
+        return;
+    }
+    if (subcommand === 'test-substance') {
+        cmdTestSubstance(cwd, args, raw);
+        return;
+    }
     if (subcommand === 'gap-analysis-plan-post') {
         cmdGapAnalysisPlanPost(cwd, args, raw);
         return;
@@ -3175,7 +3236,7 @@ function routeCheckCommand({ args, cwd, raw }) {
         (0, prohibition_enforcement_cjs_1.routeProhibitionEnforcement)(args, raw);
         return;
     }
-    error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, gap-analysis-plan-post, prohibition-enforcement, ship-platform-drift, tdd-review-checkpoint, ui-plan-gate, ui-safety-gate, vault-review, vault-status, vault-trace, verify-schema-drift, verify-codebase-drift', ERROR_REASON.SDK_UNKNOWN_COMMAND);
+    error('Unknown check subcommand. Available: auto-mode, decision-coverage-plan, decision-coverage-verify, gap-analysis-plan-post, plan-sizing, prohibition-enforcement, ship-platform-drift, tdd-review-checkpoint, test-substance, ui-plan-gate, ui-safety-gate, vault-review, vault-status, vault-trace, verify-schema-drift, verify-codebase-drift', ERROR_REASON.SDK_UNKNOWN_COMMAND);
 }
 module.exports = {
     routeCheckCommand,

package/pp-core/bin/lib/commands.cjs

@@ -51,6 +51,10 @@ const runtime_slash_cjs_1 = require("./runtime-slash.cjs");
 // Node built-ins and it never requires this module, so the edge adds no cycle.
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const vaultSeal = require("./vault-seal.cjs");
+// 35-02: per-phase TIMELINE.jsonl fold for cmdStats (timeline key + wall_clock column).
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const timelineMod = require("./timeline.cjs");
+const { foldRecords, buildPhaseTimeline } = timelineMod;
 // ─── Phase Status ─────────────────────────────────────────────────────────────
 /**
  * Determine phase status by checking plan/summary counts AND verification state.
@@ -1141,6 +1145,7 @@ function cmdStats(cwd, format, raw) {
     const isDirInMilestone = getMilestonePhaseFilter(cwd);
     // Phase & plan stats (reuse progress pattern)
     const phasesByNumber = new Map();
+    const timeline = {};
     let totalPlans = 0;
     let totalSummaries = 0;
     try {
@@ -1160,6 +1165,7 @@ function cmdStats(cwd, format, raw) {
                 plans: 0,
                 summaries: 0,
                 status: 'Not Started',
+                wall_clock: null,
             });
         }
     }
@@ -1186,12 +1192,31 @@ function cmdStats(cwd, format, raw) {
             const status = determinePhaseStatus(plans, summaries, node_path_1.default.join(phasesDir, dir), 'Not Started');
             const normalizedNum = normalizePhaseName(phaseNum);
             const existing = phasesByNumber.get(normalizedNum);
+            // D-12/D-15: fold this phase's TIMELINE file(s). Its own try/catch keeps one
+            // unreadable file from escaping into the outer catch and dropping later phases.
+            let wallClock = existing?.wall_clock ?? null;
+            try {
+                const timelineFiles = phaseFiles.filter(f => f.endsWith('-TIMELINE.jsonl'));
+                if (timelineFiles.length > 0) {
+                    const text = timelineFiles
+                        .map(f => node_fs_1.default.readFileSync(node_path_1.default.join(phasesDir, dir, f), 'utf-8'))
+                        .join('\n');
+                    const runs = foldRecords(text);
+                    if (runs.length > 0) {
+                        const built = buildPhaseTimeline(runs);
+                        timeline[normalizedNum] = built;
+                        wallClock = built.wall_clock;
+                    }
+                }
+            }
+            catch { /* a bad timeline file never drops phases */ }
             phasesByNumber.set(normalizedNum, {
                 number: normalizedNum,
                 name: existing?.name || phaseName,
                 plans: (existing?.plans || 0) + plans,
                 summaries: (existing?.summaries || 0) + summaries,
                 status,
+                wall_clock: wallClock,
             });
         }
     }
@@ -1240,6 +1265,7 @@ function cmdStats(cwd, format, raw) {
         milestone_version: milestone.version,
         milestone_name: milestone.name,
         phases,
+        timeline,
         phases_completed: completedPhases,
         phases_total: phases.length,
         total_plans: totalPlans,
@@ -1266,10 +1292,10 @@ function cmdStats(cwd, format, raw) {
             out += `**Requirements:** ${requirementsComplete}/${requirementsTotal} complete\n`;
         }
         out += '\n';
-        out += `| Phase | Name | Plans | Completed | Status |\n`;
-        out += `|-------|------|-------|-----------|--------|\n`;
+        out += `| Phase | Name | Plans | Completed | Status | Wall-clock |\n`;
+        out += `|-------|------|-------|-----------|--------|------------|\n`;
         for (const p of phases) {
-            out += `| ${p.number} | ${p.name} | ${p.plans} | ${p.summaries} | ${p.status} |\n`;
+            out += `| ${p.number} | ${p.name} | ${p.plans} | ${p.summaries} | ${p.status} | ${p.wall_clock ?? '—'} |\n`;
         }
         if (gitCommits > 0) {
             out += `\n**Git:** ${gitCommits} commits`;

package/pp-core/bin/lib/config.cjs

@@ -589,6 +589,11 @@ function cmdConfigSet(cwd, keyPath, value, raw) {
     if (kp === 'workflow.drift_action' && !isStringMember(VALID_DRIFT_ACTIONS, parsedValue)) {
         error(`Invalid workflow.drift_action '${val}'. Valid values: ${VALID_DRIFT_ACTIONS.join(', ')}`);
     }
+    // Phase classification (D-09, CLAS-03): `full` reproduces the pre-1.21 gate stack.
+    const VALID_CEREMONY_MODES = ['proportional', 'full'];
+    if (kp === 'workflow.ceremony' && !isStringMember(VALID_CEREMONY_MODES, parsedValue)) {
+        error(`Invalid workflow.ceremony '${val}'. Valid values: ${VALID_CEREMONY_MODES.join(', ')}`);
+    }
     if (kp === 'workflow.drift_threshold') {
         if (typeof parsedValue !== 'number' || !Number.isInteger(parsedValue) || parsedValue < 1) {
             error(`Invalid workflow.drift_threshold '${val}'. Must be a positive integer.`);

package/pp-core/bin/lib/init.cjs

@@ -32,6 +32,7 @@ const worktreeSafety = require("./worktree-safety.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- planning-workspace.cjs is an export= CommonJS module
 const planningWorkspace = require("./planning-workspace.cjs");
 const secrets_cjs_1 = require("./secrets.cjs");
+const plan_sizing_cjs_1 = require("./plan-sizing.cjs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports -- plan-scan.cjs is an export= CommonJS module
 const scanPhasePlans = require("./plan-scan.cjs");
 const state_document_cjs_1 = require("./state-document.cjs");
@@ -222,6 +223,49 @@ function resolvePhaseForInit(cwd, phase) {
     }
     return { phaseInfo, roadmapPhase };
 }
+/**
+ * Phase 37 (D-15): the recorded verdict as init keys, plus the research flag folded
+ * through it. Only plan-phase ever computes a verdict; this reads the recorded one,
+ * else full. Any throw returns the full keys and the configured research value, so a
+ * broken read never lowers ceremony (T-37-08). The fold can only turn research off when
+ * config has it on, the verdict says there is no codebase to match and nothing forced
+ * the researcher; it never turns a config-off gate on (T-37-10).
+ */
+function ceremonyInitKeys(cwd, phase, researchConfigured) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const loadCeremony = () => require('./ceremony.cjs');
+    try {
+        const { effectiveVerdict, resolveGateConfig, deriveCeremonyKeys } = loadCeremony();
+        const { verdict } = effectiveVerdict(cwd, phase);
+        const gateConfig = resolveGateConfig(cwd);
+        const keys = deriveCeremonyKeys(verdict, gateConfig.code_review_depth);
+        const keepResearch = verdict.mode === 'full' ||
+            verdict.answers.codebase_to_match.value === true ||
+            verdict.gates['research']?.decision === 'run';
+        return {
+            keys,
+            research_enabled: researchConfigured === undefined ? researchConfigured : Boolean(researchConfigured) && keepResearch,
+        };
+    }
+    catch {
+        let depth = 'standard';
+        try {
+            depth = loadCeremony().resolveGateConfig(cwd).code_review_depth;
+        }
+        catch { /* keep standard */ }
+        return {
+            keys: {
+                ceremony_tier: 'heavy',
+                ceremony_mode: 'full',
+                plan_check_rounds: 3,
+                plan_check_mode: 'standard',
+                verifier_depth: 'full',
+                code_review_depth: depth === 'quick' || depth === 'deep' ? depth : 'standard',
+            },
+            research_enabled: researchConfigured,
+        };
+    }
+}
 function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
     if (!phase) {
         error('phase required for init execute-phase');
@@ -235,6 +279,7 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
         : null;
     const phase_req_ids = reqExtracted && reqExtracted !== 'TBD' ? reqExtracted : null;
     const wf = (config.workflow ?? {});
+    const ceremony = ceremonyInitKeys(cwd, phase, undefined);
     const result = {
         executor_model: resolveModelInternal(cwd, 'pp-executor'),
         verifier_model: resolveModelInternal(cwd, 'pp-verifier'),
@@ -247,6 +292,7 @@ function cmdInitExecutePhase(cwd, phase, raw, options = {}) {
         phase_branch_template: config.phase_branch_template,
         milestone_branch_template: config.milestone_branch_template,
         verifier_enabled: config.verifier,
+        ...ceremony.keys,
         phase_found: !!phaseInfo,
         phase_dir: phaseInfo?.['directory'] || null,
         phase_number: phaseInfo?.['phase_number'] || null,
@@ -331,13 +377,16 @@ function cmdInitPlanPhase(cwd, phase, raw, options = {}) {
     assertValidGranularityOverride(granularityOverride, error);
     const granularity = resolveGranularityInternal(cwd, 'planning', granularityOverride || undefined);
     const wf = (config.workflow ?? {});
+    const ceremony = ceremonyInitKeys(cwd, phase, wf['research']);
     const result = {
         researcher_model: resolveModelInternal(cwd, 'pp-phase-researcher'),
         planner_model: resolveModelInternal(cwd, 'pp-planner'),
         checker_model: resolveModelInternal(cwd, 'pp-plan-checker'),
         tdd_mode: options['tdd'] || Boolean(wf['tdd_mode']) || false,
         granularity,
-        research_enabled: wf['research'],
+        ...(0, plan_sizing_cjs_1.planBudget)(config.context_window),
+        ...ceremony.keys,
+        research_enabled: ceremony.research_enabled,
         plan_checker_enabled: config.plan_checker,
         nyquist_validation_enabled: wf['nyquist_validation'],
         commit_docs: config.commit_docs,

package/pp-core/bin/lib/io.cjs

@@ -225,6 +225,8 @@ const ERROR_REASON = Object.freeze({
     DISCOVERY_SESSION_CHECK_FAILED: 'discovery_session_check_failed',
     DISCOVERY_DEVIATIONS_CHECK_FAILED: 'discovery_deviations_check_failed',
     DISCOVERY_DEVIATIONS_UNAPPROVED: 'discovery_deviations_unapproved',
+    // timeline (Phase 35: end with no matching open run)
+    TIMELINE_NO_OPEN_RUN: 'timeline_no_open_run',
     // generic
     USAGE: 'usage',
     UNKNOWN: 'unknown',

package/pp-core/bin/lib/loop-resolver.cjs

@@ -40,7 +40,7 @@ const { resolveCapabilityRuntimeState, SEAL_FIELD, sealRenderVerdict, resolveInj
 // ─── Capability-activation engine (single owner for config-key precedence) ────
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const capabilityActivationModule = require("./capability-activation.cjs");
-const { _getNestedConfigValue, _readRawConfigKey, _resolveActivationValue, resolveConfigKey } = capabilityActivationModule;
+const { _getNestedConfigValue, _readRawConfigKey, _resolveActivationValue, resolveConfigKey, evaluateWhen } = capabilityActivationModule;
 // ─── Canonical points (derived from LOOP_HOST_CONTRACT — authoritative 12) ───
 // FIX 2: Derive the authoritative canonical set from LOOP_HOST_CONTRACT so it
 // cannot drift from the host contract. CANONICAL_POINTS_FALLBACK is kept as an
@@ -99,11 +99,14 @@ function _getCanonicalPoints(_registry) {
  * Ordering: steps first, then contributions, then gates. Within each array,
  * the materialized registry order is preserved.
  *
- * Activation: a hook with no `when` is always active. With `when` (dotted key),
- * resolved against `config`; active iff truthy. Inactive hooks are filtered out.
+ * Activation: a hook with no `when` is always active. With `when` (a dotted key,
+ * or dotted keys joined by `&&`), resolved against `config` by evaluateWhen in
+ * capability-activation; active iff every conjunct holds. A `ceremony.<gate>`
+ * conjunct reads the phase verdict through the `ceremony` thunk and is true
+ * without one. Inactive hooks are filtered out.
  */
 function resolveLoopHooks(input) {
-    const { point, registry, config, cwd, capabilityStatesById, recordedArtifacts, platformBindingsPresent, } = input;
+    const { point, registry, config, cwd, capabilityStatesById, recordedArtifacts, platformBindingsPresent, ceremony, } = input;
     // Validate point
     const canonicalPoints = _getCanonicalPoints(registry);
     if (!canonicalPoints.includes(point)) {
@@ -124,14 +127,10 @@ function resolveLoopHooks(input) {
     const activeHooks = [];
     // Helper: check activation using single-key precedence resolver (FIX 1 + FIX 3)
     function isActive(hook) {
-        const when = hook['when'];
-        // No `when` → unconditional hook, always active
-        if (when === undefined || when === null)
-            return true;
-        // FIX 3: `when` present but not a non-empty string → malformed registry data → INACTIVE
-        if (typeof when !== 'string' || when.length === 0)
-            return false;
-        return _resolveActivationValue(when, config, cwd, registry);
+        // One evaluator owns the `when` rules (no `when` -> active; malformed -> inactive;
+        // `&&` conjuncts; `ceremony.<gate>` through the injected thunk), shared with
+        // capability-state so the two cannot drift (Phase 37 D-14).
+        return evaluateWhen(hook['when'], { config, cwd, registry, ceremony });
     }
     function isCapabilityActive(capId) {
         if (!capabilityStatesById)
@@ -487,6 +486,11 @@ function renderLoopHooks(resolved) {
  * seal gate render (Phase 16 D-19). `--active-cap <cap>` also requires the
  * capability's own state to be active (D-27).
  *
+ * options.phase + options.resolveCeremonyGate: an injected
+ * `(phase) => (gate) => boolean`; with a non-empty `--phase` a `ceremony.<gate>`
+ * conjunct of a hook's `when` answers from that phase's recorded verdict. Without
+ * both, or under `--active-cap`, every such conjunct is true (Phase 37 D-14).
+ *
  * options.resolvePlatformBindingsPresent: an injected `() => boolean` (pp-tools
  * builds it on the vault leaf's hasPlatformBindings); only literal `false`
  * drops a `requiresPlatformBindings` capability's hooks (QD-13). `--into` and
@@ -544,6 +548,15 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
     // (pp-tools passes one built on the vault leaf's hasPlatformBindings).
     const resolvePlatformBindingsPresent = options['resolvePlatformBindingsPresent'];
     const platformBindingsPresent = () => resolveInjectedPlatformBindingsPresent(resolvePlatformBindingsPresent);
+    // Phase 37 D-14: the ceremony verdict arrives the same way. Only a non-empty
+    // `--phase` plus an injected resolver builds the thunk (once, so the verdict
+    // is read once per run); anything else passes none and every `ceremony.*`
+    // conjunct stays true. `--active-cap` reads the unfiltered resolution.
+    const ceremonyPhase = typeof options['phase'] === 'string' ? options['phase'] : '';
+    const resolveCeremonyGate = options['resolveCeremonyGate'];
+    const ceremonyThunk = activeCapId === undefined && ceremonyPhase.length > 0 && typeof resolveCeremonyGate === 'function'
+        ? resolveCeremonyGate(ceremonyPhase)
+        : undefined;
     let resolved;
     try {
         // --active-cap reads the UNFILTERED resolution (16-16 D-81, see above):
@@ -551,6 +564,7 @@ function cmdLoopRenderHooks(cwd, point, raw, options = {}) {
         resolved = resolveLoopHooks({
             point, registry, config, cwd, capabilityStatesById, recordedArtifacts,
             ...(activeCapId === undefined ? { platformBindingsPresent } : {}),
+            ...(ceremonyThunk !== undefined ? { ceremony: ceremonyThunk } : {}),
         });
     }
     catch (err) {

package/pp-core/bin/lib/phase.cjs

@@ -58,7 +58,7 @@ const uatPredicate = require("./uat-predicate.cjs");
 const { evaluateUatPassed } = uatPredicate;
 const { planningDir, withPlanningLock, milestonePathsFor } = planningWorkspace;
 const { extractFrontmatter } = frontmatterMod;
-const { readModifyWriteStateMd, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, syncStateFrontmatter, withStateLock, updatePerformanceMetricsSection, } = stateMod;
+const { readModifyWriteStateMd, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, syncStateFrontmatter, stripFrontmatter, withStateLock, updatePerformanceMetricsSection, } = stateMod;
 // #2893 — strict canonical filter: `{padded_phase}-{NN}-PLAN.md` or `PLAN.md`.
 const isCanonicalPlanFile = (f) => f.endsWith('-PLAN.md') || f === 'PLAN.md';
 // Any .md file with PLAN anywhere in the basename — diagnostic net
@@ -347,6 +347,43 @@ function extractObjective(content) {
     const m = content.match(/<objective>\s*\n?\s*(.+)/);
     return m ? m[1].trim() : null;
 }
+// Tasks in a PLAN.md body: `<task>` elements (case-insensitive; the `<tasks>` wrapper
+// does not match), else `## Task N` headings for markdown-format plans. A task counts
+// only where it really is one: the opening tag (or heading) starts a line and the tag
+// has a closing `</task>`, so a `<task>` mentioned in prose or inline code is not a
+// task. Shared with `check plan-sizing`, where the count feeds `over_ceiling`.
+//
+// One pass (36-W-1b): the earlier single regex `^[ \t]*<task(?=[\s>])[^>]*>[\s\S]*?</task>`
+// rescanned to the end of the file for every unclosed open line, which is quadratic. Here
+// the open tag is found, its `>` is the first one after it (what `[^>]*>` always ended
+// at), and the close is searched from there (what the lazy `[\s\S]*?` ended at). When
+// either search fails the loop stops: any later line-start open tag begins after this
+// one, so its first `>` and its close search start no earlier and fail too. After a
+// match the open search resumes where the old global match resumed, at the end of the
+// close tag. The content is not lowercased: `toLowerCase` maps U+212A to `k` and
+// changes the length of U+0130, which the regex `i` flag (non-unicode) does not do.
+function countPlanTasks(content) {
+    const open = /^[ \t]*<task(?=[\s>])/gim;
+    const close = /<\/task>/gi;
+    let xmlTasks = 0;
+    for (;;) {
+        const found = open.exec(content);
+        if (found === null)
+            break;
+        const gt = content.indexOf('>', open.lastIndex);
+        if (gt < 0)
+            break;
+        close.lastIndex = gt + 1;
+        const closed = close.exec(content);
+        if (closed === null)
+            break;
+        xmlTasks++;
+        open.lastIndex = close.lastIndex;
+    }
+    if (xmlTasks > 0)
+        return xmlTasks;
+    return (content.match(/^[ \t]*#{2,}\s*Task\s*\d+/gim) || []).length;
+}
 // O(V + E). Assigns each in-phase plan its longest-path topological level over the
 // in-phase dependsOn DAG (Kahn's algorithm). Returns { level: Map<id,number>, visited: number }.
 // visited < rawPlans.length signals a dependency cycle.
@@ -444,9 +481,7 @@ function cmdPhasePlanIndex(cwd, phase, raw) {
         const planPath = node_path_1.default.join(phaseDir, planFile);
         const content = node_fs_1.default.readFileSync(planPath, 'utf-8');
         const fm = extractFrontmatter(content);
-        const xmlTasks = content.match(/<task[\s>]/gi) || [];
-        const mdTasks = content.match(/##\s*Task\s*\d+/gi) || [];
-        const taskCount = xmlTasks.length || mdTasks.length;
+        const taskCount = countPlanTasks(content);
         const parsedWave = parseInt(fm['wave'], 10);
         const declaredWave = Number.isNaN(parsedWave) ? null : parsedWave;
         let dependsOn = [];
@@ -1320,7 +1355,13 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
             }
             if (node_fs_1.default.existsSync(statePath)) {
                 const originalStateContent = (0, shell_command_projection_cjs_1.platformReadSync)(statePath) || '';
-                let stateContent = originalStateContent;
+                // #1257 class: the body-field patterns are case-insensitive and line-anchored, so
+                // run over the whole file they hit the YAML keys first (`status:`, `progress:`)
+                // and the body Status line never moved. Edit the body only; syncStateFrontmatter
+                // below re-derives the frontmatter from it.
+                const strippedBody = stripFrontmatter(originalStateContent);
+                let frontmatterPrefix = originalStateContent.slice(0, originalStateContent.length - strippedBody.length);
+                let stateContent = strippedBody;
                 const phaseValue = nextPhaseNum || phaseNum;
                 const nextPhaseDisplayName = phaseDisplayNameFromRoadmap(roadmapContent, nextPhaseNum) ??
                     phaseDisplayNameFromSlug(nextPhaseName);
@@ -1385,7 +1426,7 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                         const newPercent = (0, phase_lifecycle_cjs_1.clampPercent)(newCompleted, totalPhases);
                         stateContent =
                             stateReplaceField(stateContent, 'Progress', `${newPercent}%`) || stateContent;
-                        stateContent = stateContent.replace(/(percent:\s*)\d+/, `$1${newPercent}`);
+                        frontmatterPrefix = frontmatterPrefix.replace(/(percent:\s*)\d+/, `$1${newPercent}`);
                     }
                 }
                 stateContent = updatePerformanceMetricsSection(stateContent, cwd, phaseNum, planCount, summaryCount);
@@ -1395,14 +1436,14 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                 // one still on disk.
                 // D-10: this transaction sets Last activity itself; that explicit date flows.
                 const activityFieldSet = (0, state_document_cjs_1.extractPositionalField)(stateContent, 'Last Activity', 'Last activity') !==
-                    (0, state_document_cjs_1.extractPositionalField)(originalStateContent, 'Last Activity', 'Last activity');
+                    (0, state_document_cjs_1.extractPositionalField)(strippedBody, 'Last Activity', 'Last activity');
                 // 261007-rly D-11: phase complete opts OUT of the stopped_at hold and keeps
                 // re-deriving the key from the Session line, as it did before the hold moved
                 // into syncStateFrontmatter: bug #3517's pin (tests/phase.test.cjs) needs a
                 // newer Session line to replace a stale stored value here, the opposite of
                 // the operator-note shape the hold protects. Filed, not decided here:
                 // todos/pending/phase-complete-rederives-stopped-at-from-the-session-line.md.
-                stateContent = syncStateFrontmatter(stateContent, cwd, roadmapContent, activityFieldSet, true);
+                stateContent = syncStateFrontmatter(frontmatterPrefix + stateContent, cwd, roadmapContent, activityFieldSet, true);
                 stateFrontmatterUpdated = (0, state_document_cjs_1.diffFrontmatterFields)(extractFrontmatter(originalStateContent), extractFrontmatter(stateContent));
                 writes.push({ filePath: statePath, before: originalStateContent, after: stateContent });
             }
@@ -1477,4 +1518,5 @@ module.exports = {
     cmdPhaseComplete,
     cmdPhaseUatPassed,
     computeDependencyLevels,
+    countPlanTasks,
 };