agentic-orchestrator 0.1.27 → 0.2.0

package/apps/control-plane/test/plan-service.spec.ts

@@ -13,7 +13,7 @@ vi.mock('../src/core/fs.js', async () => {
   };
 });
 
-import { PlanService } from '../src/application/services/plan-service.js';
+import { PlanService, renderPlanMarkdown } from '../src/application/services/plan-service.js';
 
 type AnyRecord = Record<string, any>;
 
@@ -48,16 +48,40 @@ async function writePlan(repoRoot: string, featureId: string, plan: AnyRecord):
   await fs.writeFile(path.join(featureDir, 'plan.json'), JSON.stringify(plan, null, 2), 'utf8');
 }
 
+async function writeVerifiedManifest(
+  repoRoot: string,
+  featureId: string,
+  manifest: AnyRecord,
+): Promise<void> {
+  const featureDir = path.join(repoRoot, featureId);
+  await fs.mkdir(featureDir, { recursive: true });
+  await fs.writeFile(
+    path.join(featureDir, 'spec.manifest.verified.json'),
+    JSON.stringify(manifest, null, 2),
+    'utf8',
+  );
+}
+
 async function createHarness(options: {
   collisionPolicy?: 'block' | 'reject';
   specs?: string[];
   stateLocks?: string[];
   stateGateProfile?: string;
+  stateStatus?: string;
+  intakeStatus?: string | null;
+  dependsOn?: string[];
+  validateSchemaImpl?: (
+    schemaName: string,
+    value: unknown,
+  ) => Promise<{ valid: boolean; errors?: unknown }>;
 }) {
   const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-plan-service-'));
   const specs = options.specs ?? ['feature_a', 'feature_ref'];
   const stateLocks = options.stateLocks ?? ['openapi', 'events', 'db_migrations'];
   const stateGateProfile = options.stateGateProfile ?? 'default';
+  const stateStatus = options.stateStatus ?? 'planning';
+  const intakeStatus = options.intakeStatus ?? null;
+  const dependsOn = options.dependsOn ?? [];
   const writes: AnyRecord[] = [];
   const stateUpdates: AnyRecord[] = [];
   let index: AnyRecord = {
@@ -104,15 +128,20 @@ async function createHarness(options: {
     }),
     readState: async () => ({
       frontMatter: {
-        status: 'planning',
+        status: stateStatus,
         gate_profile: stateGateProfile,
+        intake: intakeStatus ? { status: intakeStatus } : {},
+        depends_on: dependsOn,
         locks: {
           held: stateLocks,
         },
         gates: {},
       },
     }),
-    validateSchema: async () => ({ valid: true }),
+    validateSchema: async (schemaName: string, value: unknown) =>
+      options.validateSchemaImpl
+        ? await options.validateSchemaImpl(schemaName, value)
+        : { valid: true },
     withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) =>
       await operation(),
     withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
@@ -135,6 +164,9 @@ async function createHarness(options: {
     writes,
     stateUpdates,
     getIndex: () => JSON.parse(JSON.stringify(index)),
+    setIndex: (nextIndex: AnyRecord) => {
+      index = JSON.parse(JSON.stringify(nextIndex));
+    },
     cleanup: async () => await fs.rm(repoRoot, { recursive: true, force: true }),
   };
 }
@@ -185,7 +217,7 @@ describe('PlanService', () => {
     expect(queue.map((entry: AnyRecord) => entry.feature_id)).toEqual(['feature_a', 'feature_z']);
     expect(queue[0]?.required_resources).toEqual(['db_migrations', 'openapi']);
     expect(queue[1]?.required_resources).toEqual(['db_migrations', 'events', 'openapi']);
-    expect(harness.writes).toHaveLength(2);
+    expect(harness.writes).toHaveLength(4);
   });
 
   it('GIVEN_blocked_collision_then_conflict_resolved_WHEN_resubmitting_same_plan_THEN_accepts_retry', async () => {
@@ -223,6 +255,593 @@ describe('PlanService', () => {
     expect(harness.stateUpdates.length).toBe(1);
   });
 
+  it('GIVEN_colliding_plan_with_merged_feature_WHEN_submitting_THEN_ignores_merged_and_accepts', async () => {
+    const harness = await createHarness({
+      collisionPolicy: 'reject',
+      specs: ['feature_a', 'feature_merged'],
+    });
+    cleanups.push(harness.cleanup);
+
+    harness.setIndex({
+      ...harness.getIndex(),
+      merged: ['feature_merged'],
+    });
+
+    await writePlan(harness.repoRoot, 'feature_merged', makePlan('feature_merged'));
+
+    const accepted = await harness.service.planSubmit('feature_a', makePlan('feature_a'), null);
+    expect(accepted).toMatchObject({
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 1,
+      },
+    });
+  });
+
+  it('applies an approved collision override and accepts the colliding plan', async () => {
+    const harness = await createHarness({
+      collisionPolicy: 'reject',
+      specs: ['feature_a', 'feature_ref'],
+    });
+    cleanups.push(harness.cleanup);
+
+    const referencePlan = makePlan('feature_ref');
+    const candidatePlan = makePlan('feature_a');
+    await writePlan(harness.repoRoot, 'feature_ref', referencePlan);
+
+    await expect(
+      harness.service.planSubmit('feature_a', candidatePlan, null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.COLLISION_DETECTED,
+        },
+      },
+    });
+
+    const collisionRecord = harness.getIndex().collision_records[0];
+    harness.setIndex({
+      ...harness.getIndex(),
+      collision_overrides: [
+        {
+          override_id: 'override_001',
+          feature_ids: ['feature_a', 'feature_ref'],
+          created_at: '2026-01-01T00:00:00.000Z',
+          created_by: 'tester',
+          rationale: 'expected overlap',
+          approved_collision_fingerprint: collisionRecord.collision_fingerprint,
+          approved_paths: ['apps/control-plane/src/shared.ts'],
+          approved_with_feature_ids: ['feature_ref'],
+          status: 'active',
+          source_collision_id: collisionRecord.collision_id,
+        },
+      ],
+    });
+
+    const accepted = await harness.service.planSubmit('feature_a', candidatePlan, null);
+    expect(accepted).toMatchObject({
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 1,
+      },
+    });
+
+    const nextIndex = harness.getIndex();
+    expect(nextIndex.collision_overrides[0]).toMatchObject({
+      override_id: 'override_001',
+      status: 'applied',
+      source_collision_id: collisionRecord.collision_id,
+    });
+    expect(
+      nextIndex.collision_records.some(
+        (entry: AnyRecord) => entry.resolution === 'override_applied',
+      ),
+    ).toBe(true);
+    expect(
+      nextIndex.collision_records.some((entry: AnyRecord) => entry.resolution === 'cleared'),
+    ).toBe(true);
+  });
+
+  it('rejects contract collisions without offering an override workflow', async () => {
+    const harness = await createHarness({
+      collisionPolicy: 'reject',
+      specs: ['feature_a', 'feature_ref'],
+    });
+    cleanups.push(harness.cleanup);
+
+    await writePlan(
+      harness.repoRoot,
+      'feature_ref',
+      makePlan('feature_ref', {
+        contracts: {
+          openapi: 'modify',
+          events: 'none',
+          db: 'none',
+        },
+      }),
+    );
+
+    await expect(
+      harness.service.planSubmit(
+        'feature_a',
+        makePlan('feature_a', {
+          contracts: {
+            openapi: 'modify',
+            events: 'none',
+            db: 'none',
+          },
+        }),
+        null,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.COLLISION_DETECTED,
+          details: {
+            suggested_next_actions: [
+              'Acquire relevant lock and resubmit',
+              'Revise plan scope to avoid shared contract changes',
+              'Create shared prerequisite feature',
+            ],
+          },
+        },
+      },
+    });
+
+    expect(harness.getIndex().collision_records[0]).toMatchObject({
+      resolution: 'rejected',
+      with_feature_ids: ['feature_ref'],
+    });
+  });
+
+  it('requires a verified manifest before accepting execution plans from intake', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'intake',
+      intakeStatus: 'in_progress',
+    });
+    cleanups.push(harness.cleanup);
+
+    await expect(
+      harness.service.planSubmit('feature_a', makePlan('feature_a'), null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.VERIFIED_MANIFEST_REQUIRED,
+        },
+      },
+    });
+  });
+
+  it('returns early when dependency checks are invoked without a feature id', async () => {
+    const harness = await createHarness({ specs: ['feature_a'] });
+    cleanups.push(harness.cleanup);
+
+    await expect(harness.service.checkDependencies(null)).resolves.toBeUndefined();
+  });
+
+  it('rejects circular dependencies before accepting a plan', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      dependsOn: ['feature_a'],
+    });
+    cleanups.push(harness.cleanup);
+
+    await expect(harness.service.checkDependencies('feature_a')).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.DEPENDENCY_CIRCULAR,
+        },
+      },
+    });
+  });
+
+  it('defers plans with unresolved dependencies and records the blocked dependency set', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      dependsOn: ['feature_dep'],
+    });
+    cleanups.push(harness.cleanup);
+
+    await expect(harness.service.checkDependencies('feature_a')).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.DEPENDENCY_UNRESOLVED,
+          details: {
+            depends_on_unresolved: ['feature_dep'],
+          },
+        },
+      },
+    });
+
+    expect(harness.getIndex().dep_blocked).toEqual([
+      {
+        feature_id: 'feature_a',
+        depends_on_unresolved: ['feature_dep'],
+      },
+    ]);
+  });
+
+  it('rejects missing plan payloads and mismatched feature identifiers', async () => {
+    const harness = await createHarness({ specs: ['feature_a'] });
+    cleanups.push(harness.cleanup);
+
+    await expect(harness.service.planSubmit('feature_a', null, null)).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_ARGUMENT,
+        },
+      },
+    });
+
+    await expect(
+      harness.service.planSubmit('feature_a', makePlan('other_feature'), null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_ARGUMENT,
+        },
+      },
+    });
+  });
+
+  it('rejects plan traces that do not cover the verified manifest contract', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'planning',
+      intakeStatus: 'verified',
+      stateLocks: [],
+    });
+    cleanups.push(harness.cleanup);
+
+    await writeVerifiedManifest(harness.repoRoot, 'feature_a', {
+      feature_id: 'feature_a',
+      manifest_version: 1,
+      artifact_type: 'verified',
+      verification_basis: 'human_review_confirmed',
+      verified_at: '2026-01-01T00:00:00.000Z',
+      source_bootstrap_version: 1,
+      obligations: [
+        { obligation_id: 'OBL-001', name: 'one' },
+        { obligation_id: 'OBL-002', name: 'two' },
+      ],
+    });
+
+    await expect(
+      harness.service.planSubmit(
+        'feature_a',
+        makePlan('feature_a', {
+          plan_trace: [
+            {
+              obligation_id: 'OBL-001',
+              disposition: 'in_scope',
+              planned_paths: ['apps/not-in-plan.ts'],
+              notes: 'bad mapping',
+            },
+            {
+              obligation_id: 'OBL-001',
+              disposition: 'in_scope',
+              planned_paths: ['apps/control-plane/src/shared.ts'],
+              notes: 'duplicate',
+            },
+            {
+              obligation_id: 'OBL-999',
+              disposition: 'in_scope',
+              planned_paths: ['apps/control-plane/src/shared.ts'],
+              notes: 'unknown',
+            },
+          ],
+        }),
+        null,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.PLAN_TRACE_INVALID,
+          details: {
+            missing_obligation_ids: ['OBL-002'],
+            unknown_obligation_ids: ['OBL-999'],
+            duplicate_obligation_ids: ['OBL-001'],
+            invalid_mappings: ['OBL-001'],
+            invalid_mapping_details: [
+              {
+                obligation_id: 'OBL-001',
+                reason: 'planned_paths_outside_plan_files',
+                planned_paths: ['apps/not-in-plan.ts'],
+              },
+            ],
+          },
+        },
+      },
+    });
+  });
+
+  it('treats malformed verified manifests as missing before execution planning begins', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'planning',
+      intakeStatus: 'verified',
+      stateLocks: [],
+      validateSchemaImpl: async (schemaName, value) => {
+        if (schemaName !== 'spec.manifest.verified.schema.json') {
+          return { valid: true };
+        }
+        const record = value as Record<string, unknown>;
+        const verificationBasis = record.verification_basis;
+        const verifiedAt = record.verified_at;
+        const obligations = Array.isArray(record.obligations) ? record.obligations : [];
+        const obligationsValid = obligations.every((obligation) => {
+          const obligationRecord = obligation as Record<string, unknown>;
+          return (
+            typeof obligationRecord.obligation_id === 'string' &&
+            /^OBL-\d{3,}$/.test(obligationRecord.obligation_id)
+          );
+        });
+        const basisValid =
+          verificationBasis === 'structured_spec' ||
+          verificationBasis === 'questions_resolved' ||
+          verificationBasis === 'policy_approved_auto_promotion' ||
+          verificationBasis === 'human_review_confirmed';
+        return {
+          valid:
+            basisValid &&
+            typeof verifiedAt === 'string' &&
+            verifiedAt.length > 0 &&
+            obligationsValid,
+        };
+      },
+    });
+    cleanups.push(harness.cleanup);
+
+    await writeVerifiedManifest(harness.repoRoot, 'feature_a', {
+      feature_id: 'feature_a',
+      manifest_version: 1,
+      artifact_type: 'verified',
+      verification_basis: 'pending_confirmation',
+      verified_at: null,
+      source_bootstrap_version: 1,
+      obligations: [
+        {
+          obligation_id: 'OBL-V01',
+          name: 'draft obligation',
+        },
+      ],
+    });
+
+    await expect(
+      harness.service.planSubmit('feature_a', makePlan('feature_a'), null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.VERIFIED_MANIFEST_REQUIRED,
+        },
+      },
+    });
+  });
+
+  it('treats non-object verified-manifest payloads as missing before execution planning begins', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'planning',
+      intakeStatus: 'verified',
+      stateLocks: [],
+      validateSchemaImpl: async () => ({ valid: true }),
+    });
+    cleanups.push(harness.cleanup);
+
+    await writeVerifiedManifest(
+      harness.repoRoot,
+      'feature_a',
+      'draft-payload' as unknown as AnyRecord,
+    );
+
+    await expect(
+      harness.service.planSubmit('feature_a', makePlan('feature_a'), null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.VERIFIED_MANIFEST_REQUIRED,
+        },
+      },
+    });
+  });
+
+  it('treats verified-manifest payloads with missing required fields as missing before execution planning begins', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'planning',
+      intakeStatus: 'verified',
+      stateLocks: [],
+      validateSchemaImpl: async () => ({ valid: true }),
+    });
+    cleanups.push(harness.cleanup);
+
+    await writeVerifiedManifest(harness.repoRoot, 'feature_a', {
+      feature_id: 'feature_a',
+      artifact_type: 'verified',
+    });
+
+    await expect(
+      harness.service.planSubmit('feature_a', makePlan('feature_a'), null),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.VERIFIED_MANIFEST_REQUIRED,
+        },
+      },
+    });
+  });
+
+  it('accepts valid plan traces against a verified manifest and promotes blocked features into building', async () => {
+    const harness = await createHarness({
+      specs: ['feature_a'],
+      stateStatus: 'blocked',
+      intakeStatus: 'verified',
+      stateLocks: [],
+    });
+    cleanups.push(harness.cleanup);
+
+    await writeVerifiedManifest(harness.repoRoot, 'feature_a', {
+      feature_id: 'feature_a',
+      manifest_version: 1,
+      artifact_type: 'verified',
+      verification_basis: 'human_review_confirmed',
+      verified_at: '2026-01-01T00:00:00.000Z',
+      source_bootstrap_version: 1,
+      obligations: [{ obligation_id: 'OBL-001', name: 'one' }],
+    });
+
+    const accepted = await harness.service.planSubmit(
+      'feature_a',
+      makePlan('feature_a', {
+        files: {
+          create: ['apps/control-plane/src/new-file.ts'],
+          modify: ['apps/control-plane/src/shared.ts'],
+          delete: ['apps/control-plane/src/legacy.ts'],
+        },
+        plan_trace: [
+          {
+            obligation_id: 'OBL-001',
+            disposition: 'in_scope',
+            planned_paths: ['apps/control-plane/src/new-file.ts'],
+            planned_test_paths: ['apps/control-plane/test/new-file.spec.ts'],
+            planned_verification: ['qa:fast'],
+            notes: 'fully traced',
+          },
+        ],
+      }),
+      null,
+    );
+
+    expect(accepted).toMatchObject({
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 1,
+      },
+    });
+    expect(harness.stateUpdates[0].frontMatter?.status).toBe('building');
+  });
+
+  it('rejects invalid plan schemas and revision metadata through the direct validators', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-plan-service-invalid-'));
+    cleanups.push(async () => await fs.rm(repoRoot, { recursive: true, force: true }));
+    const service = new PlanService({
+      getPolicySnapshot: () => ({
+        collision_policy: 'block',
+        gate_selection: {
+          default_profile: 'default',
+          auto_heal_invalid_state_profile: true,
+          legacy_mode_profile_compat: true,
+        },
+        locks: {
+          contract_to_resource: {
+            openapi: 'openapi',
+            events: 'events',
+            db: 'db_migrations',
+          },
+        },
+      }),
+      getGatesConfig: () => ({
+        profiles: {
+          default: {
+            modes: {
+              fast: [],
+              full: [],
+              merge: [],
+            },
+          },
+        },
+      }),
+      planPath: (featureId: string) => path.join(repoRoot, featureId, 'plan.json'),
+      featureDiscoverSpecs: async () => ({ data: { specs: [] } }),
+      readState: async () => ({ frontMatter: { status: 'planning', gates: {} } }),
+      validateSchema: async () => ({
+        valid: false,
+        errors: [{ instancePath: '/summary', message: 'required' }],
+      }),
+      withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) =>
+        await operation(),
+      withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+      readIndex: async () => ({
+        version: 1,
+        active: [],
+        blocked: [],
+        merged: [],
+        locks: {},
+        lock_leases: {},
+        blocked_queue: [],
+        runtime_sessions: {},
+      }),
+      writeIndex: async () => undefined,
+      updateState: async (_featureId: string, _expectedVersion: number | null, updater: any) => {
+        const updated = await updater({ status: 'planning', gates: {} }, '');
+        return updated.frontMatter ?? {};
+      },
+    });
+
+    await expect(service.validatePlanSchema(makePlan('feature_a'))).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.PLAN_VALIDATION_FAILED,
+        },
+      },
+    });
+
+    expect(() =>
+      service.validatePlanRevisionRules(null, makePlan('feature_a', { plan_version: 2 }), null),
+    ).toThrowError();
+    expect(() =>
+      service.validatePlanRevisionRules(makePlan('feature_a'), makePlan('feature_a'), 2),
+    ).toThrowError();
+    expect(() =>
+      service.validatePlanRevisionRules(
+        makePlan('feature_a'),
+        makePlan('feature_a', {
+          plan_version: 2,
+          revision_of: 999,
+        }),
+        1,
+      ),
+    ).toThrowError();
+  });
+
+  it('renders markdown fallbacks when the plan does not declare explicit work items', () => {
+    const markdown = renderPlanMarkdown(
+      'feature_a',
+      {
+        feature_id: 'feature_a',
+        plan_version: 'unknown',
+        summary: '',
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: {
+          create: [],
+          modify: [],
+          delete: [],
+        },
+        contracts: {},
+        acceptance_criteria: [],
+        gate_targets: [],
+        risk: [],
+      },
+      {
+        status: '',
+        branch: '',
+        worktree_path: '',
+        gates: {},
+      },
+    );
+
+    expect(markdown).toContain('Summary');
+    expect(markdown).toContain('Pending planner summary.');
+    expect(markdown).toContain('1. Keep execution scoped to the accepted plan artifacts.');
+    expect(markdown).toContain('Gate profile: default');
+    expect(markdown).toContain('Branch: unknown');
+  });
+
   it('GIVEN_mode_name_used_as_gate_profile_WHEN_planSubmit_THEN_canonicalizes_profile_and_preserves_mode_intent', async () => {
     const harness = await createHarness({ specs: ['feature_a'] });
     cleanups.push(harness.cleanup);
@@ -245,4 +864,67 @@ describe('PlanService', () => {
     expect(harness.stateUpdates).toHaveLength(1);
     expect(harness.stateUpdates[0].frontMatter?.gate_profile).toBe('default');
   });
+
+  it('GIVEN_accepted_plan_WHEN_planSubmit_succeeds_THEN_writes_plan_markdown_baseline', async () => {
+    const harness = await createHarness({ specs: ['feature_a'] });
+    cleanups.push(harness.cleanup);
+
+    const accepted = await harness.service.planSubmit('feature_a', makePlan('feature_a'), null);
+    expect(accepted).toMatchObject({
+      data: {
+        accepted: true,
+        plan_version: 1,
+      },
+    });
+
+    const planMarkdown = await fs.readFile(
+      path.join(harness.repoRoot, 'feature_a', 'plan.md'),
+      'utf8',
+    );
+    expect(planMarkdown).toContain('# Plan for feature_a');
+    expect(planMarkdown).toContain('Plan version: 1');
+    expect(planMarkdown).toContain('Status: building');
+    expect(planMarkdown).toContain(
+      'Future planning, build, and QA states must be reconciled against this plan.md and plan.json version 1.',
+    );
+  });
+
+  it('GIVEN_plan_revision_WHEN_planSubmit_updates_existing_plan_THEN_plan_markdown_tracks_revision_metadata', async () => {
+    const harness = await createHarness({ specs: ['feature_a'] });
+    cleanups.push(harness.cleanup);
+
+    await writePlan(harness.repoRoot, 'feature_a', makePlan('feature_a'));
+
+    const revisedPlan = makePlan('feature_a', {
+      plan_version: 2,
+      revision_of: 1,
+      contracts: {
+        openapi: 'modify',
+        events: 'modify',
+        db: 'migration',
+      },
+      gate_targets: ['full'],
+      risk: ['Migration sequencing required'],
+    });
+
+    const accepted = await harness.service.planSubmit('feature_a', revisedPlan, 1);
+    expect(accepted).toMatchObject({
+      data: {
+        accepted: true,
+        plan_version: 2,
+      },
+    });
+
+    const planMarkdown = await fs.readFile(
+      path.join(harness.repoRoot, 'feature_a', 'plan.md'),
+      'utf8',
+    );
+    expect(planMarkdown).toContain('Plan version: 2');
+    expect(planMarkdown).toContain('Revision of: 1');
+    expect(planMarkdown).toContain('OpenAPI: modify');
+    expect(planMarkdown).toContain('Events: modify');
+    expect(planMarkdown).toContain('Database: migration');
+    expect(planMarkdown).toContain('- full');
+    expect(planMarkdown).toContain('- Migration sequencing required');
+  });
 });