@pareto4/pp-core 1.19.0 → 1.21.0

package/pp-core/bin/lib/discovery-stories.cjs

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Discovery user-stories check (Discovery Sprint improvement plan, Batch 4).
+ *
+ * `.planning/discovery/_stories.md` is the register of user stories Session 3
+ * Step 5E mints from the step matrices: `US-nn`, the EPIC it belongs to, the
+ * requirements it realises, the story itself, its acceptance criteria and the
+ * step it was derived from. Before Batch 4 the stories lived only in Session
+ * 3's Notes Template, where no build agent read them (review F-4); the
+ * verifier now takes its UAT from this register through `for-phase`. This
+ * module checks the structure:
+ *
+ *   - the `## Stories` table exists with the template's columns;
+ *   - `US-` IDs are well-formed, unique, contiguous;
+ *   - `EPIC` is one `E-nn`;
+ *   - every story cites at least one requirement, each existing in
+ *     `_requirements.md` when it is on file and parseable;
+ *   - `Story` and `Acceptance criteria` are non-empty;
+ *   - `Acceptance criteria` is a criterion, not a pointer (`As in F-01`);
+ *   - `Source step` is `—` or a comma list of `MP-nn #<cell>`, the main process
+ *     and the step row existing in `_processes.md` when it is on file;
+ *   - every MVP-disposition requirement that a persona-actor step cites has at
+ *     least one story (the `N-`/`T-` prefixes never need one; a requirement
+ *     only `System` steps realise, or no step at all, has no user to tell it).
+ *
+ * Posture (D-43/D-53): reports at Sessions 8 and 13; hard-blocks at
+ * `/pp-discovery-to-build`. Absent artifact → exit 0.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const io = require("./io.cjs");
+const { output, error, ERROR_REASON } = io;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const table = require("./discovery-table.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const rollup = require("./discovery-rollup.cjs");
+// ─── Constants ────────────────────────────────────────────────────────────────
+const DISCOVERY_DIR = '.planning/discovery';
+const STORIES_FILE = `${DISCOVERY_DIR}/_stories.md`;
+const REQUIREMENTS_FILE = `${DISCOVERY_DIR}/_requirements.md`;
+const PROCESSES_FILE = `${DISCOVERY_DIR}/_processes.md`;
+const STORIES_SECTION = 'Stories';
+const STORIES_HEADER = Object.freeze(['ID', 'EPIC', 'Requirements', 'Story', 'Acceptance criteria', 'Source step']);
+const US_RE = /^US-(\d{2})$/;
+const EPIC_RE = /^E-\d{2}$/;
+const REQUIREMENT_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/;
+/** `MP-nn #<cell>` — the main process and the step matrix's `#` cell, copied verbatim (`01.3`, `5`). */
+const SOURCE_STEP_RE = /^(MP-\d{2}) #(\S+)$/;
+const MP_HEADING_RE = /^(MP-\d{2})\s+—\s+\S/;
+const SYSTEM_ACTOR = 'System';
+/** An acceptance-criteria cell that only points elsewhere is no criterion the verifier can run. */
+const POINTER_AC_RE = /^(as in|see|zie|idem)\b/i;
+const PENDING = '—';
+/** Requirement prefixes that need no user story: non-functional and technical rows have no actor. */
+const STORYLESS_PREFIXES = Object.freeze(['N-', 'T-']);
+const USAGE = 'Usage: pp-tools discovery stories-check';
+function readIfPresent(abs) {
+    if (!node_fs_1.default.existsSync(abs))
+        return { kind: 'absent' };
+    try {
+        return { kind: 'ok', content: node_fs_1.default.readFileSync(abs, 'utf-8') };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+function sameHeader(actual, expected) {
+    return actual.length === expected.length && actual.every((c, i) => c.trim().toLowerCase() === expected[i].toLowerCase());
+}
+function splitList(cell) {
+    return cell.split(',').map((t) => t.trim()).filter(Boolean);
+}
+/** First-column IDs of the first table under a `## <heading>` of another artifact. */
+function firstColumnOf(content, heading) {
+    const section = table.splitSections(content.split(/\r?\n/), 2).find((s) => s.heading === heading);
+    if (!section)
+        return new Set();
+    const tables = table.parseTables(section.body);
+    if (tables.length === 0)
+        return new Set();
+    return new Set(tables[0].rows.map((r) => (r.cells[0] ?? '').trim()).filter(Boolean));
+}
+/**
+ * Every step row of `_processes.md` § Steps: its key (`MP-nn #<cell>`), its
+ * actors and the requirements it cites. `null` when the section is absent —
+ * the step rule then cannot run and only the prefix exemption applies.
+ */
+function stepsOf(content) {
+    const steps = table.splitSections(content.split(/\r?\n/), 2).find((s) => s.heading === 'Steps');
+    if (!steps)
+        return null;
+    const out = [];
+    for (const sec of table.splitSections(steps.body.map((l) => l.text), 3)) {
+        const m = MP_HEADING_RE.exec(sec.heading);
+        const tbl = table.parseTables(sec.body)[0];
+        if (!m || !tbl)
+            continue;
+        for (const r of tbl.rows) {
+            out.push({ key: `${m[1]} #${(r.cells[0] ?? '').trim()}`, actors: splitList(r.cells[2] ?? ''), requirements: splitList(r.cells[7] ?? '') });
+        }
+    }
+    return out;
+}
+/**
+ * Does this MVP requirement need a user story? Step 5E derives stories from the
+ * step rows where the actor is a persona, so the check mirrors that: a
+ * requirement needs one when at least one step citing it has an actor other
+ * than `System`. Without a step matrix the prefix exemption is all there is.
+ */
+function needsStory(r, steps) {
+    if (STORYLESS_PREFIXES.includes(r.prefix))
+        return false;
+    if (steps === null)
+        return true;
+    return steps.some((s) => s.requirements.includes(r.id) && s.actors.some((a) => a !== SYSTEM_ACTOR));
+}
+// ─── Check ────────────────────────────────────────────────────────────────────
+function checkStories(content, sources) {
+    const violations = [];
+    const sections = table.splitSections(content.split(/\r?\n/), 2);
+    const section = sections.find((s) => s.heading === STORIES_SECTION);
+    if (!section) {
+        return { ok: false, stories: 0, violations: [{ artifact: STORIES_FILE, reason: 'missing_section', id: STORIES_SECTION }] };
+    }
+    const tables = table.parseTables(section.body);
+    if (tables.length === 0) {
+        return { ok: false, stories: 0, violations: [{ artifact: STORIES_FILE, reason: 'missing_section', line: section.line, id: STORIES_SECTION }] };
+    }
+    if (!sameHeader(tables[0].header, STORIES_HEADER)) {
+        return { ok: false, stories: 0, violations: [{ artifact: STORIES_FILE, reason: 'bad_table_shape', line: tables[0].line, id: STORIES_SECTION }] };
+    }
+    const knownIds = sources.requirements instanceof Array ? new Set(sources.requirements.map((r) => r.id)) : null;
+    const ids = new Set();
+    const seqs = [];
+    const storied = new Set();
+    for (const row of tables[0].rows) {
+        const [id, epic, requirements, story, acceptance, sourceStep] = row.cells.map((c) => c.trim());
+        const m = US_RE.exec(id ?? '');
+        if (!m) {
+            violations.push({ artifact: STORIES_FILE, reason: 'bad_id', line: row.line });
+        }
+        else if (ids.has(id)) {
+            violations.push({ artifact: STORIES_FILE, reason: 'duplicate_id', line: row.line, id });
+        }
+        else {
+            ids.add(id);
+            seqs.push(Number(m[1]));
+        }
+        if (!EPIC_RE.test(epic ?? ''))
+            violations.push({ artifact: STORIES_FILE, reason: 'bad_epic', line: row.line });
+        if ((story ?? '') === '')
+            violations.push({ artifact: STORIES_FILE, reason: 'empty_cell', line: row.line, id: 'Story' });
+        if ((acceptance ?? '') === '')
+            violations.push({ artifact: STORIES_FILE, reason: 'empty_cell', line: row.line, id: 'Acceptance criteria' });
+        else if (POINTER_AC_RE.test(acceptance))
+            violations.push({ artifact: STORIES_FILE, reason: 'acceptance_is_pointer', line: row.line, id });
+        const reqs = splitList(requirements ?? '');
+        if (reqs.length === 0)
+            violations.push({ artifact: STORIES_FILE, reason: 'no_requirement', line: row.line });
+        for (const r of reqs) {
+            if (!REQUIREMENT_ID_RE.test(r))
+                violations.push({ artifact: STORIES_FILE, reason: 'unknown_requirement_id', line: row.line, id: r.slice(0, 40) });
+            else if (knownIds !== null && !knownIds.has(r))
+                violations.push({ artifact: STORIES_FILE, reason: 'unknown_requirement_id', line: row.line, id: r });
+            else
+                storied.add(r);
+        }
+        const src = sourceStep ?? '';
+        if (src !== PENDING) {
+            const refs = splitList(src);
+            if (refs.length === 0)
+                violations.push({ artifact: STORIES_FILE, reason: 'bad_source_step', line: row.line });
+            for (const ref of refs) {
+                const sm = SOURCE_STEP_RE.exec(ref);
+                if (!sm)
+                    violations.push({ artifact: STORIES_FILE, reason: 'bad_source_step', line: row.line });
+                else if (sources.processes !== null && !sources.processes.has(sm[1]))
+                    violations.push({ artifact: STORIES_FILE, reason: 'unknown_process_id', line: row.line, id: sm[1] });
+                else if (sources.steps !== null && !sources.steps.some((st) => st.key === ref))
+                    violations.push({ artifact: STORIES_FILE, reason: 'unknown_process_step', line: row.line, id: ref.slice(0, 40) });
+            }
+        }
+    }
+    const max = table.boundedSequenceMax(seqs);
+    if (max !== null) {
+        const have = new Set(seqs);
+        for (let n = 1; n <= max; n += 1) {
+            if (!have.has(n))
+                violations.push({ artifact: STORIES_FILE, reason: 'sequence_gap', id: `US-${String(n).padStart(2, '0')}` });
+        }
+    }
+    if (sources.requirements instanceof Array) {
+        for (const r of sources.requirements) {
+            if (r.disposition !== rollup.DISPOSITIONS.MVP)
+                continue;
+            if (!needsStory(r, sources.steps))
+                continue;
+            if (!storied.has(r.id))
+                violations.push({ artifact: REQUIREMENTS_FILE, reason: 'mvp_requirement_without_story', id: r.id });
+        }
+    }
+    else if (sources.requirements === 'unparseable') {
+        violations.push({ artifact: REQUIREMENTS_FILE, reason: 'requirements_unparseable' });
+    }
+    return { ok: violations.length === 0, stories: ids.size, violations };
+}
+function checkProjectStories(cwd) {
+    const read = readIfPresent(node_path_1.default.join(cwd, STORIES_FILE));
+    if (read.kind === 'absent')
+        return null;
+    if (read.kind === 'unreadable')
+        return { ok: false, file: STORIES_FILE, stories: 0, violations: [{ artifact: STORIES_FILE, reason: 'artifact_unreadable' }] };
+    const extra = [];
+    const sources = { requirements: null, processes: null, steps: null };
+    const req = readIfPresent(node_path_1.default.join(cwd, REQUIREMENTS_FILE));
+    if (req.kind === 'unreadable')
+        extra.push({ artifact: REQUIREMENTS_FILE, reason: 'artifact_unreadable' });
+    if (req.kind === 'ok') {
+        const parsed = rollup.parseRequirementsArtifact(req.content);
+        sources.requirements = parsed.ok ? parsed.rows.map((r) => ({ id: r.id, prefix: r.prefix, disposition: r.disposition })) : 'unparseable';
+    }
+    const proc = readIfPresent(node_path_1.default.join(cwd, PROCESSES_FILE));
+    if (proc.kind === 'unreadable')
+        extra.push({ artifact: PROCESSES_FILE, reason: 'artifact_unreadable' });
+    if (proc.kind === 'ok') {
+        sources.processes = firstColumnOf(proc.content, 'To-be');
+        sources.steps = stepsOf(proc.content);
+    }
+    const result = checkStories(read.content, sources);
+    result.violations.push(...extra);
+    result.ok = result.violations.length === 0;
+    return { file: STORIES_FILE, ...result };
+}
+function formatViolation(v) {
+    const where = v.line !== undefined ? `:${v.line}` : '';
+    const what = v.id !== undefined ? ` (${v.id})` : '';
+    return `  - ${v.artifact}${where}: ${v.reason}${what}`;
+}
+// ─── CLI adapter ──────────────────────────────────────────────────────────────
+/** `pp-tools discovery stories-check` (dotted `query discovery.stories-check`). Absent artifact → exit 0, `present: false`. */
+function cmdDiscoveryStoriesCheck(cwd, args, raw) {
+    if (args.length > 2) {
+        error(USAGE, ERROR_REASON.USAGE);
+        return; // unreachable
+    }
+    const result = checkProjectStories(cwd);
+    if (result === null) {
+        output({ ok: true, present: false, file: STORIES_FILE }, raw);
+        return;
+    }
+    const payload = { ok: result.ok, present: true, file: result.file, stories: result.stories };
+    if (!result.ok) {
+        output({ ...payload, violations: result.violations.length }, raw);
+        error(`discovery stories-check: ${result.violations.length} violation(s):\n` + result.violations.map(formatViolation).join('\n'), ERROR_REASON.DISCOVERY_STORIES_CHECK_FAILED);
+        return; // unreachable
+    }
+    output(payload, raw);
+}
+module.exports = {
+    STORIES_FILE,
+    STORIES_HEADER,
+    STORYLESS_PREFIXES,
+    SYSTEM_ACTOR,
+    needsStory,
+    STORIES_CHECK_FAILED: ERROR_REASON.DISCOVERY_STORIES_CHECK_FAILED,
+    checkStories,
+    checkProjectStories,
+    cmdDiscoveryStoriesCheck,
+};

package/pp-core/bin/lib/discovery-sweep.cjs

@@ -40,7 +40,7 @@ const VOID_TAGS = new Set([
 const RAW_TEXT_TAGS = new Set(['script', 'style', 'noscript']);
 const ID_RE = /^[A-Za-z][A-Za-z0-9_:.-]{0,79}$/;
 const REQ_ID_RE = /^[A-Z][A-Z0-9]*-\d+$/;
-const DECISION_RE = /^D-\d{2}-\d+$/;
+const DECISION_RE = /^D-(?:\d{2}|P\d{2})-\d+$/;
 const ELEMENT_RE = /^(\*|[A-Za-z0-9_.-]+\.html?)#([A-Za-z][A-Za-z0-9_:.-]{0,79})$/;
 const ROUND_RE = /^## Sweep (\d{1,2}) — \d{4}-\d{2}-\d{2} — .+$/;
 const TABLE_HEADER = ['Element', 'Outcome', 'Reference'];

package/pp-core/bin/lib/discovery-table.cjs

@@ -90,9 +90,64 @@ function boundedSequenceMax(seqs) {
     const max = seqs.reduce((a, b) => (b > a ? b : a), 0);
     return max > MAX_SEQUENCE_SPAN ? null : max;
 }
+/**
+ * Every pipe table in a run of numbered lines (Discovery Sprint improvement
+ * plan, Batch 2). The header is the row before the first separator; data rows
+ * follow until the first line that is not a pipe row; a second separator
+ * starts the next table. Cells go through `splitTableCells`, so an escaped pipe
+ * inside a free-text cell never shifts a column.
+ */
+function parseTables(body) {
+    const tables = [];
+    for (let i = 1; i < body.length; i += 1) {
+        if (!SEPARATOR_ROW_RE.test(body[i].text) || !body[i - 1].text.trim().startsWith('|'))
+            continue;
+        const table = { line: body[i - 1].n, header: splitTableCells(body[i - 1].text), rows: [] };
+        let j = i + 1;
+        for (; j < body.length; j += 1) {
+            const text = body[j].text.trim();
+            if (!text.startsWith('|') || SEPARATOR_ROW_RE.test(text))
+                break;
+            table.rows.push({ line: body[j].n, cells: splitTableCells(text) });
+        }
+        tables.push(table);
+        i = j - 1;
+    }
+    return tables;
+}
+/**
+ * Split a file into the sections opened by headings of exactly `level` hashes
+ * (`## ` for 2). A section's body runs to the next heading of the same or a
+ * higher level; lower-level headings stay inside the body, so a caller can
+ * split a body again at the next level. Lines before the first heading belong
+ * to no section.
+ */
+function splitSections(lines, level) {
+    const open = new RegExp(`^#{${level}}\\s+(.*)$`);
+    const close = new RegExp(`^#{1,${level}}\\s`);
+    const out = [];
+    let current = null;
+    for (let i = 0; i < lines.length; i += 1) {
+        const m = open.exec(lines[i]);
+        if (m) {
+            current = { heading: m[1].trim(), line: i + 1, body: [] };
+            out.push(current);
+            continue;
+        }
+        if (close.test(lines[i])) {
+            current = null;
+            continue;
+        }
+        if (current)
+            current.body.push({ n: i + 1, text: lines[i] });
+    }
+    return out;
+}
 module.exports = {
     splitTableCells,
     SEPARATOR_ROW_RE,
     MAX_SEQUENCE_SPAN,
     boundedSequenceMax,
+    parseTables,
+    splitSections,
 };

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

@@ -203,6 +203,30 @@ const ERROR_REASON = Object.freeze({
     DISCOVERY_REBASELINE_CHECK_FAILED: 'discovery_rebaseline_check_failed',
     // discovery vault context record (PBI 75336)
     DISCOVERY_VAULT_CHECK_FAILED: 'discovery_vault_check_failed',
+    // discovery project charter (Discovery Sprint improvement plan, Batch 1)
+    DISCOVERY_CHARTER_CHECK_FAILED: 'discovery_charter_check_failed',
+    DISCOVERY_CHARTER_UNSIGNED: 'discovery_charter_unsigned',
+    // discovery data model, processes, business rules (improvement plan, Batch 2)
+    DISCOVERY_ENTITY_CHECK_FAILED: 'discovery_entity_check_failed',
+    DISCOVERY_ENTITY_CHECK_INCOMPLETE: 'discovery_entity_check_incomplete',
+    DISCOVERY_PROCESS_CHECK_FAILED: 'discovery_process_check_failed',
+    DISCOVERY_PROCESS_STEPS_UNCITED: 'discovery_process_steps_uncited',
+    DISCOVERY_RULES_CHECK_FAILED: 'discovery_rules_check_failed',
+    DISCOVERY_STORIES_CHECK_FAILED: 'discovery_stories_check_failed',
+    DISCOVERY_PHASES_CHECK_FAILED: 'discovery_phases_check_failed',
+    DISCOVERY_FOR_PHASE_FAILED: 'discovery_for_phase_failed',
+    // discovery roles, integrations, migration, deviations (improvement plan, Batch 3)
+    DISCOVERY_ROLES_CHECK_FAILED: 'discovery_roles_check_failed',
+    DISCOVERY_INTEGRATIONS_CHECK_FAILED: 'discovery_integrations_check_failed',
+    DISCOVERY_INTEGRATIONS_UNCITED: 'discovery_integrations_uncited',
+    DISCOVERY_MIGRATION_CHECK_FAILED: 'discovery_migration_check_failed',
+    DISCOVERY_MIGRATION_UNCITED: 'discovery_migration_uncited',
+    // discovery session output gate (improvement plan, Batch 5)
+    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

@@ -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 = [];
@@ -1477,4 +1512,5 @@ module.exports = {
     cmdPhaseComplete,
     cmdPhaseUatPassed,
     computeDependencyLevels,
+    countPlanTasks,
 };