@open-agent-toolkit/cli 0.3.18 → 0.3.20

package/dist/commands/project/validate-plan/frontmatter.d.ts

@@ -0,0 +1,12 @@
+export type FrontmatterResult = {
+    kind: 'ok';
+    data: Record<string, unknown>;
+} | {
+    kind: 'no-frontmatter';
+    data: Record<string, unknown>;
+} | {
+    kind: 'invalid';
+    message: string;
+};
+export declare function parseFrontmatterFromContent(content: string): FrontmatterResult;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/commands/project/validate-plan/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/frontmatter.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,GACd,iBAAiB,CAyBnB"}

package/dist/commands/project/validate-plan/frontmatter.js

@@ -0,0 +1,27 @@
+import YAML from 'yaml';
+const FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/;
+export function parseFrontmatterFromContent(content) {
+    const match = content.match(FRONTMATTER_PATTERN);
+    if (!match?.[1]) {
+        return { kind: 'no-frontmatter', data: {} };
+    }
+    try {
+        const parsed = YAML.parse(match[1]);
+        if (parsed !== null &&
+            typeof parsed === 'object' &&
+            !Array.isArray(parsed)) {
+            return { kind: 'ok', data: parsed };
+        }
+        return {
+            kind: 'invalid',
+            message: 'Frontmatter did not parse as an object',
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            kind: 'invalid',
+            message: `Malformed YAML in frontmatter: ${message}`,
+        };
+    }
+}

package/dist/commands/project/validate-plan/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,UAAU,+BAA+B;IACvC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;CACjE;AAMD,wBAAgB,gCAAgC,CAC9C,SAAS,GAAE,OAAO,CAAC,+BAA+B,CAAM,GACvD,OAAO,CAsGT"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,UAAU,+BAA+B;IACvC,mBAAmB,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,cAAc,CAAC;CACjE;AAMD,wBAAgB,gCAAgC,CAC9C,SAAS,GAAE,OAAO,CAAC,+BAA+B,CAAM,GACvD,OAAO,CAgJT"}

package/dist/commands/project/validate-plan/index.js

@@ -1,9 +1,16 @@
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { buildCommandContext, } from '../../../app/command-context.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
+import { WORKFLOW_MODES, } from '@open-agent-toolkit/control-plane';
 import { Command } from 'commander';
-import { extractPhaseIdsFromPlan, parseFrontmatterFromContent, validateLitePlan, validateParallelGroups, } from './validate-plan.js';
+import { extractPhaseIds, parseFrontmatterFromContent, resolvePlanProfile, validateParallelGroups, validatePlanForProfile, } from './validate-plan.js';
+function toWorkflowMode(value) {
+    return typeof value === 'string' &&
+        WORKFLOW_MODES.includes(value)
+        ? value
+        : null;
+}
 const DEFAULT_DEPENDENCIES = {
     buildCommandContext,
 };
@@ -15,7 +22,8 @@ export function createProjectValidatePlanCommand(overrides = {}) {
         .option('--project-path <path>', 'project directory containing plan.md', process.cwd())
         .action((options, command) => {
         const context = dependencies.buildCommandContext(readGlobalOptions(command));
-        const planPath = join(options.projectPath, 'plan.md');
+        const projectPath = resolve(context.cwd, options.projectPath);
+        const planPath = join(projectPath, 'plan.md');
         let content;
         try {
             content = readFileSync(planPath, 'utf-8');
@@ -46,27 +54,59 @@ export function createProjectValidatePlanCommand(overrides = {}) {
             return;
         }
         const groups = frontmatterResult.data['oat_plan_parallel_groups'];
-        const phaseIds = extractPhaseIdsFromPlan(content);
-        let workflowMode = null;
+        let stateFrontmatter = null;
         try {
-            const stateContent = readFileSync(join(options.projectPath, 'state.md'), 'utf-8');
-            const stateFrontmatter = parseFrontmatterFromContent(stateContent);
-            const mode = stateFrontmatter.kind === 'invalid'
-                ? null
-                : stateFrontmatter.data['oat_workflow_mode'];
-            workflowMode = typeof mode === 'string' ? mode : null;
+            const stateContent = readFileSync(join(projectPath, 'state.md'), 'utf-8');
+            const parsedState = parseFrontmatterFromContent(stateContent);
+            stateFrontmatter =
+                parsedState.kind === 'invalid' ? null : parsedState.data;
         }
         catch {
-            workflowMode = null;
+            stateFrontmatter = null;
         }
-        const liteResult = validateLitePlan(content, workflowMode);
-        if (!liteResult.ok) {
+        const workflowMode = toWorkflowMode(stateFrontmatter?.['oat_workflow_mode']);
+        const profile = resolvePlanProfile(workflowMode);
+        const phaseIds = extractPhaseIds(content, profile);
+        let implementationContent = null;
+        if (profile === 'goal') {
+            try {
+                implementationContent = readFileSync(join(projectPath, 'implementation.md'), 'utf-8');
+            }
+            catch {
+                implementationContent = null;
+            }
+        }
+        const issues = validatePlanForProfile(content, {
+            profile,
+            workflowMode,
+            stateFrontmatter,
+            implementationContent,
+        });
+        const profileErrors = issues
+            .filter((issue) => issue.severity === 'error')
+            .map((issue) => issue.message);
+        const warnings = issues
+            .filter((issue) => issue.severity === 'warning')
+            .map((issue) => issue.message);
+        const warningPayload = warnings.length > 0 ? { warnings } : {};
+        if (!context.json) {
+            for (const warning of warnings) {
+                context.logger.warn(warning);
+            }
+        }
+        if (profileErrors.length > 0) {
             if (context.json) {
-                context.logger.json({ valid: false, errors: [liteResult.message] });
+                context.logger.json({
+                    valid: false,
+                    errors: profileErrors,
+                    ...warningPayload,
+                });
             }
             else {
                 context.logger.error('Plan validation failed:');
-                context.logger.error(`  - ${liteResult.message}`);
+                for (const err of profileErrors) {
+                    context.logger.error(`  - ${err}`);
+                }
             }
             process.exitCode = 1;
             return;
@@ -74,7 +114,7 @@ export function createProjectValidatePlanCommand(overrides = {}) {
         const result = validateParallelGroups(groups, phaseIds);
         if (result.valid) {
             if (context.json) {
-                context.logger.json({ valid: true });
+                context.logger.json({ valid: true, ...warningPayload });
             }
             else {
                 context.logger.success('Plan validation passed.');
@@ -83,7 +123,11 @@ export function createProjectValidatePlanCommand(overrides = {}) {
             return;
         }
         if (context.json) {
-            context.logger.json({ valid: false, errors: result.errors });
+            context.logger.json({
+                valid: false,
+                errors: result.errors,
+                ...warningPayload,
+            });
         }
         else {
             context.logger.error('Plan validation failed:');

package/dist/commands/project/validate-plan/profiles.d.ts

@@ -0,0 +1,69 @@
+import { type MilestoneMembershipErrorCode, type WorkflowMode } from '@open-agent-toolkit/control-plane';
+/**
+ * Plan validation profiles. Each workflow mode validates `plan.md` against
+ * one profile:
+ *
+ * - `task`: spec-driven, quick and import plans. Phase ids come from task
+ *   headings; no profile-specific body rules.
+ * - `lite`: the lite single-phase rules.
+ * - `brief`: taskless phase blocks (`**Intent:**`, `**Exit evidence:**`,
+ *   optional `**Provisional:**`). Phase ids come from `## Phase` headings.
+ * - `goal`: every `brief` rule plus the goal milestone rules: membership
+ *   read through the control-plane Milestones reader (its error codes map
+ *   onto `goal-*` codes), frozen delivery scopes from `oat_deliveries`,
+ *   parallel groups inside one milestone, `oat_plan_source: goal`, and
+ *   canonical phase ids in persisted registry lists.
+ */
+export type PlanProfile = 'task' | 'lite' | 'brief' | 'goal';
+export interface ValidationContext {
+    profile: PlanProfile;
+    workflowMode: WorkflowMode | null;
+    stateFrontmatter: Record<string, unknown> | null;
+    /**
+     * The journal (`implementation.md`), when readable. Goal membership reads it
+     * so a phase the journal marks extracted need not belong to a milestone.
+     */
+    implementationContent?: string | null;
+}
+export type BriefValidationErrorCode = 'brief-no-phases' | 'brief-duplicate-phase' | 'brief-phase-missing-intent' | 'brief-phase-missing-exit-evidence' | 'brief-provisional-invalid' | 'brief-first-phase-provisional' | 'brief-malformed-phase-heading';
+export type BriefValidationWarningCode = 'brief-task-headings-ignored';
+export type GoalValidationErrorCode = 'goal-milestones-missing' | 'goal-milestones-malformed' | 'goal-duplicate-milestone' | 'goal-milestone-empty' | 'goal-milestone-unknown-phase' | 'goal-phase-in-multiple-milestones' | 'goal-phase-without-milestone' | 'goal-shipped-milestone-changed' | 'goal-delivered-scope-changed' | 'goal-group-crosses-milestone' | 'goal-plan-source' | 'goal-noncanonical-phase-id';
+export type LiteValidationErrorCode = 'lite-multi-phase' | 'lite-parallel-groups' | 'lite-criterion-without-command';
+export type ValidationIssue = {
+    severity: 'error';
+    code: BriefValidationErrorCode | GoalValidationErrorCode | LiteValidationErrorCode;
+    message: string;
+} | {
+    severity: 'warning';
+    code: BriefValidationWarningCode;
+    message: string;
+};
+export declare function resolvePlanProfile(mode: WorkflowMode | null): PlanProfile;
+export type LitePlanValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    code: 'lite-multi-phase' | 'lite-parallel-groups' | 'lite-criterion-without-command';
+    message: string;
+};
+export declare function validateLitePlan(planContent: string, workflowMode: string | null | undefined): LitePlanValidationResult;
+/**
+ * The normalized id and name of a `## Phase` heading line, or `null` when the
+ * line is not a well-formed phase heading. Delegates to the control-plane
+ * phase-unit parser so heading spellings (`## Phase 1:`, `## Phase p01:`,
+ * `## Phase p-rev1:`, `## Revision Phase 1:`) normalize exactly as progress
+ * reads them.
+ */
+export declare function parsePhaseHeadingLine(line: string): {
+    phaseId: string;
+    name: string;
+} | null;
+export declare function extractPhaseIds(content: string, profile: PlanProfile): string[];
+export declare function validatePlanForProfile(content: string, ctx: ValidationContext): ValidationIssue[];
+/**
+ * Each Milestones reader error code maps onto exactly one goal rule code, so
+ * the reader stays the one membership predicate and validation never
+ * re-parses the table.
+ */
+export declare const GOAL_MEMBERSHIP_RULE_CODES: Readonly<Record<MilestoneMembershipErrorCode, GoalValidationErrorCode>>;
+//# sourceMappingURL=profiles.d.ts.map

package/dist/commands/project/validate-plan/profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/profiles.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,4BAA4B,EACjC,KAAK,YAAY,EAClB,MAAM,mCAAmC,CAAC;AAI3C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE7D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,WAAW,CAAC;IACrB,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACjD;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,MAAM,MAAM,wBAAwB,GAChC,iBAAiB,GACjB,uBAAuB,GACvB,4BAA4B,GAC5B,mCAAmC,GACnC,2BAA2B,GAC3B,+BAA+B,GAC/B,+BAA+B,CAAC;AAEpC,MAAM,MAAM,0BAA0B,GAAG,6BAA6B,CAAC;AAEvE,MAAM,MAAM,uBAAuB,GAC/B,yBAAyB,GACzB,2BAA2B,GAC3B,0BAA0B,GAC1B,sBAAsB,GACtB,8BAA8B,GAC9B,mCAAmC,GACnC,8BAA8B,GAC9B,gCAAgC,GAChC,8BAA8B,GAC9B,8BAA8B,GAC9B,kBAAkB,GAClB,4BAA4B,CAAC;AAEjC,MAAM,MAAM,uBAAuB,GAC/B,kBAAkB,GAClB,sBAAsB,GACtB,gCAAgC,CAAC;AAErC,MAAM,MAAM,eAAe,GACvB;IACE,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EACA,wBAAwB,GACxB,uBAAuB,GACvB,uBAAuB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB,GACD;IACE,QAAQ,EAAE,SAAS,CAAC;IACpB,IAAI,EAAE,0BAA0B,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEN,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,GAAG,WAAW,CAIzE;AAMD,MAAM,MAAM,wBAAwB,GAChC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IACE,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EACA,kBAAkB,GAClB,sBAAsB,GACtB,gCAAgC,CAAC;IACrC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAeN,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACtC,wBAAwB,CA8C1B;AAeD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAG1C;AAiBD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,GACnB,MAAM,EAAE,CAIV;AA0LD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,iBAAiB,GACrB,eAAe,EAAE,CAenB;AAMD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAC/C,MAAM,CAAC,4BAA4B,EAAE,uBAAuB,CAAC,CAS9D,CAAC"}

package/dist/commands/project/validate-plan/profiles.js

@@ -0,0 +1,420 @@
+import { isBriefMode, normalizeMilestoneId, normalizePhaseId, parseProvisionalPhaseIds, parseTaskProgress, readMilestoneMembership, recordLineMask, } from '@open-agent-toolkit/control-plane';
+import { parseFrontmatterFromContent } from './frontmatter.js';
+export function resolvePlanProfile(mode) {
+    if (mode === 'lite')
+        return 'lite';
+    if (isBriefMode(mode))
+        return mode;
+    return 'task';
+}
+function validationCriteria(planContent) {
+    const heading = /^## Validation Criteria[ \t]*$/m.exec(planContent);
+    if (!heading)
+        return null;
+    const bodyStart = heading.index + heading[0].length;
+    const remaining = planContent.slice(bodyStart);
+    const nextHeading = /^##\s+/m.exec(remaining);
+    const body = remaining.slice(0, nextHeading?.index ?? remaining.length);
+    return body
+        .split('\n')
+        .filter((line) => /^\s*-\s+/.test(line))
+        .map((line) => line.replace(/^\s*-\s+(?:\[[ xX]\]\s*)?/, '').trim());
+}
+export function validateLitePlan(planContent, workflowMode) {
+    if (workflowMode !== 'lite') {
+        return { ok: true };
+    }
+    const phaseCount = planContent.match(/^## Phase\b.*$/gm)?.length ?? 0;
+    if (phaseCount !== 1) {
+        return {
+            ok: false,
+            code: 'lite-multi-phase',
+            message: `Lite plans must contain exactly one phase; found ${phaseCount}.`,
+        };
+    }
+    const frontmatter = parseFrontmatterFromContent(planContent);
+    const groups = frontmatter.kind === 'invalid'
+        ? undefined
+        : frontmatter.data['oat_plan_parallel_groups'];
+    if (groups !== undefined &&
+        groups !== null &&
+        !(Array.isArray(groups) && groups.length === 0)) {
+        return {
+            ok: false,
+            code: 'lite-parallel-groups',
+            message: 'Lite plans must declare no parallel groups.',
+        };
+    }
+    const criteria = validationCriteria(planContent);
+    const invalidCriterion = criteria?.find((criterion) => !criterion.startsWith('manual:') && !/`[^`\n]+`/.test(criterion));
+    if (!criteria || criteria.length === 0 || invalidCriterion !== undefined) {
+        return {
+            ok: false,
+            code: 'lite-criterion-without-command',
+            message: 'Every lite Validation Criteria bullet must name a command in backticks or start with manual: after the bullet marker.',
+        };
+    }
+    return { ok: true };
+}
+// ---------------------------------------------------------------------------
+// phase id extraction
+// ---------------------------------------------------------------------------
+function extractTaskHeadingPhaseIds(planContent) {
+    const matches = planContent.match(/### Task (p\d+)-t\d+/g) ?? [];
+    const ids = matches.map((m) => {
+        const parts = m.split(' ');
+        return parts[2].split('-')[0];
+    });
+    return Array.from(new Set(ids)).sort();
+}
+/**
+ * The normalized id and name of a `## Phase` heading line, or `null` when the
+ * line is not a well-formed phase heading. Delegates to the control-plane
+ * phase-unit parser so heading spellings (`## Phase 1:`, `## Phase p01:`,
+ * `## Phase p-rev1:`, `## Revision Phase 1:`) normalize exactly as progress
+ * reads them.
+ */
+export function parsePhaseHeadingLine(line) {
+    const phase = parseTaskProgress(line, '', { phaseUnits: true }).phases[0];
+    return phase ? { phaseId: phase.phaseId, name: phase.name } : null;
+}
+function phaseIdOfHeading(line) {
+    return parsePhaseHeadingLine(line)?.phaseId ?? null;
+}
+/**
+ * Normalized `## Phase` heading ids in document order, outside fenced and
+ * indented code, each listed once.
+ */
+function extractBriefPhaseIds(planContent) {
+    const ids = parseTaskProgress(planContent, '', {
+        phaseUnits: true,
+    }).phases.map((phase) => phase.phaseId);
+    return Array.from(new Set(ids));
+}
+export function extractPhaseIds(content, profile) {
+    return profile === 'brief' || profile === 'goal'
+        ? extractBriefPhaseIds(content)
+        : extractTaskHeadingPhaseIds(content);
+}
+// ---------------------------------------------------------------------------
+// brief profile
+// ---------------------------------------------------------------------------
+/**
+ * Plan record lines, through the control-plane reader that phase-unit
+ * progress and quick plan readiness use, so a fenced example phase block
+ * never validates or fails a real plan.
+ */
+function recordLines(content) {
+    const lines = content.split('\n');
+    const mask = recordLineMask(lines);
+    return lines.filter((_, index) => mask[index]);
+}
+const PHASE_HEADING_CANDIDATE = /^##[ \t]+(?:Revision[ \t]+)?Phase\b/;
+const SECTION_HEADING = /^#{1,2}[ \t]/;
+const ANY_HEADING = /^#/;
+const TASK_HEADING = /^###[ \t]+Task\b/;
+const FIELD_MARKER = /^\*\*[^*\n]+:\*\*/;
+const INTENT_MARKER = /^\*\*Intent:\*\*(.*)$/;
+const EXIT_EVIDENCE_MARKER = /^\*\*Exit evidence:\*\*(.*)$/;
+const PROVISIONAL_LINE = /^\*\*Provisional:\*\*/;
+// The control-plane parser's grammar: a space after the marker, then the value.
+const PROVISIONAL_VALID = /^\*\*Provisional:\*\*\s+(?:yes|no)$/;
+/**
+ * Whether a phase block carries `marker` with content: a non-empty value on
+ * the marker line, or at least one continuation line before the next blank
+ * line or field marker.
+ */
+function hasFilledField(lines, marker) {
+    for (const [index, line] of lines.entries()) {
+        const match = line.trim().match(marker);
+        if (!match)
+            continue;
+        if ((match[1] ?? '').trim().length > 0)
+            return true;
+        const next = (lines[index + 1] ?? '').trim();
+        if (next.length > 0 && !FIELD_MARKER.test(next))
+            return true;
+    }
+    return false;
+}
+function readBriefPhaseBlocks(content) {
+    const blocks = [];
+    const malformed = [];
+    // Marker ownership ends at the next line starting with `#` (the phase block
+    // grammar); task-heading attribution lasts until the next `#`/`##` heading.
+    let owner = null;
+    let section = null;
+    for (const line of recordLines(content)) {
+        if (PHASE_HEADING_CANDIDATE.test(line)) {
+            const phaseId = phaseIdOfHeading(line);
+            if (phaseId == null) {
+                malformed.push(line.trim());
+                owner = null;
+                section = null;
+                continue;
+            }
+            const block = { phaseId, lines: [], taskHeadings: 0 };
+            blocks.push(block);
+            owner = block;
+            section = block;
+            continue;
+        }
+        if (SECTION_HEADING.test(line)) {
+            owner = null;
+            section = null;
+            continue;
+        }
+        if (TASK_HEADING.test(line) && section != null) {
+            section.taskHeadings += 1;
+        }
+        if (ANY_HEADING.test(line)) {
+            owner = null;
+            continue;
+        }
+        owner?.lines.push(line);
+    }
+    return { blocks, malformed };
+}
+function validateBriefPlan(content) {
+    const issues = [];
+    const { blocks, malformed } = readBriefPhaseBlocks(content);
+    for (const heading of malformed) {
+        issues.push({
+            severity: 'error',
+            code: 'brief-malformed-phase-heading',
+            message: `brief-malformed-phase-heading: "${heading}" is not a phase heading; use "## Phase pNN: <name>".`,
+        });
+    }
+    if (blocks.length === 0) {
+        issues.push({
+            severity: 'error',
+            code: 'brief-no-phases',
+            message: 'brief-no-phases: Brief plans must declare at least one "## Phase pNN: <name>" block.',
+        });
+        return issues;
+    }
+    const seen = new Set();
+    const reported = new Set();
+    for (const { phaseId } of blocks) {
+        if (seen.has(phaseId) && !reported.has(phaseId)) {
+            reported.add(phaseId);
+            issues.push({
+                severity: 'error',
+                code: 'brief-duplicate-phase',
+                message: `brief-duplicate-phase: Phase ${phaseId} is declared more than once.`,
+            });
+        }
+        seen.add(phaseId);
+    }
+    for (const block of blocks) {
+        if (!hasFilledField(block.lines, INTENT_MARKER)) {
+            issues.push({
+                severity: 'error',
+                code: 'brief-phase-missing-intent',
+                message: `brief-phase-missing-intent: Phase ${block.phaseId} has no non-empty **Intent:**.`,
+            });
+        }
+        if (!hasFilledField(block.lines, EXIT_EVIDENCE_MARKER)) {
+            issues.push({
+                severity: 'error',
+                code: 'brief-phase-missing-exit-evidence',
+                message: `brief-phase-missing-exit-evidence: Phase ${block.phaseId} has no non-empty **Exit evidence:**.`,
+            });
+        }
+        for (const line of block.lines) {
+            const trimmed = line.trim();
+            if (PROVISIONAL_LINE.test(trimmed) && !PROVISIONAL_VALID.test(trimmed)) {
+                issues.push({
+                    severity: 'error',
+                    code: 'brief-provisional-invalid',
+                    message: `brief-provisional-invalid: Phase ${block.phaseId} has "${trimmed}"; use "**Provisional:** yes" or "**Provisional:** no".`,
+                });
+            }
+        }
+    }
+    const firstPhaseId = blocks[0].phaseId;
+    if (parseProvisionalPhaseIds(content).has(firstPhaseId)) {
+        issues.push({
+            severity: 'error',
+            code: 'brief-first-phase-provisional',
+            message: `brief-first-phase-provisional: The first phase (${firstPhaseId}) cannot be provisional.`,
+        });
+    }
+    const withTasks = blocks.filter((block) => block.taskHeadings > 0);
+    if (withTasks.length > 0) {
+        issues.push({
+            severity: 'warning',
+            code: 'brief-task-headings-ignored',
+            message: `brief-task-headings-ignored: Task headings in plan.md under ${withTasks
+                .map((block) => block.phaseId)
+                .join(', ')} do not count toward brief progress; record execution tasks in implementation.md.`,
+        });
+    }
+    return issues;
+}
+export function validatePlanForProfile(content, ctx) {
+    switch (ctx.profile) {
+        case 'lite': {
+            const result = validateLitePlan(content, 'lite');
+            return result.ok
+                ? []
+                : [{ severity: 'error', code: result.code, message: result.message }];
+        }
+        case 'brief':
+            return validateBriefPlan(content);
+        case 'goal':
+            return [...validateBriefPlan(content), ...validateGoalPlan(content, ctx)];
+        case 'task':
+            return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// goal profile
+// ---------------------------------------------------------------------------
+/**
+ * Each Milestones reader error code maps onto exactly one goal rule code, so
+ * the reader stays the one membership predicate and validation never
+ * re-parses the table.
+ */
+export const GOAL_MEMBERSHIP_RULE_CODES = {
+    'milestones-missing': 'goal-milestones-missing',
+    'milestones-malformed': 'goal-milestones-malformed',
+    'milestone-duplicate': 'goal-duplicate-milestone',
+    'milestone-empty': 'goal-milestone-empty',
+    'milestone-unknown-phase': 'goal-milestone-unknown-phase',
+    'phase-in-multiple-milestones': 'goal-phase-in-multiple-milestones',
+    'phase-without-milestone': 'goal-phase-without-milestone',
+};
+function goalError(code, message) {
+    return { severity: 'error', code, message: `${code}: ${message}` };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function rawList(value) {
+    return Array.isArray(value) ? value : [];
+}
+function readRawDeliveries(state) {
+    return rawList(state?.['oat_deliveries'])
+        .filter(isRecord)
+        .map((entry, index) => ({
+        label: typeof entry['delivery_id'] === 'string'
+            ? entry['delivery_id']
+            : `oat_deliveries[${index}]`,
+        milestone: normalizeMilestoneId(entry['milestone']),
+        scope: rawList(entry['scope'])
+            .map((token) => normalizePhaseId(String(token)))
+            .filter((token) => token !== null),
+    }));
+}
+/**
+ * Persisted phase-id lists in the goal registry. The state reader normalizes
+ * these and drops tokens that are not phase ids; validation reports every
+ * token that is not already canonical so the drift is repaired at its source.
+ */
+function persistedPhaseIdLists(state) {
+    if (state === null)
+        return [];
+    const lists = [];
+    const carrierLists = (prefix, carrier) => {
+        if (isRecord(carrier) && isRecord(carrier['subject'])) {
+            lists.push({
+                field: `${prefix}.subject.scope`,
+                values: rawList(carrier['subject']['scope']),
+            });
+        }
+    };
+    const recovery = state['oat_goal_recovery'];
+    if (isRecord(recovery)) {
+        lists.push({
+            field: 'oat_goal_recovery.phase_ids',
+            values: rawList(recovery['phase_ids']),
+        });
+    }
+    for (const [index, entry] of rawList(state['oat_deliveries']).entries()) {
+        if (!isRecord(entry))
+            continue;
+        const prefix = `oat_deliveries[${index}]`;
+        lists.push({ field: `${prefix}.scope`, values: rawList(entry['scope']) });
+        if (isRecord(entry['integrated_review'])) {
+            lists.push({
+                field: `${prefix}.integrated_review.scope`,
+                values: rawList(entry['integrated_review']['scope']),
+            });
+        }
+        carrierLists(`${prefix}.exit_gate`, entry['exit_gate']);
+    }
+    const gates = state['oat_milestone_gates'];
+    if (isRecord(gates)) {
+        for (const [milestone, carriers] of Object.entries(gates)) {
+            if (!isRecord(carriers))
+                continue;
+            carrierLists(`oat_milestone_gates.${milestone}.plan`, carriers['plan']);
+            carrierLists(`oat_milestone_gates.${milestone}.exit`, carriers['exit']);
+        }
+    }
+    return lists;
+}
+function validateGoalPlan(content, ctx) {
+    const issues = [];
+    const frontmatter = parseFrontmatterFromContent(content);
+    const planData = frontmatter.kind === 'invalid' ? {} : frontmatter.data;
+    if (planData['oat_plan_source'] !== 'goal') {
+        issues.push(goalError('goal-plan-source', `Goal plans must declare "oat_plan_source: goal"; found ${JSON.stringify(planData['oat_plan_source'] ?? null)}.`));
+    }
+    const membership = readMilestoneMembership(content, ctx.implementationContent ?? '');
+    for (const error of membership.errors) {
+        issues.push(goalError(GOAL_MEMBERSHIP_RULE_CODES[error.code], error.message));
+    }
+    const owners = new Map();
+    for (const row of membership.milestones) {
+        for (const phaseId of row.phaseIds) {
+            if (!owners.has(phaseId))
+                owners.set(phaseId, row.milestoneId);
+        }
+    }
+    const declaredMilestones = new Set(membership.milestones.map((row) => row.milestoneId));
+    const declaredPhases = new Set(extractBriefPhaseIds(content));
+    for (const delivery of readRawDeliveries(ctx.stateFrontmatter)) {
+        if (!membership.present || delivery.milestone === null)
+            continue;
+        if (!declaredMilestones.has(delivery.milestone)) {
+            issues.push(goalError('goal-shipped-milestone-changed', `Delivery ${delivery.label} shipped milestone ${delivery.milestone}, which the Milestones table no longer declares.`));
+            continue;
+        }
+        for (const phaseId of delivery.scope) {
+            if (!declaredPhases.has(phaseId)) {
+                issues.push(goalError('goal-delivered-scope-changed', `Delivery ${delivery.label} froze ${phaseId} in its scope, but the brief no longer declares it.`));
+                continue;
+            }
+            const owner = owners.get(phaseId);
+            if (owner !== undefined && owner !== delivery.milestone) {
+                issues.push(goalError('goal-delivered-scope-changed', `Delivery ${delivery.label} froze ${phaseId} under ${delivery.milestone}, but the Milestones table now assigns it to ${owner}.`));
+            }
+            else if (owner === undefined) {
+                issues.push(goalError('goal-delivered-scope-changed', `Delivery ${delivery.label} froze ${phaseId} under ${delivery.milestone}, but the Milestones table no longer lists it there.`));
+            }
+        }
+    }
+    for (const [index, group] of rawList(planData['oat_plan_parallel_groups']).entries()) {
+        const groupOwners = new Set();
+        for (const member of rawList(group)) {
+            const phaseId = normalizePhaseId(String(member));
+            const owner = phaseId === null ? undefined : owners.get(phaseId);
+            if (owner !== undefined)
+                groupOwners.add(owner);
+        }
+        if (groupOwners.size > 1) {
+            issues.push(goalError('goal-group-crosses-milestone', `Parallel group ${index} spans milestones ${[...groupOwners].join(', ')}; a group must sit inside one milestone.`));
+        }
+    }
+    for (const { field, values } of persistedPhaseIdLists(ctx.stateFrontmatter)) {
+        for (const value of values) {
+            const token = typeof value === 'string' ? value : String(value);
+            if (normalizePhaseId(token) !== token) {
+                issues.push(goalError('goal-noncanonical-phase-id', `${field} holds ${JSON.stringify(value)}, which is not a canonical phase id like "p01" or "p-rev1".`));
+            }
+        }
+    }
+    return issues;
+}