@open-agent-toolkit/cli 0.3.17 → 0.3.19

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,49 @@ 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 workflowMode = toWorkflowMode(stateFrontmatter?.['oat_workflow_mode']);
+        const profile = resolvePlanProfile(workflowMode);
+        const phaseIds = extractPhaseIds(content, profile);
+        const issues = validatePlanForProfile(content, {
+            profile,
+            workflowMode,
+            stateFrontmatter,
+        });
+        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);
+            }
         }
-        const liteResult = validateLitePlan(content, workflowMode);
-        if (!liteResult.ok) {
+        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 +104,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 +113,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,54 @@
+import { 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`: reserved for the goal mode; until its milestone rules land it
+ *   validates exactly like `brief`.
+ */
+export type PlanProfile = 'task' | 'lite' | 'brief' | 'goal';
+export interface ValidationContext {
+    profile: PlanProfile;
+    workflowMode: WorkflowMode | null;
+    stateFrontmatter: Record<string, unknown> | 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 LiteValidationErrorCode = 'lite-multi-phase' | 'lite-parallel-groups' | 'lite-criterion-without-command';
+export type ValidationIssue = {
+    severity: 'error';
+    code: BriefValidationErrorCode | 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[];
+//# 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,EAKL,KAAK,YAAY,EAClB,MAAM,mCAAmC,CAAC;AAI3C;;;;;;;;;;;GAWG;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;CAClD;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,kBAAkB,GAClB,sBAAsB,GACtB,gCAAgC,CAAC;AAErC,MAAM,MAAM,eAAe,GACvB;IACE,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,wBAAwB,GAAG,uBAAuB,CAAC;IACzD,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,CAcnB"}

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

@@ -0,0 +1,269 @@
+import { isBriefMode, parseProvisionalPhaseIds, parseTaskProgress, 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':
+        case 'goal':
+            return validateBriefPlan(content);
+        case 'task':
+            return [];
+    }
+}

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

@@ -1,28 +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;
+export { parseFrontmatterFromContent, type FrontmatterResult, } from './frontmatter.js';
+export { extractPhaseIds, resolvePlanProfile, validateLitePlan, validatePlanForProfile, type LitePlanValidationResult, type PlanProfile, type ValidationContext, type ValidationIssue, } from './profiles.js';
 export type ValidationResult = {
     valid: true;
 } | {
     valid: false;
     errors: string[];
 };
-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;
 export declare function validateParallelGroups(groups: unknown, phaseIds: readonly string[]): ValidationResult;
+/** Task-profile phase ids: unique task-heading phase ids, sorted. */
 export declare function extractPhaseIdsFromPlan(planContent: string): string[];
 //# sourceMappingURL=validate-plan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate-plan.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/validate-plan.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;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GACf;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvC,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,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,gBAAgB,CAgDlB;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAOrE"}
+{"version":3,"file":"validate-plan.d.ts","sourceRoot":"","sources":["../../../../src/commands/project/validate-plan/validate-plan.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,2BAA2B,EAC3B,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GACf;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvC,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,gBAAgB,CAgDlB;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAErE"}

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

@@ -1,79 +1,6 @@
-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}`,
-        };
-    }
-}
-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 };
-}
+import { extractPhaseIds } from './profiles.js';
+export { parseFrontmatterFromContent, } from './frontmatter.js';
+export { extractPhaseIds, resolvePlanProfile, validateLitePlan, validatePlanForProfile, } from './profiles.js';
 export function validateParallelGroups(groups, phaseIds) {
     // Missing or empty → valid (sequential execution, no parallelism declared)
     if (groups === undefined || groups === null) {
@@ -116,11 +43,7 @@ export function validateParallelGroups(groups, phaseIds) {
     }
     return errors.length > 0 ? { valid: false, errors } : { valid: true };
 }
+/** Task-profile phase ids: unique task-heading phase ids, sorted. */
 export function extractPhaseIdsFromPlan(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();
+    return extractPhaseIds(planContent, 'task');
 }

package/dist/commands/shared/agents-md-lock.d.ts

@@ -0,0 +1,3 @@
+/** Specific advisory serialization for cooperating AGENTS.md appenders. */
+export declare function acquireAgentsMdAppendLock(repoRoot: string, targetPath: string): Promise<() => Promise<void>>;
+//# sourceMappingURL=agents-md-lock.d.ts.map

package/dist/commands/shared/agents-md-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents-md-lock.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/agents-md-lock.ts"],"names":[],"mappings":"AAOA,2EAA2E;AAC3E,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CA6I9B"}