agentic-orchestrator 0.1.28 → 0.2.1

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

@@ -0,0 +1,3176 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type * as FsModule from '../src/core/fs.js';
+
+vi.mock('../src/core/fs.js', async () => {
+  const actual = await vi.importActual<typeof FsModule>('../src/core/fs.js');
+  return {
+    ...actual,
+    nowIso: () => '2026-01-01T00:00:00.000Z',
+  };
+});
+
+import { IntakeService } from '../src/application/services/intake-service.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { STATUS } from '../src/core/constants.js';
+
+interface TestState {
+  frontMatter: Record<string, unknown>;
+  body: string;
+}
+
+function makePort(
+  repoRoot: string,
+  options: {
+    featureId?: string;
+    frontMatter?: Record<string, unknown>;
+    allowAutoPromotion?: boolean;
+    autoPromotionMinConfidence?: 'high' | 'medium' | 'low';
+    invalidSchemas?: string[];
+    validateSchemaImpl?: (
+      schemaName: string,
+      value: unknown,
+    ) => Promise<{ valid: boolean; errors?: unknown }>;
+  } = {},
+) {
+  const featureId = options.featureId ?? 'feature_intake';
+  const state: TestState = {
+    frontMatter: {
+      feature_id: featureId,
+      version: 1,
+      status: STATUS.INTAKE,
+      intake: {
+        status: 'not_started',
+        bootstrap_manifest_version: null,
+        verified_manifest_version: null,
+        open_ambiguity_count: 0,
+        last_verified_at: null,
+        promotion_basis: null,
+      },
+      ...options.frontMatter,
+    },
+    body: 'state body',
+  };
+  let updateCount = 0;
+
+  return {
+    state,
+    getUpdateCount: () => updateCount,
+    port: {
+      featurePath: (id: string) => path.join(repoRoot, '.aop', 'features', id),
+      specPath: (id: string) => path.join(repoRoot, '.aop', 'features', id, 'spec.md'),
+      withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) =>
+        await operation(),
+      readState: async () => state,
+      updateState: async (
+        _featureId: string,
+        _expectedVersion: number | null,
+        updater: (
+          frontMatter: Record<string, unknown>,
+          body: string,
+        ) => Promise<{ frontMatter?: Record<string, unknown>; body?: string }>,
+      ) => {
+        updateCount += 1;
+        const updated = await updater(state.frontMatter, state.body);
+        state.frontMatter = updated.frontMatter ?? state.frontMatter;
+        state.body = updated.body ?? state.body;
+        return state.frontMatter;
+      },
+      validateSchema: async (schemaName: string, value: unknown) =>
+        options.validateSchemaImpl
+          ? await options.validateSchemaImpl(schemaName, value)
+          : {
+              valid: !(options.invalidSchemas ?? []).includes(schemaName),
+              errors: [{ schemaName }],
+            },
+      getPolicySnapshot: () => ({
+        planning: {
+          intake: {
+            allow_auto_promotion: options.allowAutoPromotion ?? false,
+            auto_promotion_min_confidence: options.autoPromotionMinConfidence ?? 'high',
+          },
+        },
+      }),
+    },
+  };
+}
+
+async function writeSpec(repoRoot: string, featureId: string, text: string): Promise<void> {
+  const specPath = path.join(repoRoot, '.aop', 'features', featureId, 'spec.md');
+  await fs.mkdir(path.dirname(specPath), { recursive: true });
+  await fs.writeFile(specPath, text, 'utf8');
+}
+
+async function writeQuestions(
+  repoRoot: string,
+  featureId: string,
+  items: Array<Record<string, unknown>>,
+): Promise<void> {
+  const questionsPath = path.join(repoRoot, '.aop', 'features', featureId, 'questions.json');
+  await fs.mkdir(path.dirname(questionsPath), { recursive: true });
+  await fs.writeFile(
+    questionsPath,
+    JSON.stringify(
+      {
+        version: 1,
+        feature_id: featureId,
+        items,
+      },
+      null,
+      2,
+    ),
+    'utf8',
+  );
+}
+
+async function writePlanArtifacts(
+  repoRoot: string,
+  featureId: string,
+  plan: Record<string, unknown>,
+): Promise<void> {
+  const featurePath = path.join(repoRoot, '.aop', 'features', featureId);
+  await fs.mkdir(featurePath, { recursive: true });
+  await fs.writeFile(path.join(featurePath, 'plan.json'), JSON.stringify(plan, null, 2), 'utf8');
+  await fs.writeFile(path.join(featurePath, 'plan.md'), '# stale plan\n', 'utf8');
+}
+
+describe('IntakeService', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(
+      tempDirs.map(async (dir) => await fs.rm(dir, { recursive: true, force: true })),
+    );
+  });
+
+  it('persists a bootstrap manifest, creates the default review, and keeps awaiting-input state', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      [
+        '# Goals',
+        '- `UsageBurnChart` should render the usage trend.',
+        '- Maybe allow either manual or auto promotion.',
+      ].join('\n'),
+    );
+    const { state, port } = makePort(repoRoot, {
+      frontMatter: {
+        status: STATUS.AWAITING_INPUT,
+      },
+    });
+    const service = new IntakeService(port);
+
+    const manifest = await service.ensureBootstrapManifest('feature_intake');
+    const review = JSON.parse(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'feature_intake', 'intake.review.json'),
+        'utf8',
+      ),
+    ) as Record<string, unknown>;
+
+    expect(manifest.obligations).toHaveLength(2);
+    expect(manifest.ambiguities).toHaveLength(1);
+    expect(review).toMatchObject({
+      feature_id: 'feature_intake',
+      version: 1,
+      status: 'proposed',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: null,
+    });
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'awaiting_input',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: null,
+      open_ambiguity_count: 1,
+    });
+  });
+
+  it('preserves existing verified-intake metadata while refreshing the bootstrap manifest summary', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { state, port } = makePort(repoRoot, {
+      frontMatter: {
+        intake: {
+          status: 'in_progress',
+          bootstrap_manifest_version: null,
+          verified_manifest_version: 7,
+          open_ambiguity_count: 99,
+          last_verified_at: '2025-12-31T00:00:00.000Z',
+          promotion_basis: 'human_review_confirmed',
+        },
+      },
+    });
+    const service = new IntakeService(port);
+
+    await service.ensureBootstrapManifest('feature_intake');
+
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'in_progress',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: 7,
+      last_verified_at: '2025-12-31T00:00:00.000Z',
+      promotion_basis: 'human_review_confirmed',
+    });
+  });
+
+  it('returns an existing bootstrap manifest without mutating state again', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const bootstrapPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feature_intake',
+      'spec.manifest.bootstrap.json',
+    );
+    await fs.mkdir(path.dirname(bootstrapPath), { recursive: true });
+    await fs.writeFile(
+      bootstrapPath,
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 4,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { getUpdateCount, port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    const manifest = await service.ensureBootstrapManifest('feature_intake');
+
+    expect(manifest.manifest_version).toBe(4);
+    expect(getUpdateCount()).toBe(0);
+  });
+
+  it('reuses a bootstrap manifest that appears while the feature lock is acquired', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const bootstrapPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feature_intake',
+      'spec.manifest.bootstrap.json',
+    );
+    const reviewPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feature_intake',
+      'intake.review.json',
+    );
+    const { getUpdateCount, port } = makePort(repoRoot);
+    let injected = false;
+    port.withFeatureLock = async <T>(_featureId: string, operation: () => Promise<T>) => {
+      if (!injected) {
+        injected = true;
+        await fs.mkdir(path.dirname(bootstrapPath), { recursive: true });
+        await fs.writeFile(
+          bootstrapPath,
+          JSON.stringify(
+            {
+              feature_id: 'feature_intake',
+              manifest_version: 9,
+              artifact_type: 'bootstrap',
+              generation_mode: 'bootstrap',
+              generated_at: '2026-01-01T00:00:00.000Z',
+              source_hash: 'hash',
+              obligations: [],
+              ambiguities: [],
+            },
+            null,
+            2,
+          ),
+          'utf8',
+        );
+        await fs.writeFile(
+          reviewPath,
+          JSON.stringify(
+            {
+              feature_id: 'feature_intake',
+              version: 1,
+              status: 'proposed',
+              questions_open: 0,
+              questions_resolved: 0,
+              clarification_answers: [],
+              ambiguities: [],
+              bootstrap_manifest_version: 9,
+              verified_manifest_version: null,
+              promotion_basis: null,
+              last_updated_at: '2026-01-01T00:00:00.000Z',
+            },
+            null,
+            2,
+          ),
+          'utf8',
+        );
+      }
+      return await operation();
+    };
+    const service = new IntakeService(port);
+
+    const manifest = await service.ensureBootstrapManifest('feature_intake');
+
+    expect(manifest.manifest_version).toBe(9);
+    expect(getUpdateCount()).toBe(1);
+  });
+
+  it('creates a missing intake review when a bootstrap manifest already exists', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const bootstrapPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feature_intake',
+      'spec.manifest.bootstrap.json',
+    );
+    await fs.mkdir(path.dirname(bootstrapPath), { recursive: true });
+    await fs.writeFile(
+      bootstrapPath,
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 2,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+    const review = JSON.parse(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'feature_intake', 'intake.review.json'),
+        'utf8',
+      ),
+    ) as Record<string, unknown>;
+
+    expect(result.review).toMatchObject({
+      feature_id: 'feature_intake',
+      bootstrap_manifest_version: 2,
+      status: 'proposed',
+    });
+    expect(review).toMatchObject({
+      version: 1,
+      bootstrap_manifest_version: 2,
+      status: 'proposed',
+    });
+  });
+
+  it('auto-promotes a clean bootstrap manifest into a verified manifest when policy allows it', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      '- `UsageBurnChart` must render an explicit intake summary before planning.',
+    );
+    const { state, port } = makePort(repoRoot, {
+      allowAutoPromotion: true,
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+    const verifiedManifest = JSON.parse(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'feature_intake', 'spec.manifest.verified.json'),
+        'utf8',
+      ),
+    ) as Record<string, unknown>;
+    const review = JSON.parse(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'feature_intake', 'intake.review.json'),
+        'utf8',
+      ),
+    ) as Record<string, unknown>;
+
+    expect(result.verifiedManifest).not.toBeNull();
+    expect(result.summary).toMatchObject({
+      status: 'verified',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: 1,
+      open_ambiguity_count: 0,
+      promotion_basis: 'policy_approved_auto_promotion',
+    });
+    expect(state.frontMatter.status).toBe(STATUS.PLANNING);
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'verified',
+      verified_manifest_version: 1,
+      promotion_basis: 'policy_approved_auto_promotion',
+    });
+    expect(verifiedManifest).toMatchObject({
+      artifact_type: 'verified',
+      verification_basis: 'policy_approved_auto_promotion',
+      source_bootstrap_version: 1,
+    });
+    expect(review).toMatchObject({
+      status: 'verified',
+      verified_manifest_version: 1,
+      promotion_basis: 'policy_approved_auto_promotion',
+    });
+  });
+
+  it('keeps intake in progress when auto-promotion is disabled', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      'The system should normalize intake questions into a verified manifest before planning.',
+    );
+    const { state, port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.verifiedManifest).toBeNull();
+    expect(result.summary).toMatchObject({
+      status: 'in_progress',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: null,
+    });
+    expect(state.frontMatter.status).toBe(STATUS.INTAKE);
+  });
+
+  it('keeps intake in progress when auto-promotion is allowed but obligations miss the confidence threshold', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      'The system should normalize human input before planning begins.',
+    );
+    const { state, port } = makePort(repoRoot, {
+      allowAutoPromotion: true,
+      autoPromotionMinConfidence: 'high',
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.bootstrapManifest.obligations).toHaveLength(1);
+    expect(result.bootstrapManifest.obligations[0]?.confidence).toBe('low');
+    expect(result.verifiedManifest).toBeNull();
+    expect(result.summary.status).toBe('in_progress');
+    expect(state.frontMatter.status).toBe(STATUS.INTAKE);
+  });
+
+  it('supports cross-platform intake-to-planning fixtures for TypeScript, Python, Java, and CLI specs', async () => {
+    const fixtures = [
+      {
+        featureId: 'feature_typescript',
+        spec: [
+          '## `UsageBurnChart`',
+          '- `FocusView` should render the chart and spec summary.',
+          '- Maybe expose `GET /api/focus-view` for lazy data loading.',
+        ].join('\n'),
+      },
+      {
+        featureId: 'feature_python',
+        spec: [
+          '## `JobRunner`',
+          '- `POST /jobs` should enqueue work and persist the request payload.',
+          '- Maybe allow either sync execution or queue-backed execution.',
+        ].join('\n'),
+      },
+      {
+        featureId: 'feature_java',
+        spec: [
+          '## `MergeQueueController`',
+          '- `MergeQueueService` must publish queue updates to the audit stream.',
+          '- Maybe expose `/api/merge-queue` only when queue depth exceeds one.',
+        ].join('\n'),
+      },
+      {
+        featureId: 'feature_cli',
+        spec: [
+          '## `aop intake`',
+          '- `policy.yaml` should support `planning.intake` defaults.',
+          '- Maybe allow either `--answer` text or JSON object payloads.',
+        ].join('\n'),
+      },
+    ] as const;
+
+    for (const fixture of fixtures) {
+      const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+      tempDirs.push(repoRoot);
+      await writeSpec(repoRoot, fixture.featureId, fixture.spec);
+      const { state, port } = makePort(repoRoot, {
+        featureId: fixture.featureId,
+        allowAutoPromotion: false,
+      });
+      const service = new IntakeService(port);
+
+      const intake = await service.ensureIntakeArtifacts(fixture.featureId);
+      expect(intake.bootstrapManifest.obligations.length).toBeGreaterThan(0);
+      expect(intake.bootstrapManifest.ambiguities.length).toBeGreaterThan(0);
+      await writeQuestions(repoRoot, fixture.featureId, [
+        {
+          question_id: 'q_intake_resolved',
+          status: 'answered',
+          blocking: true,
+          question_type: 'clarification',
+          role: 'planner',
+          phase: 'intake',
+          request_action: 'ask_user_input',
+          session_id: 'session-planner-1',
+          prompt: 'Clarify grouped intake ambiguities',
+          details: {
+            ambiguity_ids: intake.bootstrapManifest.ambiguities.map((ambiguity) => ambiguity.id),
+          },
+          expected_answer: { kind: 'free_text' },
+          created_at: '2026-01-01T00:00:00.000Z',
+          expires_at: '2026-01-01T01:00:00.000Z',
+          answer: 'Operator confirmed the intended baseline scope.',
+          answered_at: '2026-01-01T00:05:00.000Z',
+          answered_by: 'operator:alice',
+          resume_status: 'intake',
+          resume_phase: 'intake',
+        },
+      ]);
+
+      const promoted = await service.intakeSubmit(fixture.featureId, {
+        verified_manifest: {
+          feature_id: fixture.featureId,
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: intake.bootstrapManifest.ambiguities.map((ambiguity) => ({
+          ...ambiguity,
+          status: 'resolved',
+        })),
+        requires_user_input: false,
+      });
+
+      expect(promoted.data.feature_status).toBe(STATUS.PLANNING);
+      expect(state.frontMatter.status).toBe(STATUS.PLANNING);
+      expect(state.frontMatter.intake).toMatchObject({
+        status: 'verified',
+        verified_manifest_version: 1,
+        open_ambiguity_count: 0,
+        promotion_basis: 'questions_resolved',
+      });
+    }
+  });
+
+  it('falls back to verified-manifest summary data when intake frontmatter is stale or invalid', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 2,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'amb-1', summary: 'open', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.verified.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 3,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 2,
+          obligations: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 2,
+          status: 'verified',
+          questions_open: 0,
+          questions_resolved: 1,
+          clarification_answers: [],
+          ambiguities: [{ id: 'amb-1', summary: 'open', status: 'open' }],
+          bootstrap_manifest_version: 2,
+          verified_manifest_version: 3,
+          promotion_basis: 'human_review_confirmed',
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+      frontMatter: {
+        status: STATUS.PLANNING,
+        intake: {
+          status: 'mystery',
+        },
+      },
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.summary).toMatchObject({
+      status: 'verified',
+      bootstrap_manifest_version: 2,
+      verified_manifest_version: 3,
+      open_ambiguity_count: 1,
+      last_verified_at: '2026-01-01T00:00:00.000Z',
+      promotion_basis: 'human_review_confirmed',
+    });
+  });
+
+  it('falls back to awaiting-input summary state when no verified manifest exists yet', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+      frontMatter: {
+        status: STATUS.AWAITING_INPUT,
+        intake: {
+          status: 'mystery',
+        },
+      },
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.summary).toMatchObject({
+      status: 'awaiting_input',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: null,
+      open_ambiguity_count: 1,
+      promotion_basis: null,
+    });
+  });
+
+  it('prefers verified-manifest frontmatter provenance when the verified manifest is schema-valid', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 2,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.verified.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 3,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T01:00:00.000Z',
+          source_bootstrap_version: 2,
+          obligations: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 2,
+          status: 'verified',
+          questions_open: 0,
+          questions_resolved: 0,
+          clarification_answers: [],
+          ambiguities: [],
+          bootstrap_manifest_version: 2,
+          verified_manifest_version: 3,
+          promotion_basis: 'questions_resolved',
+          last_updated_at: '2026-01-01T01:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+      frontMatter: {
+        status: STATUS.PLANNING,
+        intake: {
+          status: 'verified',
+          verified_manifest_version: 3,
+          last_verified_at: '2026-01-01T02:00:00.000Z',
+          promotion_basis: 'human_review_confirmed',
+        },
+      },
+      validateSchemaImpl: async () => ({ valid: true }),
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.summary).toMatchObject({
+      status: 'verified',
+      verified_manifest_version: 3,
+      last_verified_at: '2026-01-01T02:00:00.000Z',
+      promotion_basis: 'human_review_confirmed',
+    });
+  });
+
+  it('ignores malformed verified manifests when ensuring intake artifacts', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [
+            {
+              obligation_id: 'OBL-001',
+              kind: 'behavior',
+              name: 'Plan tab visibility',
+              description: 'Keep the plan tab visible.',
+              source_refs: [{ line_start: 1, line_end: 1, heading: 'Overview' }],
+              verification_hint: 'required',
+              confidence: 'high',
+            },
+          ],
+          ambiguities: [
+            {
+              id: 'AMB-021',
+              summary: 'Clarify plan tab visibility.',
+              status: 'open',
+              obligation_ids: ['OBL-001'],
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.verified.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'pending_confirmation',
+          verified_at: null,
+          source_bootstrap_version: 1,
+          obligations: [
+            {
+              obligation_id: 'OBL-V01',
+              kind: 'behavior',
+              name: 'Draft plan tab visibility',
+              description: 'Draft verified manifest should not be treated as canonical.',
+              source_refs: [{ line_start: 1, line_end: 1, heading: 'Overview' }],
+              verification_hint: 'required',
+              confidence: 'high',
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 2,
+          status: 'verified',
+          questions_open: 0,
+          questions_resolved: 0,
+          clarification_answers: [],
+          ambiguities: [
+            {
+              id: 'AMB-021',
+              summary: 'Clarify plan tab visibility.',
+              status: 'open',
+              obligation_ids: ['OBL-001'],
+            },
+          ],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: 1,
+          promotion_basis: 'pending_confirmation',
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+      frontMatter: {
+        status: STATUS.PLANNING,
+        intake: {
+          status: 'verified',
+          promotion_basis: 'pending_confirmation',
+        },
+      },
+      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,
+        };
+      },
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.verifiedManifest).toBeNull();
+    expect(result.summary).toMatchObject({
+      status: 'in_progress',
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: null,
+      promotion_basis: null,
+    });
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as {
+      status: string;
+      promotion_basis: string | null;
+      verified_manifest_version: number | null;
+    };
+    expect(review.status).toBe('proposed');
+    expect(review.promotion_basis).toBeNull();
+    expect(review.verified_manifest_version).toBeNull();
+  });
+
+  it('syncs answered intake clarification questions into the intake review bridge', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [
+            {
+              obligation_id: 'OBL-125',
+              kind: 'behavior',
+              name: 'usage status',
+              description: 'Track usage status labels',
+              source_refs: [{ line_start: 1, line_end: 1, heading: 'Overview' }],
+              verification_hint: 'required',
+              confidence: 'high',
+            },
+          ],
+          ambiguities: [
+            {
+              id: 'AMB-110',
+              summary: 'Derived USD remains optional and secondary.',
+              status: 'open',
+            },
+            {
+              id: 'AMB-303',
+              summary: 'Always label reported, estimated, or unavailable.',
+              status: 'open',
+              obligation_ids: ['OBL-125'],
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_answered',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        resume_status: STATUS.INTAKE,
+        resume_phase: STATUS.INTAKE,
+        prompt: 'Clarify AMB-110 and AMB-303',
+        answer: 'AMB-110 stays optional. AMB-303 always labels status.',
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110', 'AMB-303'],
+          obligation_ids: ['OBL-125'],
+        },
+      },
+      {
+        question_id: 'q_open',
+        status: 'open',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        resume_status: STATUS.INTAKE,
+        resume_phase: STATUS.INTAKE,
+        prompt: 'Follow-up on AMB-303',
+        details: {
+          ambiguity_ids: ['AMB-303'],
+          obligation_ids: ['OBL-125'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot, {
+      frontMatter: {
+        status: STATUS.AWAITING_INPUT,
+        intake: {
+          status: 'awaiting_input',
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          open_ambiguity_count: 2,
+          last_verified_at: null,
+          promotion_basis: null,
+        },
+      },
+    });
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+
+    expect(result.review).toMatchObject({
+      status: 'awaiting_input',
+      questions_open: 1,
+      questions_resolved: 1,
+    });
+    expect(review).toMatchObject({
+      status: 'awaiting_input',
+      questions_open: 1,
+      questions_resolved: 1,
+      clarification_answers: [
+        expect.objectContaining({
+          question_id: 'q_answered',
+          ambiguity_ids: ['AMB-110', 'AMB-303'],
+          obligation_ids: ['OBL-125'],
+          answer: 'AMB-110 stays optional. AMB-303 always labels status.',
+          resolution_status: 'candidate',
+        }),
+      ],
+    });
+  });
+
+  it('preserves existing clarification answers when no questions artifact exists', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 3,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 1,
+          clarification_answers: [
+            {
+              question_id: 'q_preserved',
+              ambiguity_ids: ['AMB-110'],
+              obligation_ids: [],
+              prompt: 'Clarify token units',
+              answer: 'Use tokens only.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'candidate',
+            },
+          ],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+    expect(review).toMatchObject({
+      version: 3,
+      questions_open: 0,
+      questions_resolved: 1,
+      clarification_answers: [
+        expect.objectContaining({
+          question_id: 'q_preserved',
+          answer: 'Use tokens only.',
+          resolution_status: 'candidate',
+        }),
+      ],
+    });
+  });
+
+  it('sorts preserved clarification answers from legacy intake review artifacts', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'resolved' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 2,
+          clarification_answers: [
+            {
+              question_id: 'q_late',
+              ambiguity_ids: ['AMB-110'],
+              obligation_ids: [],
+              prompt: 'Later clarification',
+              answer: 'Use tokens only.',
+              answered_at: '2026-01-01T00:06:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'candidate',
+            },
+            {
+              question_id: 'q_early',
+              ambiguity_ids: ['AMB-110'],
+              obligation_ids: [],
+              prompt: 'Earlier clarification',
+              answer: 'Start from tokens only.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'candidate',
+            },
+          ],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'resolved' }],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as { clarification_answers: Array<{ question_id: string }> };
+    expect(review.clarification_answers.map((item) => item.question_id)).toEqual([
+      'q_early',
+      'q_late',
+    ]);
+  });
+
+  it('preserves explicit clarification resolution status values and sorts tied preserved answers by question id', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [
+            { id: 'AMB-110', summary: 'Clarify token units', status: 'open' },
+            { id: 'AMB-303', summary: 'Clarify label policy', status: 'open' },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 2,
+          clarification_answers: [
+            {
+              question_id: 'q_b',
+              ambiguity_ids: ['AMB-110'],
+              obligation_ids: [],
+              prompt: 'Clarify token units',
+              answer: 'Use tokens only.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'candidate',
+            },
+            {
+              question_id: 'q_a',
+              ambiguity_ids: ['AMB-303'],
+              obligation_ids: [],
+              prompt: 'Clarify label policy',
+              answer: 'Always label the metric.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'applied',
+            },
+          ],
+          ambiguities: [
+            { id: 'AMB-110', summary: 'Clarify token units', status: 'open' },
+            { id: 'AMB-303', summary: 'Clarify label policy', status: 'resolved' },
+          ],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as {
+      clarification_answers: Array<{ question_id: string; resolution_status: string }>;
+    };
+    expect(review.clarification_answers).toEqual([
+      expect.objectContaining({
+        question_id: 'q_a',
+        resolution_status: 'applied',
+      }),
+      expect.objectContaining({
+        question_id: 'q_b',
+        resolution_status: 'candidate',
+      }),
+    ]);
+  });
+
+  it('drops malformed non-array preserved clarification answers during intake review sync', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 1,
+          clarification_answers: {
+            question_id: 'q_bad',
+          },
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as { clarification_answers: unknown[] };
+    expect(review.clarification_answers).toEqual([]);
+  });
+
+  it('normalizes malformed legacy intake review ambiguities before rewriting the review', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [
+            {
+              id: 'AMB-021',
+              summary: 'Clarify phase-specific providers',
+              status: 'open',
+              obligation_ids: ['OBL-004'],
+            },
+            {
+              id: 'AMB-110',
+              summary: 'Clarify token units',
+              status: 'open',
+              obligation_ids: ['OBL-125'],
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 2,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 1,
+          ambiguities: [
+            {
+              id: 'AMB-021',
+              summary: 'Clarify phase-specific providers',
+              status: 'resolved',
+              obligation_ids: ['OBL-004 - planner/builder/qa model split'],
+              resolution: 'Answered via dashboard',
+            },
+            {
+              id: 'AMB-110',
+              summary: 'Clarify token units',
+              status: 'open',
+              obligation_ids: ['bad OBL-125 / OBL-126'],
+              resolution: { status: 'open' },
+            },
+          ],
+          clarification_answers: [
+            {
+              question_id: 'q_legacy',
+              ambiguity_ids: ['AMB-021 answered by operator'],
+              obligation_ids: ['OBL-004 — provider split'],
+              prompt: 'Clarify AMB-021',
+              answer: 'Use role-specific providers.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+              resolution_status: 'candidate',
+            },
+          ],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: 'questions_answered',
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as {
+      ambiguities: Array<Record<string, unknown>>;
+      clarification_answers: Array<Record<string, unknown>>;
+      promotion_basis: string | null;
+    };
+    expect(review.promotion_basis).toBeNull();
+    expect(review.ambiguities).toEqual([
+      {
+        id: 'AMB-021',
+        summary: 'Clarify phase-specific providers',
+        status: 'resolved',
+        obligation_ids: ['OBL-004'],
+      },
+      {
+        id: 'AMB-110',
+        summary: 'Clarify token units',
+        status: 'open',
+        obligation_ids: ['OBL-125', 'OBL-126'],
+      },
+    ]);
+    expect(review.clarification_answers).toEqual([
+      expect.objectContaining({
+        question_id: 'q_legacy',
+        ambiguity_ids: ['AMB-021'],
+        obligation_ids: ['OBL-004'],
+      }),
+    ]);
+    expect(review.ambiguities[0]).not.toHaveProperty('resolution');
+    expect(review.ambiguities[1]).not.toHaveProperty('resolution');
+  });
+
+  it('no-ops syncReviewFromQuestions when no bootstrap manifest exists yet', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    await expect(fs.access(path.join(featureDir, 'intake.review.json'))).rejects.toBeDefined();
+  });
+
+  it('marks synced clarification answers as applied and sorts ties by question id', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [
+            { id: 'AMB-110', summary: 'Clarify token units', status: 'open' },
+            { id: 'AMB-303', summary: 'Clarify label policy', status: 'open' },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 0,
+          clarification_answers: [],
+          ambiguities: [
+            { id: 'AMB-110', summary: 'Clarify token units', status: 'resolved' },
+            { id: 'AMB-303', summary: 'Clarify label policy', status: 'resolved' },
+          ],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_b',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify AMB-303',
+        answer: 'Always label the status.',
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-303'],
+        },
+      },
+      {
+        question_id: 'q_a',
+        status: 'answered',
+        question_type: 'clarification',
+        resume_status: STATUS.INTAKE,
+        prompt: 'Clarify AMB-110',
+        answer: 'Use tokens only.',
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+    expect(review).toMatchObject({
+      questions_resolved: 2,
+      clarification_answers: [
+        expect.objectContaining({
+          question_id: 'q_a',
+          resolution_status: 'applied',
+        }),
+        expect.objectContaining({
+          question_id: 'q_b',
+          resolution_status: 'applied',
+        }),
+      ],
+    });
+  });
+
+  it('drops malformed clarification answers that are missing required fields during review healing', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [{ obligation_id: 'OBL-001', kind: 'behavior', name: 'one' }],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 0,
+          clarification_answers: [
+            {
+              question_id: 'q_bad',
+              ambiguity_ids: ['AMB-110'],
+              answer: 'Missing prompt should drop this record.',
+              answered_at: '2026-01-01T00:05:00.000Z',
+              answered_by: 'dashboard:triage',
+            },
+            {
+              question_id: 'q_good',
+              ambiguity_ids: ['AMB-110'],
+              obligation_ids: ['OBL-001'],
+              prompt: 'Clarify token units',
+              answer: 'Use tokens only.',
+              answered_at: '2026-01-01T00:06:00.000Z',
+              answered_by: 'dashboard:triage',
+            },
+          ],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    const result = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(result.review.clarification_answers).toEqual([
+      expect.objectContaining({
+        question_id: 'q_good',
+        resolution_status: 'candidate',
+      }),
+    ]);
+  });
+
+  it('sorts synced clarification answers by answered_at before question_id', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_late',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify token units later',
+        answer: 'Use tokens only.',
+        answered_at: '2026-01-01T00:06:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+      {
+        question_id: 'q_early',
+        status: 'answered',
+        question_type: 'clarification',
+        resume_status: STATUS.INTAKE,
+        prompt: 'Clarify token units first',
+        answer: 'Start from tokens only.',
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as { clarification_answers: Array<{ question_id: string }> };
+    expect(review.clarification_answers.map((item) => item.question_id)).toEqual([
+      'q_early',
+      'q_late',
+    ]);
+  });
+
+  it('keeps synced review status verified when a verified manifest already exists', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.verified.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 2,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:10:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await fs.writeFile(
+      path.join(featureDir, 'intake.review.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 1,
+          status: 'proposed',
+          questions_open: 0,
+          questions_resolved: 0,
+          clarification_answers: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: 2,
+          promotion_basis: 'human_review_confirmed',
+          last_updated_at: '2026-01-01T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_open',
+        status: 'open',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify token units',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+    expect(review).toMatchObject({
+      status: 'verified',
+      verified_manifest_version: 2,
+      promotion_basis: 'human_review_confirmed',
+      questions_open: 1,
+    });
+  });
+
+  it('ignores malformed answered clarification fields while preserving valid clarification answers', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_bad',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: '   ',
+        answer: { value: 'tokens only' },
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110', '   '],
+          obligation_ids: ['   '],
+        },
+      },
+      {
+        question_id: 'q_good',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify token units',
+        answer: 'Use tokens only.',
+        answered_at: '2026-01-01T00:06:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+    expect(review).toMatchObject({
+      questions_resolved: 1,
+      clarification_answers: [
+        expect.objectContaining({
+          question_id: 'q_good',
+        }),
+      ],
+    });
+  });
+
+  it('ignores malformed question entries that do not contain a usable status', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [{ id: 'AMB-110', summary: 'Clarify token units', status: 'open' }],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      null as unknown as Record<string, unknown>,
+      {
+        question_id: 'q_missing_status',
+        status: '   ',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Ignored because the status is blank',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+      {
+        question_id: 'q_good',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify token units',
+        answer: 'Use tokens only.',
+        answered_at: '2026-01-01T00:06:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.syncReviewFromQuestions('feature_intake');
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as Record<string, unknown>;
+    expect(review).toMatchObject({
+      questions_resolved: 1,
+      clarification_answers: [expect.objectContaining({ question_id: 'q_good' })],
+    });
+  });
+
+  it('normalizes non-array and duplicate submitted ambiguities before persisting intake review', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '# Overview');
+    const featureDir = path.join(repoRoot, '.aop', 'features', 'feature_intake');
+    await fs.mkdir(featureDir, { recursive: true });
+    await fs.writeFile(
+      path.join(featureDir, 'spec.manifest.bootstrap.json'),
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'bootstrap',
+          generation_mode: 'bootstrap',
+          generated_at: '2026-01-01T00:00:00.000Z',
+          source_hash: 'hash',
+          obligations: [],
+          ambiguities: [
+            {
+              id: 'AMB-110',
+              summary: 'Clarify token units',
+              status: 'open',
+              obligation_ids: ['OBL-110'],
+            },
+            {
+              id: 'AMB-303',
+              summary: 'Clarify status labels',
+              status: 'open',
+              obligation_ids: ['OBL-303'],
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_110',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify AMB-110',
+        answer: 'Use tokens only.',
+        answered_at: '2026-01-01T00:05:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-110'],
+        },
+      },
+      {
+        question_id: 'q_303',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify AMB-303',
+        answer: 'Always label the status.',
+        answered_at: '2026-01-01T00:06:00.000Z',
+        answered_by: 'dashboard:triage',
+        details: {
+          ambiguity_ids: ['AMB-303'],
+        },
+      },
+    ]);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'questions_resolved',
+        verified_at: '2026-01-01T00:10:00.000Z',
+        source_bootstrap_version: 1,
+        obligations: [],
+      },
+      open_ambiguities: null,
+      resolved_ambiguities: [
+        {
+          ambiguity_id: 'AMB-303',
+          summary: 'Clarify status labels',
+          obligation_ids: ['OBL-303 / labels'],
+          resolution: 'Answered',
+        },
+        {
+          ambiguity_id: 'AMB-110',
+          summary: 'Clarify token units',
+          obligation_ids: ['OBL-110 / telemetry'],
+        },
+        {
+          ambiguity_id: 'AMB-303',
+          summary: 'Duplicate ambiguity entry',
+          obligation_ids: ['OBL-303 again'],
+        },
+      ],
+      requires_user_input: false,
+    } as unknown as Parameters<IntakeService['intakeSubmit']>[1]);
+
+    const review = JSON.parse(
+      await fs.readFile(path.join(featureDir, 'intake.review.json'), 'utf8'),
+    ) as { ambiguities: Array<Record<string, unknown>> };
+    expect(review.ambiguities).toEqual([
+      {
+        id: 'AMB-110',
+        summary: 'Clarify token units',
+        status: 'resolved',
+        obligation_ids: ['OBL-110'],
+      },
+      {
+        id: 'AMB-303',
+        summary: 'Clarify status labels',
+        status: 'resolved',
+        obligation_ids: ['OBL-303'],
+      },
+    ]);
+  });
+
+  it('accepts questions_resolved when answered evidence uses a singular ambiguity_id field', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { state, port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+    const ambiguity = intake.bootstrapManifest.ambiguities[0];
+    expect(ambiguity).toBeDefined();
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_intake_answered',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify the ambiguity',
+        details: { ambiguity_id: ambiguity?.id },
+        answer: 'Confirmed.',
+        answered_at: '2026-01-01T00:02:00.000Z',
+        answered_by: 'operator:alice',
+      },
+    ]);
+
+    const promoted = await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'questions_resolved',
+        verified_at: '2026-01-01T00:00:00.000Z',
+        source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+        obligations: intake.bootstrapManifest.obligations,
+      },
+      open_ambiguities: [],
+      resolved_ambiguities: [{ ...ambiguity, status: 'resolved' }],
+      requires_user_input: false,
+    });
+
+    expect(promoted.data.feature_status).toBe(STATUS.PLANNING);
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'verified',
+      promotion_basis: 'questions_resolved',
+    });
+  });
+
+  it('rejects questions_resolved evidence when the answered intake question predates bootstrap generation', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_intake_answered',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify the ambiguity',
+        details: { ambiguity_ids: intake.bootstrapManifest.ambiguities.map((item) => item.id) },
+        answer: 'Confirmed.',
+        answered_at: '2025-12-31T23:59:59.000Z',
+        answered_by: 'operator:alice',
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: intake.bootstrapManifest.ambiguities.map((ambiguity) => ({
+          ...ambiguity,
+          status: 'resolved',
+        })),
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'verified manifest requires persisted answered intake-question evidence',
+        },
+      },
+    });
+  });
+
+  it('rejects intake promotion when open ambiguities remain even if requires_user_input is false', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    await service.ensureIntakeArtifacts('feature_intake');
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [{ id: 'AMB-001', summary: 'still open', status: 'open' }],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message:
+            'verified manifest cannot be promoted while intake ambiguities remain unresolved',
+        },
+      },
+    });
+  });
+
+  it('rejects structured_spec verification when inferred ambiguities would be resolved by intake submission', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'structured_spec',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: intake.bootstrapManifest.ambiguities.map((ambiguity) => ({
+          ...ambiguity,
+          status: 'resolved',
+        })),
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'structured_spec verification cannot resolve inferred intake ambiguities',
+        },
+      },
+    });
+  });
+
+  it('accepts structured_spec verification when bootstrap intake has no inferred ambiguities', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { state, port } = makePort(repoRoot, {
+      allowAutoPromotion: false,
+    });
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+
+    expect(intake.bootstrapManifest.ambiguities).toHaveLength(0);
+
+    const promoted = await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'structured_spec',
+        verified_at: '2026-01-01T00:00:00.000Z',
+        source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+        obligations: intake.bootstrapManifest.obligations,
+      },
+      open_ambiguities: [],
+      resolved_ambiguities: [],
+      requires_user_input: false,
+    });
+
+    expect(promoted.data.feature_status).toBe(STATUS.PLANNING);
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'verified',
+      promotion_basis: 'structured_spec',
+    });
+  });
+
+  it('rejects questions_resolved when answered evidence points at different ambiguity ids', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+    const resolvedAmbiguity = intake.bootstrapManifest.ambiguities[0];
+    expect(resolvedAmbiguity).toBeDefined();
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_mismatch',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify a different ambiguity',
+        details: {
+          ambiguity_ids: ['AMB-999'],
+        },
+        answer: 'Confirmed.',
+        answered_at: '2026-01-01T00:02:00.000Z',
+        answered_by: 'operator:alice',
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [{ ...resolvedAmbiguity, status: 'resolved' }],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'resolved intake ambiguities must map to answered intake questions',
+        },
+      },
+    });
+  });
+
+  it('rejects intake promotion when verification still needs user input or open ambiguities remain', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const reviewPath = path.join(
+      repoRoot,
+      '.aop',
+      'features',
+      'feature_intake',
+      'intake.review.json',
+    );
+    await fs.mkdir(path.dirname(reviewPath), { recursive: true });
+    await fs.writeFile(
+      reviewPath,
+      JSON.stringify(
+        {
+          feature_id: 'feature_intake',
+          version: 4,
+          status: 'awaiting_input',
+          questions_open: 1,
+          questions_resolved: 0,
+          clarification_answers: [],
+          ambiguities: [],
+          bootstrap_manifest_version: 1,
+          verified_manifest_version: null,
+          promotion_basis: null,
+          last_updated_at: '2025-12-31T00:00:00.000Z',
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+    const { state, port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [{ id: 'amb-1', summary: 'still open', status: 'open' }],
+        resolved_ambiguities: [{ id: 'amb-2', summary: 'resolved', status: 'resolved' }],
+        requires_user_input: true,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+        },
+      },
+    });
+    const review = JSON.parse(await fs.readFile(reviewPath, 'utf8')) as Record<string, unknown>;
+
+    expect(review).toMatchObject({
+      version: 4,
+      status: 'awaiting_input',
+      questions_open: 1,
+      questions_resolved: 0,
+      promotion_basis: null,
+    });
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'in_progress',
+      open_ambiguity_count: 0,
+      promotion_basis: null,
+    });
+  });
+
+  it('rejects questions_resolved promotion without answered intake-question evidence', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: intake.bootstrapManifest.ambiguities.map((ambiguity) => ({
+          ...ambiguity,
+          status: 'resolved',
+        })),
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          details: expect.objectContaining({
+            verification_basis: 'questions_resolved',
+          }),
+        },
+      },
+    });
+  });
+
+  it('rejects questions_resolved promotion when an answered intake question is missing actor metadata', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      ['# Goals', '- Maybe allow either manual or auto promotion.'].join('\n'),
+    );
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_missing_actor',
+        status: 'answered',
+        question_type: 'clarification',
+        phase: STATUS.INTAKE,
+        prompt: 'Clarify the ambiguity',
+        details: { ambiguity_ids: intake.bootstrapManifest.ambiguities.map((item) => item.id) },
+        answer: 'Confirmed.',
+        answered_at: '2026-01-01T00:02:00.000Z',
+        answered_by: null,
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+          obligations: intake.bootstrapManifest.obligations,
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: intake.bootstrapManifest.ambiguities.map((ambiguity) => ({
+          ...ambiguity,
+          status: 'resolved',
+        })),
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'verified manifest requires persisted answered intake-question evidence',
+        },
+      },
+    });
+  });
+
+  it('rejects human_review_confirmed without explicit manifest-review confirmation evidence', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    await service.ensureIntakeArtifacts('feature_intake');
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_intake_answered',
+        status: 'answered',
+        blocking: true,
+        question_type: 'clarification',
+        role: 'planner',
+        phase: 'intake',
+        request_action: 'ask_user_input',
+        session_id: 'session-planner-1',
+        prompt: 'Confirm the chart target',
+        details: { ambiguity_id: 'AMB-001' },
+        expected_answer: { kind: 'free_text' },
+        created_at: '2026-01-01T00:00:00.000Z',
+        expires_at: '2026-01-01T01:00:00.000Z',
+        answer: 'Use the existing chart surface.',
+        answered_at: '2026-01-01T00:02:00.000Z',
+        answered_by: 'operator:alice',
+        resume_status: 'intake',
+        resume_phase: 'intake',
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message:
+            'human_review_confirmed requires an explicit answered manifest-review confirmation question',
+        },
+      },
+    });
+  });
+
+  it('rejects verified-manifest promotion while an intake question is still open', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    await service.ensureIntakeArtifacts('feature_intake');
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_intake_open',
+        status: 'open',
+        blocking: true,
+        question_type: 'clarification',
+        role: 'planner',
+        phase: 'intake',
+        request_action: 'ask_user_input',
+        session_id: 'session-planner-1',
+        prompt: 'Need operator guidance',
+        details: { ambiguity_id: 'AMB-001' },
+        expected_answer: { kind: 'free_text' },
+        created_at: '2026-01-01T00:00:00.000Z',
+        expires_at: '2026-01-01T01:00:00.000Z',
+        answer: null,
+        answered_at: null,
+        answered_by: null,
+        resume_status: 'intake',
+        resume_phase: 'intake',
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [{ id: 'AMB-001', summary: 'resolved', status: 'resolved' }],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'verified manifest cannot be promoted while intake questions remain open',
+        },
+      },
+    });
+  });
+
+  it('rejects questions_resolved when no resolved ambiguities are supplied even with answered questions', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    await service.ensureIntakeArtifacts('feature_intake');
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_intake_answered',
+        status: 'answered',
+        blocking: true,
+        question_type: 'clarification',
+        role: 'planner',
+        phase: 'intake',
+        request_action: 'ask_user_input',
+        session_id: 'session-planner-1',
+        prompt: 'Need operator guidance',
+        details: { ambiguity_id: 'AMB-001' },
+        expected_answer: { kind: 'free_text' },
+        created_at: '2026-01-01T00:00:00.000Z',
+        expires_at: '2026-01-01T01:00:00.000Z',
+        answer: 'Confirmed.',
+        answered_at: '2026-01-01T00:02:00.000Z',
+        answered_by: 'operator:alice',
+        resume_status: 'intake',
+        resume_phase: 'intake',
+      },
+    ]);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'questions_resolved verification requires at least one resolved ambiguity',
+        },
+      },
+    });
+  });
+
+  it('accepts human_review_confirmed when an explicit manifest-review confirmation answer exists', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { state, port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+    await service.ensureIntakeArtifacts('feature_intake');
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_manifest_confirm',
+        status: 'answered',
+        blocking: true,
+        question_type: 'clarification',
+        role: 'planner',
+        phase: 'intake',
+        request_action: 'ask_user_input',
+        session_id: 'session-planner-1',
+        prompt: 'Confirm the final verified manifest',
+        details: {
+          confirmation_kind: 'manifest_review',
+          review_target: 'verified_manifest',
+        },
+        expected_answer: { kind: 'free_text' },
+        created_at: '2026-01-01T00:00:00.000Z',
+        expires_at: '2026-01-01T01:00:00.000Z',
+        answer: 'Confirmed.',
+        answered_at: '2026-01-01T00:03:00.000Z',
+        answered_by: 'operator:alice',
+        resume_status: 'intake',
+        resume_phase: 'intake',
+      },
+    ]);
+
+    const promoted = await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'human_review_confirmed',
+        verified_at: '2026-01-01T00:00:00.000Z',
+        source_bootstrap_version: 1,
+        obligations: [],
+      },
+      open_ambiguities: [],
+      resolved_ambiguities: [],
+      requires_user_input: false,
+    });
+
+    expect(promoted.data.feature_status).toBe(STATUS.PLANNING);
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'verified',
+      promotion_basis: 'human_review_confirmed',
+    });
+  });
+
+  it('normalizes draft reviewed manifests and legacy manifest-review confirmation questions', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { state, port } = makePort(repoRoot, {
+      validateSchemaImpl: async (schemaName, value) => {
+        if (schemaName !== 'spec.manifest.verified.schema.json') {
+          return { valid: true };
+        }
+        const record = value as Record<string, unknown>;
+        const obligations = Array.isArray(record.obligations) ? record.obligations : [];
+        const sourceRefsValid = obligations.every((obligation) => {
+          const obligationRecord = obligation as Record<string, unknown>;
+          const sourceRefs = obligationRecord.source_refs;
+          return (
+            Array.isArray(sourceRefs) &&
+            sourceRefs.every((sourceRef) => {
+              const sourceRefRecord = sourceRef as Record<string, unknown>;
+              return (
+                typeof sourceRefRecord.line_start === 'number' &&
+                typeof sourceRefRecord.line_end === 'number' &&
+                (typeof sourceRefRecord.heading === 'string' || sourceRefRecord.heading === null)
+              );
+            })
+          );
+        });
+        return {
+          valid:
+            record.artifact_type === 'verified' &&
+            record.verification_basis === 'human_review_confirmed' &&
+            typeof record.verified_at === 'string' &&
+            obligations.every((obligation) => {
+              const obligationRecord = obligation as Record<string, unknown>;
+              return (
+                typeof obligationRecord.obligation_id === 'string' &&
+                /^OBL-\d{3,}$/.test(obligationRecord.obligation_id) &&
+                [
+                  'artifact',
+                  'endpoint',
+                  'workflow',
+                  'behavior',
+                  'integration',
+                  'contract',
+                  'verification',
+                ].includes(String(obligationRecord.kind ?? '')) &&
+                !Object.prototype.hasOwnProperty.call(obligationRecord, 'added_by')
+              );
+            }) &&
+            sourceRefsValid,
+        };
+      },
+    });
+    const service = new IntakeService(port);
+    const intake = await service.ensureIntakeArtifacts('feature_intake');
+    await writeQuestions(repoRoot, 'feature_intake', [
+      {
+        question_id: 'q_manifest_review',
+        status: 'answered',
+        blocking: true,
+        question_type: 'clarification',
+        role: 'planner',
+        phase: 'intake',
+        request_action: 'ask_user_input',
+        session_id: 'session-planner-1',
+        prompt:
+          'Please review spec.manifest.verified.json and confirm whether the obligation set is complete.',
+        details: {
+          ambiguity_id: 'AMB-MANIFEST-REVIEW',
+          obligation_ids: ['OBL-V01', 'OBL-V02', 'OBL-V03'],
+        },
+        expected_answer: { kind: 'free_text' },
+        created_at: '2026-01-01T00:00:00.000Z',
+        expires_at: '2026-01-01T01:00:00.000Z',
+        answer: 'Confirmed. Add the operator follow-up obligation.',
+        answered_at: '2026-01-01T00:03:00.000Z',
+        answered_by: 'operator:alice',
+        resume_status: 'intake',
+        resume_phase: 'intake',
+      },
+    ]);
+
+    const promoted = await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'human_review_confirmed',
+        verified_at: '2026-01-01T00:04:00.000Z',
+        source_bootstrap_version: intake.bootstrapManifest.manifest_version,
+        obligations: [
+          {
+            obligation_id: 'OBL-V01',
+            kind: 'behavior',
+            name: 'Primary plan workspace',
+            description: 'Render the plan workspace.',
+            source_refs: [{ line_start: 1, line_end: 1, heading: null }],
+            verification_hint: 'required',
+            confidence: 'high',
+          },
+          {
+            obligation_id: 'OBL-V02',
+            kind: 'constraint',
+            name: 'Plan tab visibility during intake',
+            description: 'The Plan tab must stay visible during intake.',
+            source_refs: [{ line_start: 2, line_end: 2, heading: null }],
+            verification_hint: 'required',
+            confidence: 'high',
+          },
+          {
+            obligation_id: 'OBL-V03',
+            kind: 'behavior',
+            name: 'Operator review follow-up',
+            description: 'Add the operator-requested follow-up obligation.',
+            source_refs: [],
+            verification_hint: 'required',
+            confidence: 'high',
+            added_by: 'operator_review',
+          },
+        ],
+      },
+      open_ambiguities: [],
+      resolved_ambiguities: [],
+      requires_user_input: false,
+    } as unknown as Parameters<IntakeService['intakeSubmit']>[1]);
+
+    const persisted = JSON.parse(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'feature_intake', 'spec.manifest.verified.json'),
+        'utf8',
+      ),
+    ) as { obligations: Array<Record<string, unknown>> };
+
+    expect(promoted.data.feature_status).toBe(STATUS.PLANNING);
+    expect(persisted.obligations).toEqual([
+      {
+        obligation_id: 'OBL-001',
+        kind: 'behavior',
+        name: 'Primary plan workspace',
+        description: 'Render the plan workspace.',
+        source_refs: [{ line_start: 1, line_end: 1, heading: null }],
+        verification_hint: 'required',
+        confidence: 'high',
+      },
+      {
+        obligation_id: 'OBL-002',
+        kind: 'contract',
+        name: 'Plan tab visibility during intake',
+        description: 'The Plan tab must stay visible during intake.',
+        source_refs: [{ line_start: 2, line_end: 2, heading: null }],
+        verification_hint: 'required',
+        confidence: 'high',
+      },
+      {
+        obligation_id: 'OBL-003',
+        kind: 'behavior',
+        name: 'Operator review follow-up',
+        description: 'Add the operator-requested follow-up obligation.',
+        source_refs: [],
+        verification_hint: 'required',
+        confidence: 'high',
+      },
+    ]);
+    expect(state.frontMatter.intake).toMatchObject({
+      status: 'verified',
+      promotion_basis: 'human_review_confirmed',
+    });
+  });
+
+  it('clears stale accepted plan artifacts and resets the plan gate when intake is verified', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    await writePlanArtifacts(repoRoot, 'feature_intake', {
+      feature_id: 'feature_intake',
+      plan_version: 1,
+      summary: 'stale plan',
+      files: {
+        create: [],
+        modify: ['apps/control-plane/src/stale.ts'],
+        delete: [],
+      },
+      acceptance_criteria: [],
+      gate_profile: 'default',
+      plan_trace: [
+        {
+          obligation_id: 'OBL-STALE',
+          disposition: 'in_scope',
+          planned_paths: ['apps/control-plane/src/stale.ts'],
+          notes: 'stale contract',
+        },
+      ],
+    });
+    const { state, port } = makePort(repoRoot, {
+      allowAutoPromotion: true,
+      frontMatter: {
+        status: STATUS.INTAKE,
+        gates: {
+          plan: 'pass',
+          fast: 'pass',
+          full: 'pass',
+        },
+      },
+    });
+    const service = new IntakeService(port);
+
+    await service.intakeSubmit('feature_intake', {
+      verified_manifest: {
+        feature_id: 'feature_intake',
+        manifest_version: 1,
+        artifact_type: 'verified',
+        verification_basis: 'policy_approved_auto_promotion',
+        verified_at: '2026-01-01T00:00:00.000Z',
+        source_bootstrap_version: 1,
+        obligations: [],
+      },
+      open_ambiguities: [],
+      resolved_ambiguities: [],
+      requires_user_input: false,
+    });
+
+    await expect(
+      fs.access(path.join(repoRoot, '.aop', 'features', 'feature_intake', 'plan.json')),
+    ).rejects.toThrow();
+    await expect(
+      fs.access(path.join(repoRoot, '.aop', 'features', 'feature_intake', 'plan.md')),
+    ).rejects.toThrow();
+    expect(state.frontMatter.status).toBe(STATUS.PLANNING);
+    expect((state.frontMatter.gates as Record<string, unknown>).plan).toBe('na');
+  });
+
+  it('rejects policy-approved auto-promotion when the bootstrap manifest does not satisfy promotion policy', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(
+      repoRoot,
+      'feature_intake',
+      'The system should normalize human input before planning begins.',
+    );
+    const { port } = makePort(repoRoot, {
+      allowAutoPromotion: true,
+      autoPromotionMinConfidence: 'high',
+    });
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'policy_approved_auto_promotion',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [
+            {
+              obligation_id: 'OBL-001',
+              kind: 'behavior',
+              name: 'normalize human input before planning begins',
+              description: 'The system should normalize human input before planning begins.',
+              source_refs: [{ line_start: 1, line_end: 1, heading: null }],
+              verification_hint: 'required',
+              confidence: 'low',
+            },
+          ],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+        },
+      },
+    });
+  });
+
+  it('rejects intake submissions when the verified manifest points at a stale bootstrap manifest version', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 99,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+        },
+      },
+    });
+  });
+
+  it('rejects intake submissions without a verified manifest payload', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      } as unknown as Parameters<IntakeService['intakeSubmit']>[1]),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_ARGUMENT,
+        },
+      },
+    });
+  });
+
+  it('rejects intake submissions when the verified manifest belongs to a different feature', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot);
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'other_feature',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_ARGUMENT,
+        },
+      },
+    });
+  });
+
+  it('surfaces verified-manifest schema failures as intake submission invalid', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot, {
+      validateSchemaImpl: async (schemaName) =>
+        schemaName === 'spec.manifest.verified.schema.json'
+          ? {
+              valid: false,
+              errors: [{ keyword: 'pattern', instancePath: '/obligations/0/obligation_id' }],
+            }
+          : { valid: true },
+    });
+    const service = new IntakeService(port);
+
+    await expect(
+      service.intakeSubmit('feature_intake', {
+        verified_manifest: {
+          feature_id: 'feature_intake',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'human_review_confirmed',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          message: 'verified manifest failed schema validation',
+        },
+      },
+    });
+  });
+
+  it('fails with a structured validation error when bootstrap manifest validation fails', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-intake-service-'));
+    tempDirs.push(repoRoot);
+    await writeSpec(repoRoot, 'feature_intake', '- `UsageBurnChart` should render.');
+    const { port } = makePort(repoRoot, {
+      invalidSchemas: ['spec.manifest.bootstrap.schema.json'],
+    });
+    const service = new IntakeService(port);
+
+    await expect(service.ensureBootstrapManifest('feature_intake')).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.STATE_VALIDATION_FAILED,
+        },
+      },
+    });
+  });
+});