agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/planning-wave-executor.spec.ts

@@ -1,8 +1,13 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { STATUS, TOOLS } from '../src/core/constants.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { PlanningWaveExecutor } from '../src/supervisor/planning-wave-executor.js';
 
+type ToolCall = [role: string, toolName: string, args?: Record<string, unknown>];
+
 function basePlan(featureId: string) {
   return {
     feature_id: featureId,
@@ -26,9 +31,22 @@ function basePlan(featureId: string) {
   };
 }
 
+function readLoggedNote(toolCaller: {
+  callTool: ReturnType<typeof vi.fn>;
+}): Record<string, unknown> {
+  const logCall = toolCaller.callTool.mock.calls.find(
+    (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+  ) as ToolCall | undefined;
+  expect(logCall).toBeDefined();
+  return JSON.parse(String(logCall?.[2]?.note ?? '{}')) as Record<string, unknown>;
+}
+
 describe('PlanningWaveExecutor post-QA reconciliation', () => {
   it('GIVEN_worker_emits_plan_submission_WHEN_running_planning_wave_THEN_skips_fallback_plan_generation', async () => {
     const featureId = 'feature_worker_plan';
+    const plannerSessionSync = {
+      syncPlannerSessions: vi.fn(async () => undefined),
+    };
     const toolCaller = {
       callTool: vi.fn(async (_role: string, toolName: string) => {
         if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
@@ -58,19 +76,33 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
         patchApplied: false,
         noteLogged: true,
         requestHandled: false,
+        questionRequested: false,
+        contextStall: false,
+        contextRequestCount: 0,
+        lastContextRequestAt: null,
+        lastContextRequestRole: null,
+        invalidOutput: false,
+        noProgress: false,
+        outputTypes: [],
+        rawOutputs: [],
         priorityOrder: [],
         toolResults: [],
+        errorCode: null,
+        interactiveOutcome: null,
+        checkpoint: null,
       })),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
       planGenerator: planGenerator as never,
+      plannerSessionSync,
       workerDecisionRunner: workerDecisionRunner as never,
     });
 
     await executor.run([featureId]);
 
+    expect(plannerSessionSync.syncPlannerSessions).toHaveBeenCalledWith([featureId]);
     expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
       expect.objectContaining({
         role: 'planner',
@@ -84,6 +116,281 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(planSubmitCalls).toHaveLength(0);
   });
 
+  it('uses the verified manifest instead of raw spec prose for post-QA reconciliation edge-case guidance', async () => {
+    const featureId = 'feature_verified_manifest_reconciliation';
+    const plannerSessionSync = {
+      syncPlannerSessions: vi.fn(async () => undefined),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Handle missing inputs and timeout retries under concurrent requests.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                plan_trace: [
+                  {
+                    obligation_id: 'OBL-001',
+                    disposition: 'in_scope',
+                    planned_paths: ['apps/control-plane/src/file.ts'],
+                    notes: 'mapped',
+                  },
+                ],
+              },
+              intake: {
+                verified_manifest: {
+                  obligations: [
+                    {
+                      obligation_id: 'OBL-001',
+                      kind: 'endpoint',
+                      verification_hint: 'required',
+                    },
+                  ],
+                },
+              },
+              qa_test_index: {
+                summary: {
+                  pending: 0,
+                  failed: 0,
+                  running: 0,
+                },
+              },
+              latest_evidence: {
+                overall: 'pass',
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        throw new Error(`unexpected_tool:${toolName}:${String(args?.feature_id ?? '')}`);
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      plannerSessionSync,
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    expect(plannerSessionSync.syncPlannerSessions).toHaveBeenCalledWith([featureId]);
+    const updateCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.PLAN_UPDATE);
+    expect(updateCall).toBeTruthy();
+    const updatedPlan = updateCall?.[2].plan_json as Record<string, unknown>;
+    const riskItems = Array.isArray(updatedPlan.risk) ? updatedPlan.risk : [];
+    expect(riskItems).toEqual(
+      expect.arrayContaining([
+        'Verified endpoint and contract obligations cover payload validation and negative-path handling.',
+        'Required verified-manifest obligations have explicit verification coverage.',
+      ]),
+    );
+    expect(riskItems).not.toEqual(
+      expect.arrayContaining([
+        'Edge-case: timeout, retry, and latency behavior is covered.',
+        'Edge-case: concurrent access and race-condition behavior are covered.',
+      ]),
+    );
+  });
+
+  it('GIVEN_blocked_feature_with_accepted_plan_WHEN_running_planning_wave_THEN_skips_regular_planner_turn', async () => {
+    const featureId = 'feature_blocked_with_plan';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                },
+              },
+              plan: basePlan(featureId),
+            },
+          };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })),
+    };
+    const workerDecisionRunner = {
+      execute: vi.fn(),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run([featureId]);
+
+    expect(workerDecisionRunner.execute).not.toHaveBeenCalled();
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_blocked_feature_in_intake_with_existing_plan_WHEN_running_planning_wave_THEN_still_executes_planner_intake_turn', async () => {
+    const featureId = 'feature_blocked_intake_with_plan';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              intake: {
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                verified_manifest: null,
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-001',
+                      status: 'open',
+                      summary: 'Clarify the intake contract before planning.',
+                      obligation_ids: ['OBL-001'],
+                    },
+                  ],
+                },
+              },
+              plan: basePlan(featureId),
+            },
+          };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })),
+    };
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: false,
+        intakeSubmission: false,
+        patchApplied: false,
+        noteLogged: false,
+        requestHandled: false,
+        questionRequested: true,
+        contextStall: false,
+        contextRequestCount: 0,
+        lastContextRequestAt: null,
+        lastContextRequestRole: null,
+        invalidOutput: false,
+        errorCode: null,
+        noProgress: false,
+        outputTypes: ['REQUEST'],
+        rawOutputs: [],
+        priorityOrder: [],
+        toolResults: [],
+        interactiveOutcome: null,
+        checkpoint: null,
+      })),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run([featureId]);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: 'planner',
+        featureId,
+      }),
+    );
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_legacy_planning_state_with_accepted_plan_WHEN_running_planning_wave_THEN_normalizes_state_and_skips_planner', async () => {
+    const featureId = 'feature_legacy_planning_with_plan';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  version: 6,
+                  status: STATUS.PLANNING,
+                  gates: {
+                    plan: 'na',
+                  },
+                },
+              },
+              plan: basePlan(featureId),
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+          return { ok: true, data: { updated: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })),
+    };
+    const workerDecisionRunner = {
+      execute: vi.fn(),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run([featureId]);
+
+    expect(workerDecisionRunner.execute).not.toHaveBeenCalled();
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+    expect(toolCaller.callTool).toHaveBeenCalledWith('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
+      feature_id: featureId,
+      expected_version: 6,
+      patch: {
+        front_matter: {
+          status: STATUS.BUILDING,
+          gates: {
+            plan: 'pass',
+          },
+        },
+      },
+    });
+  });
+
   it('GIVEN_post_qa_gaps_WHEN_reconciling_THEN_emits_plan_update_with_edge_case_hardening', async () => {
     const featureId = 'feature_gap';
     const toolCaller = {
@@ -165,7 +472,77 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     );
     expect(logCall?.[0]).toBe('orchestrator');
     const note = JSON.parse(String(logCall?.[2].note)) as Record<string, unknown>;
-    expect(note.decision).toBe('plan_update');
+    expect(note.plan_decision).toBe('update_required');
+    expect(note.execution_disposition).toBe('blocked_other');
+  });
+
+  it('GIVEN_blocked_feature_still_in_intake_WHEN_running_post_qa_reconciliation_THEN_skips_plan_update', async () => {
+    const featureId = 'feature_blocked_intake_reconciliation_skip';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              intake: {
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                verified_manifest: null,
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-001',
+                      status: 'open',
+                      summary: 'Still unresolved.',
+                    },
+                  ],
+                },
+              },
+              plan: basePlan(featureId),
+              qa_test_index: {
+                summary: {
+                  pending: 1,
+                  failed: 1,
+                  running: 0,
+                },
+              },
+              latest_evidence: {
+                overall: 'fail',
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.any(Object),
+    );
   });
 
   it('GIVEN_reconciled_post_qa_context_WHEN_reconciling_THEN_logs_no_update_and_skips_plan_update', async () => {
@@ -232,8 +609,9 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(logCall).toBeTruthy();
     const logArgs = logCall?.[2] ?? {};
     const note = JSON.parse(String(logArgs.note));
-    expect(note.decision).toBe('no_update');
-    expect(note.reasons).toEqual(['reconciled_no_gaps']);
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('blocked_stale_evidence');
+    expect(note.reasons).toEqual(['checkpoint_missing']);
   });
 
   it('GIVEN_plan_null_WHEN_reconciling_THEN_logs_no_update_missing_plan', async () => {
@@ -278,7 +656,8 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(logCall).toBeTruthy();
     const logPayload = (logCall as unknown[] | undefined)?.[2] as { note?: string } | undefined;
     const note = JSON.parse(String(logPayload?.note));
-    expect(note.decision).toBe('no_update');
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('blocked_other');
     expect(note.reasons).toContain('missing_plan');
   });
 
@@ -328,7 +707,8 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(logCall).toBeTruthy();
     const logPayload = (logCall as unknown[] | undefined)?.[2] as { note?: string } | undefined;
     const note = JSON.parse(String(logPayload?.note));
-    expect(note.decision).toBe('no_update');
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('blocked_other');
     expect(note.reasons).toContain('existing_plan_version_invalid');
   });
 
@@ -419,119 +799,2093 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(planUpdateCalls).toHaveLength(0);
     expect(logCalls).toHaveLength(0);
   });
-});
 
-describe('PlanningWaveExecutor live watchdog and semantic policies', () => {
-  function workerDecision(overrides: Record<string, unknown> = {}) {
-    return {
-      planSubmission: false,
-      patchApplied: false,
-      noteLogged: false,
-      requestHandled: false,
-      invalidOutput: false,
-      noProgress: false,
-      outputTypes: [],
-      rawOutputs: [],
-      priorityOrder: [],
-      toolResults: [],
-      ...overrides,
-    };
+  it('GIVEN_blocked_provider_output_invalid_WHEN_reconciling_THEN_logs_blocked_provider_failure', async () => {
+    const featureId = 'feature_provider_invalid';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  status_reason: `blocked:${ERROR_CODES.PROVIDER_OUTPUT_INVALID}`,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_provider_invalid/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'fast',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'fail',
+                mode: 'fast',
+                input_diff_hash: 'diff-1',
+              },
+              gate_evidence_by_mode: {
+                fast: {
+                  mode: 'fast',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('blocked_provider_failure');
+    expect(note.checkpoint_validity).toBe('valid');
+  });
+
+  it('GIVEN_invalid_checkpoint_WHEN_reconciling_THEN_logs_nonblocking_stale_evidence', async () => {
+    const featureId = 'feature_checkpoint_invalid';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'invalid',
+                      diff_snapshot:
+                        '.aop/features/feature_checkpoint_invalid/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'fail',
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('blocked_stale_evidence');
+    expect(note.checkpoint_validity).toBe('skipped');
+  });
+
+  it('GIVEN_warning_only_invalid_checkpoint_WHEN_reconciling_THEN_reruns_full_gate_instead_of_blocking', async () => {
+    const featureId = 'feature_checkpoint_warning';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.QA,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-warning',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'invalid',
+                      severity: 'warning',
+                      diff_snapshot:
+                        '.aop/features/feature_checkpoint_warning/checkpoints/checkpoint-warning.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'full',
+                input_diff_hash: 'diff-old',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-old',
+                  input_checkpoint_id: 'checkpoint-old',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('rerun_full_gate');
+    expect(note.checkpoint_validity).toBe('skipped');
+    expect(note.reasons).toEqual(
+      expect.arrayContaining(['checkpoint_invalid_nonblocking', 'gate_evidence_stale:full']),
+    );
+  });
+
+  it('GIVEN_qa_with_stale_full_evidence_WHEN_reconciling_THEN_logs_rerun_full_gate', async () => {
+    const featureId = 'feature_rerun_full_gate';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.QA,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_rerun_full_gate/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'full',
+                input_diff_hash: 'diff-old',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-old',
+                  input_checkpoint_id: 'checkpoint-old',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('rerun_full_gate');
+    expect(note.gate_evidence_freshness).toBe('stale');
+  });
+
+  it('GIVEN_ready_to_merge_with_current_full_evidence_WHEN_reconciling_THEN_logs_converged', async () => {
+    const featureId = 'feature_converged';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.READY_TO_MERGE,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_converged/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 2, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'full',
+                input_diff_hash: 'diff-1',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('converged');
+    expect(note.gate_evidence_freshness).toBe('current');
+  });
+
+  it('GIVEN_blocked_feature_with_stale_failed_full_gate_evidence_WHEN_reconciling_THEN_logs_blocked_stale_evidence', async () => {
+    const featureId = 'feature_blocked_stale_full';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_blocked_stale_full/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'fail',
+                mode: 'full',
+                input_diff_hash: 'diff-old',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-old',
+                  input_checkpoint_id: 'checkpoint-old',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('blocked_stale_evidence');
+    expect(note.gate_evidence_freshness).toBe('stale');
+  });
+
+  it('GIVEN_blocked_feature_with_current_failed_gate_WHEN_reconciling_THEN_logs_blocked_other', async () => {
+    const featureId = 'feature_blocked_current_fail';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_blocked_current_fail/checkpoints/checkpoint-1.diff',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'fast',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'fail',
+                mode: 'fast',
+                input_diff_hash: 'diff-1',
+              },
+              gate_evidence_by_mode: {
+                fast: {
+                  mode: 'fast',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('blocked_other');
+    expect(note.gate_evidence_freshness).toBe('unknown');
+  });
+
+  it('GIVEN_fresh_required_gate_failure_WHEN_reconciling_THEN_invokes_planner_with_gate_failure_context', async () => {
+    const featureId = 'feature_scope_gap';
+    const logPath = path.join(os.tmpdir(), `planning-wave-${Date.now()}.log`);
+    await fs.writeFile(
+      logPath,
+      [
+        '# feature=feature_scope_gap mode=full step=validate_all attempt=1',
+        '# cmd=["npm","run","validate:all"]',
+        '# exit=1 timeout=false',
+        '',
+        '## stdout',
+        '',
+        '## stderr',
+        'validate failed',
+        'apps/control-plane/src/example.ts:12:3: example failure',
+      ].join('\n'),
+      'utf8',
+    );
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: true,
+        patchApplied: false,
+        noteLogged: false,
+        requestHandled: false,
+        questionRequested: false,
+        contextStall: false,
+        contextRequestCount: 0,
+        lastContextRequestAt: null,
+        lastContextRequestRole: null,
+        invalidOutput: false,
+        noProgress: false,
+        outputTypes: ['PLAN_SUBMISSION'],
+        rawOutputs: [],
+        priorityOrder: [],
+        toolResults: [],
+        errorCode: null,
+        interactiveOutcome: null,
+        checkpoint: null,
+      })),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'CLI feature with a gate failure outside current plan scope.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_scope_gap/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                allowed_areas: ['apps/control-plane/src/cli/', 'apps/control-plane/test/'],
+                forbidden_areas: [
+                  'apps/control-plane/src/application/',
+                  'apps/control-plane/src/supervisor/',
+                ],
+                files: {
+                  create: [],
+                  modify: ['apps/control-plane/src/cli/example.ts'],
+                  delete: [],
+                },
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'fail',
+                mode: 'full',
+                step_results: [
+                  {
+                    name: 'validate_all',
+                    cmd: ['npm', 'run', 'validate:all'],
+                    exit_code: 1,
+                    log_path: logPath,
+                    timeout: false,
+                  },
+                ],
+                notes: ['npm run validate:all failed because the required gate is still red.'],
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: 'planner',
+        featureId,
+        contextBundle: expect.objectContaining({
+          gate_failure_context: expect.objectContaining({
+            gate_name: 'full',
+            step_name: 'validate_all',
+            cmd: ['npm', 'run', 'validate:all'],
+            exit_code: 1,
+            affected_files: [
+              expect.objectContaining({
+                path: 'apps/control-plane/src/example.ts',
+                line: 12,
+              }),
+            ],
+            error_lines: expect.arrayContaining(['validate failed']),
+            notes: ['npm run validate:all failed because the required gate is still red.'],
+          }),
+        }),
+      }),
+    );
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.plan_decision).toBe('update_required');
+    expect(note.execution_disposition).toBe('retry_build');
+    expect(note.reasons).toEqual(
+      expect.arrayContaining(['planner_gate_failure_revision_requested']),
+    );
+    expect(note.gate_failure_context).toEqual(
+      expect.objectContaining({
+        step_name: 'validate_all',
+        exit_code: 1,
+        cmd: ['npm', 'run', 'validate:all'],
+        notes: ['npm run validate:all failed because the required gate is still red.'],
+      }),
+    );
+  });
+
+  it('GIVEN_qa_with_pending_work_and_current_evidence_WHEN_reconciling_THEN_logs_retry_qa', async () => {
+    const featureId = 'feature_retry_qa';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.QA,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature_retry_qa/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 1, failed: 0, running: 0, passed: 0, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'full',
+                input_diff_hash: 'diff-1',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-1',
+                  input_checkpoint_id: 'checkpoint-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.execution_disposition).toBe('retry_qa');
+    expect(note.gate_evidence_freshness).toBe('current');
+  });
+
+  it('GIVEN_ready_to_merge_with_non_current_full_evidence_WHEN_reconciling_THEN_logs_blocked_stale_evidence', async () => {
+    const featureId = 'feature_merge_blocked_stale';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.READY_TO_MERGE,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'valid',
+                      diff_snapshot:
+                        '.aop/features/feature_merge_blocked_stale/checkpoints/checkpoint-1.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'full',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 2, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'full',
+                input_diff_hash: 'diff-old',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-old',
+                  input_checkpoint_id: 'checkpoint-old',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('rerun_full_gate');
+    expect(note.gate_evidence_freshness).toBe('stale');
+  });
+
+  it('GIVEN_qa_with_skipped_checkpoint_and_missing_full_evidence_WHEN_reconciling_THEN_logs_rerun_full_gate', async () => {
+    const featureId = 'feature_qa_skipped_checkpoint';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.',
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.QA,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-1',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      validation_status: 'skipped',
+                      diff_snapshot: `.aop/features/${featureId}/checkpoints/checkpoint-1.diff`,
+                      diff_hash: 'diff-1',
+                    },
+                  ],
+                  evidence: {
+                    last_gate_mode: 'fast',
+                  },
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 5, waived: 0 },
+              },
+              latest_evidence: {
+                overall: 'pass',
+                mode: 'fast',
+                input_diff_hash: 'diff-1',
+              },
+              gate_evidence_by_mode: {},
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() },
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const note = readLoggedNote(toolCaller);
+    expect(note.plan_decision).toBe('unchanged');
+    expect(note.execution_disposition).toBe('rerun_full_gate');
+    expect(note.gate_evidence_freshness).toBe('missing');
+    expect(note.checkpoint_validity).toBe('skipped');
+  });
+});
+
+describe('PlanningWaveExecutor live watchdog and semantic policies', () => {
+  function workerDecision(overrides: Record<string, unknown> = {}) {
+    return {
+      planSubmission: false,
+      intakeSubmission: false,
+      patchApplied: false,
+      noteLogged: false,
+      requestHandled: false,
+      questionRequested: false,
+      contextStall: false,
+      contextRequestCount: 0,
+      lastContextRequestAt: null,
+      lastContextRequestRole: null,
+      invalidOutput: false,
+      noProgress: false,
+      outputTypes: [],
+      rawOutputs: [],
+      priorityOrder: [],
+      toolResults: [],
+      ...overrides,
+    };
+  }
+
+  function createPlanningToolCaller(statuses: string[]) {
+    let statusIndex = 0;
+    return {
+      callTool: vi.fn(async (_role: string, toolName: string, args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          const status = statuses[Math.min(statusIndex, statuses.length - 1)] ?? STATUS.PLANNING;
+          statusIndex += 1;
+          return {
+            ok: true,
+            data: {
+              feature_id: String(args?.feature_id ?? 'feature-a'),
+              state: { front_matter: { status } },
+              plan: null,
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { version: 3 } } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
   }
 
-  function createPlanningToolCaller(statuses: string[]) {
-    let statusIndex = 0;
-    return {
-      callTool: vi.fn(async (_role: string, toolName: string, args?: Record<string, unknown>) => {
+  it('generates and submits fallback plan in stub mode when worker does not submit a plan', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: 'feature-a', plan_version: 1 })),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      providerMode: 'stub',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision()),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(planGenerator.generateInitialPlan).toHaveBeenCalledWith('feature-a');
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+      }),
+    );
+  });
+
+  it('auto-promotes the bootstrap manifest in stub mode for intake features before planning', async () => {
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: 'feature-a',
+              state: { front_matter: { status: STATUS.INTAKE } },
+              plan: null,
+              intake: {
+                bootstrap_manifest: {
+                  artifact_type: 'bootstrap',
+                  feature_id: 'feature-a',
+                  manifest_version: 2,
+                  obligations: [{ obligation_id: 'OBL-001', confidence: 'high' }],
+                  ambiguities: [],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: 'feature-a',
+              accepted: true,
+              feature_status: STATUS.PLANNING,
+              verified_manifest_version: 2,
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { version: 3 } } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: 'feature-a', plan_version: 1 })),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      providerMode: 'stub',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision()),
+      },
+      getPolicySnapshot: () => ({
+        planning: {
+          intake: {
+            allow_auto_promotion: true,
+            auto_promotion_min_confidence: 'high',
+          },
+        },
+      }),
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.FEATURE_INTAKE_SUBMIT,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        intake_submission: expect.objectContaining({
+          verified_manifest: expect.objectContaining({
+            artifact_type: 'verified',
+            feature_id: 'feature-a',
+            manifest_version: 2,
+            verification_basis: 'policy_approved_auto_promotion',
+            source_bootstrap_version: 2,
+          }),
+        }),
+      }),
+    );
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+  });
+
+  it('blocks feature on provider stall timeout when block policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const stallError = new Error('stall timeout') as Error & { code?: string };
+    stallError.code = ERROR_CODES.PROVIDER_STALL_TIMEOUT;
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      providerStallAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => {
+          throw stallError;
+        }),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('blocks feature on provider spawn failure when block policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const runtimeError = new Error('spawn timeout') as Error & { code?: string };
+    runtimeError.code = ERROR_CODES.PROVIDER_SPAWN_TIMEOUT;
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      providerSpawnFailureAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => {
+          throw runtimeError;
+        }),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('blocks feature on provider hard timeout when timeout block policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const runtimeError = new Error('hard timeout') as Error & { code?: string };
+    runtimeError.code = ERROR_CODES.PROVIDER_HARD_TIMEOUT;
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      providerTimeoutAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => {
+          throw runtimeError;
+        }),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+          }),
+        }),
+      }),
+    );
+  });
+
+  it('throws runtime errors that have no runtime-failure policy mapping', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const nonMappedError = new Error('bad output') as Error & { code?: string };
+    nonMappedError.code = ERROR_CODES.PROVIDER_OUTPUT_INVALID;
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => {
+          throw nonMappedError;
+        }),
+      },
+    });
+
+    await expect(executor.run(['feature-a'])).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+    });
+  });
+
+  it('throws provider spawn failure when fail-run policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const runtimeError = new Error('runtime unavailable') as Error & { code?: string };
+    runtimeError.code = ERROR_CODES.PROVIDER_RUNTIME_UNAVAILABLE;
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      providerSpawnFailureAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => {
+          throw runtimeError;
+        }),
+      },
+    });
+
+    await expect(executor.run(['feature-a'])).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_RUNTIME_UNAVAILABLE,
+    });
+  });
+
+  it('applies output-loop block policy and skips plan submission for that cycle', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      outputLoopStallAction: 'block_feature',
+      outputLoopDetector: {
+        threshold: 2,
+        check: () => ({
+          fingerprint: 'sha256:loop',
+          isLoop: true,
+          consecutiveIdentical: 1,
+          lastUniqueIteration: 1,
+        }),
+        reset: vi.fn(),
+      } as never,
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          workerDecision({ rawOutputs: [{ type: 'NOTE', content: 'same' }] }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(1);
+    const planSubmitCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCalls).toHaveLength(0);
+  });
+
+  it('throws on output-loop detection when fail-run policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      outputLoopStallAction: 'fail_run',
+      outputLoopDetector: {
+        threshold: 2,
+        check: () => ({
+          fingerprint: 'sha256:loop',
+          isLoop: true,
+          consecutiveIdentical: 1,
+          lastUniqueIteration: 1,
+        }),
+        reset: vi.fn(),
+      } as never,
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          workerDecision({ rawOutputs: [{ type: 'NOTE', content: 'same' }] }),
+        ),
+      },
+    });
+
+    await expect(executor.run(['feature-a'])).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_OUTPUT_LOOP,
+    });
+  });
+
+  it('blocks malformed planner output in live mode and skips plan submission', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(1);
+    expect(statePatchCalls[0]?.[2]).toEqual(
+      expect.objectContaining({
+        patch: {
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+            status_reason: `${ERROR_CODES.PROVIDER_OUTPUT_INVALID}: Planner emitted malformed worker outputs`,
+            recovery: expect.objectContaining({
+              state: 'retrying',
+              cause: ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+              role: 'planner',
+              resume_phase: 'planning',
+              attempt: 1,
+            }),
+          }),
+        },
+      }),
+    );
+    const planSubmitCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCalls).toHaveLength(0);
+  });
+
+  it('routes malformed intake planner output into a blocking clarification question instead of blocked state', async () => {
+    const featureId = 'feature_intake_recovery';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                  cluster: {
+                    planner_session_id: 'planner-session-1',
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+                latest_answer: null,
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-002',
+                      status: 'open',
+                      summary: 'Clarify the provider contract.',
+                      obligation_ids: ['OBL-002'],
+                    },
+                    {
+                      id: 'AMB-003',
+                      status: 'open',
+                      summary: 'Clarify the cost labeling behavior.',
+                      obligation_ids: ['OBL-003'],
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return {
+            ok: true,
+            data: {
+              items: [
+                {
+                  status: 'answered',
+                  phase: STATUS.INTAKE,
+                  resume_status: STATUS.INTAKE,
+                  details: {
+                    ambiguity_ids: ['AMB-002'],
+                  },
+                },
+              ],
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return {
+            ok: true,
+            data: {
+              question_id: 'q_intake_recovery',
+            },
+          };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: featureId,
+        session_id: 'planner-session-1',
+        phase: STATUS.INTAKE,
+        resume_status: STATUS.INTAKE,
+        resume_phase: STATUS.INTAKE,
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-002', 'AMB-003'],
+          obligation_ids: ['OBL-002', 'OBL-003'],
+          prior_answered_ambiguity_ids: ['AMB-002'],
+          recovery_reason: ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+        }),
+      }),
+    );
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(0);
+  });
+
+  it('routes no-progress intake planner turns into a blocking clarification question before the retry limit', async () => {
+    const featureId = 'feature_intake_no_progress';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.INTAKE,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+                latest_answer: null,
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-010',
+                      status: 'open',
+                      summary: 'Clarify the telemetry rollout behavior.',
+                      obligation_ids: ['OBL-010'],
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return { ok: true, data: { items: [] } };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { question_id: 'q_no_progress' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      noProgressLimit: 2,
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ noProgress: true })),
+      },
+    });
+
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: featureId,
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-010'],
+          recovery_reason: ERROR_CODES.PROVIDER_NO_PROGRESS,
+        }),
+      }),
+    );
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(0);
+  });
+
+  it('blocks planning context stalls when intake recovery does not apply', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          workerDecision({
+            contextStall: true,
+            contextRequestCount: 3,
+            lastContextRequestAt: '2026-03-18T08:00:00.000Z',
+            lastContextRequestRole: 'planner',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        patch: {
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+            status_reason: expect.stringContaining(ERROR_CODES.PROVIDER_CONTEXT_STALL),
+          }),
+        },
+      }),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.any(Object),
+    );
+  });
+
+  it('routes intake context stalls into a blocking clarification question instead of blocked state', async () => {
+    const featureId = 'feature_intake_context_stall';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-011',
+                      status: 'open',
+                      summary: 'Clarify the telemetry aggregation granularity.',
+                      obligation_ids: ['OBL-011'],
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return { ok: true, data: { items: [] } };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { question_id: 'q_context_stall' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ contextStall: true })),
+      },
+    });
+
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: featureId,
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-011'],
+          recovery_reason: ERROR_CODES.PROVIDER_CONTEXT_STALL,
+        }),
+      }),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: featureId,
+      }),
+    );
+  });
+
+  it('keeps intake malformed output blocked when verified-manifest data already exists in an inconsistent intake context', async () => {
+    const featureId = 'feature_intake_verified_manifest_present';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+              },
+              intake: {
+                verified_manifest: {
+                  manifest_version: 2,
+                  obligations: [{ obligation_id: 'OBL-030' }],
+                },
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-030',
+                      status: 'open',
+                      summary: 'Should not be asked again.',
+                      obligation_ids: ['OBL-030'],
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { version: 7 } } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.any(Object),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: featureId,
+      }),
+    );
+  });
+
+  it('keeps intake malformed output blocked when a clarification question is already open', async () => {
+    const featureId = 'feature_intake_open_question_present';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
         if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
-          const status = statuses[Math.min(statusIndex, statuses.length - 1)] ?? STATUS.PLANNING;
-          statusIndex += 1;
           return {
             ok: true,
             data: {
-              feature_id: String(args?.feature_id ?? 'feature-a'),
-              state: { front_matter: { status } },
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'awaiting_input',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
               plan: null,
+              human_input: {
+                open_questions: [{ question_id: 'q_existing' }],
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'awaiting_input',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-040',
+                      status: 'open',
+                      summary: 'Clarify the warning-label copy.',
+                      obligation_ids: ['OBL-040'],
+                    },
+                  ],
+                },
+              },
             },
           };
         }
         if (toolName === TOOLS.FEATURE_STATE_GET) {
-          return { ok: true, data: { front_matter: { version: 3 } } };
+          return { ok: true, data: { front_matter: { version: 8 } } };
         }
-        return { ok: true, data: {} };
+        return { ok: true, data: { accepted: true } };
       }),
     };
-  }
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
+      },
+    });
 
-  it('generates and submits fallback plan in stub mode when worker does not submit a plan', async () => {
-    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
-    const planGenerator = {
-      generateInitialPlan: vi.fn(async () => ({ feature_id: 'feature-a', plan_version: 1 })),
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.any(Object),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: featureId,
+      }),
+    );
+  });
+
+  it('routes malformed intake planner output into a follow-up clarification question when every open ambiguity already has answered evidence', async () => {
+    const featureId = 'feature_intake_all_answered';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+                latest_answer: null,
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-020',
+                      status: 'open',
+                      summary: 'Clarify the usage estimate labels.',
+                      obligation_ids: ['OBL-020'],
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return {
+            ok: true,
+            data: {
+              items: [
+                {
+                  status: 'answered',
+                  phase: STATUS.INTAKE,
+                  resume_status: STATUS.INTAKE,
+                  details: {
+                    ambiguity_ids: ['AMB-020'],
+                  },
+                },
+              ],
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { question_id: 'q_follow_up' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
     };
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: planGenerator as never,
-      providerMode: 'stub',
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
       workerDecisionRunner: {
-        execute: vi.fn(async () => workerDecision()),
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
       },
     });
 
-    await executor.run(['feature-a']);
+    await executor.run([featureId]);
 
-    expect(planGenerator.generateInitialPlan).toHaveBeenCalledWith('feature-a');
     expect(toolCaller.callTool).toHaveBeenCalledWith(
-      'planner',
-      TOOLS.PLAN_SUBMIT,
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
       expect.objectContaining({
-        feature_id: 'feature-a',
+        feature_id: featureId,
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-020'],
+          obligation_ids: ['OBL-020'],
+          prior_answered_ambiguity_ids: ['AMB-020'],
+          recovery_reason: ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+        }),
       }),
     );
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(0);
   });
 
-  it('blocks feature on provider stall timeout when block policy is configured', async () => {
-    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
-    const stallError = new Error('stall timeout') as Error & { code?: string };
-    stallError.code = ERROR_CODES.PROVIDER_STALL_TIMEOUT;
+  it('includes prior clarification answers in the recovery question prompt for unresolved intake ambiguities', async () => {
+    const featureId = 'feature_intake_prior_answer_prompt';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+                latest_answer: null,
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [
+                    {
+                      id: 'AMB-020',
+                      status: 'open',
+                      summary: 'Clarify the usage estimate labels.',
+                      obligation_ids: ['OBL-020'],
+                    },
+                  ],
+                  clarification_answers: [
+                    {
+                      question_id: 'q_prior',
+                      ambiguity_ids: ['AMB-020'],
+                      answer: {
+                        label_policy: 'always_show_estimated',
+                      },
+                      answered_at: '2026-01-01T00:05:00.000Z',
+                    },
+                  ],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return {
+            ok: true,
+            data: {
+              items: [
+                {
+                  status: 'answered',
+                  phase: STATUS.INTAKE,
+                  resume_status: STATUS.INTAKE,
+                  details: {
+                    ambiguity_ids: ['AMB-020'],
+                  },
+                },
+              ],
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { question_id: 'q_follow_up' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
       planGenerator: { generateInitialPlan: vi.fn() } as never,
       providerMode: 'live',
-      providerStallAction: 'block_feature',
+      malformedOutputAction: 'block_feature',
       workerDecisionRunner: {
-        execute: vi.fn(async () => {
-          throw stallError;
-        }),
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
       },
     });
 
-    await executor.run(['feature-a']);
+    await executor.run([featureId]);
 
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
-      TOOLS.FEATURE_STATE_PATCH,
+      TOOLS.FEATURE_QUESTION_CREATE,
       expect.objectContaining({
-        feature_id: 'feature-a',
-        patch: expect.objectContaining({
-          front_matter: expect.objectContaining({
-            status: STATUS.BLOCKED,
-          }),
-        }),
+        feature_id: featureId,
+        prompt: expect.stringContaining('Prior answered clarification evidence:'),
+      }),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        prompt: expect.stringContaining('"label_policy": "always_show_estimated"'),
       }),
     );
   });
 
-  it('throws runtime errors that have no runtime-failure policy mapping', async () => {
+  it('keeps malformed intake planner output blocked when no open ambiguities remain to ask about', async () => {
+    const featureId = 'feature_intake_no_open_ambiguities';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED,
+                  intake: {
+                    status: 'in_progress',
+                    bootstrap_manifest_version: 1,
+                    verified_manifest_version: null,
+                  },
+                },
+              },
+              plan: null,
+              human_input: {
+                open_questions: [],
+              },
+              intake: {
+                verified_manifest: null,
+                summary: {
+                  status: 'in_progress',
+                  verified_manifest_version: null,
+                },
+                review: {
+                  ambiguities: [],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_LIST) {
+          return { ok: true, data: { items: [] } };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { version: 5 } } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run([featureId]);
+
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.anything(),
+    );
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(1);
+  });
+
+  it('throws on malformed planner output when fail-run policy is configured', async () => {
     const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
-    const nonMappedError = new Error('bad output') as Error & { code?: string };
-    nonMappedError.code = ERROR_CODES.PROVIDER_OUTPUT_INVALID;
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
       planGenerator: { generateInitialPlan: vi.fn() } as never,
       providerMode: 'live',
+      malformedOutputAction: 'fail_run',
       workerDecisionRunner: {
-        execute: vi.fn(async () => {
-          throw nonMappedError;
-        }),
+        execute: vi.fn(async () => workerDecision({ invalidOutput: true })),
       },
     });
 
@@ -540,40 +2894,144 @@ describe('PlanningWaveExecutor live watchdog and semantic policies', () => {
     });
   });
 
-  it('applies output-loop block policy and skips plan submission for that cycle', async () => {
+  it('tracks no-progress iterations and blocks on the configured limit', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING, STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      noProgressLimit: 2,
+      noProgressAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ noProgress: true })),
+      },
+    });
+
+    await executor.run(['feature-a']);
+    await executor.run(['feature-a']);
+
+    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatchCalls).toHaveLength(1);
+  });
+
+  it('throws on no-progress limit when fail-run policy is configured', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'live',
+      noProgressLimit: 1,
+      noProgressAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ noProgress: true })),
+      },
+    });
+
+    await expect(executor.run(['feature-a'])).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_NO_PROGRESS,
+    });
+  });
+
+  it('ignores no-progress policy in stub mode and still submits fallback plans', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: 'feature-a', plan_version: 1 })),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      providerMode: 'stub',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ noProgress: true })),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(planGenerator.generateInitialPlan).toHaveBeenCalledWith('feature-a');
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.objectContaining({ feature_id: 'feature-a' }),
+    );
+  });
+
+  it('skips fallback plan generation when the planner requested human input', async () => {
+    const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: 'feature-a', plan_version: 1 })),
+    };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => workerDecision({ questionRequested: true })),
+      },
+    });
+
+    await executor.run(['feature-a']);
+
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+    const planSubmitCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCalls).toHaveLength(0);
+  });
+
+  it('blocks planner execution on repeated context refresh with no progress', async () => {
     const toolCaller = createPlanningToolCaller([STATUS.PLANNING]);
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
       planGenerator: { generateInitialPlan: vi.fn() } as never,
       providerMode: 'live',
-      outputLoopStallAction: 'block_feature',
-      outputLoopDetector: {
-        threshold: 2,
-        check: () => ({
-          fingerprint: 'sha256:loop',
-          isLoop: true,
-          consecutiveIdentical: 1,
-          lastUniqueIteration: 1,
-        }),
-        reset: vi.fn(),
-      } as never,
       workerDecisionRunner: {
         execute: vi.fn(async () =>
-          workerDecision({ rawOutputs: [{ type: 'NOTE', content: 'same' }] }),
+          workerDecision({
+            contextStall: true,
+            contextRequestCount: 2,
+            lastContextRequestAt: '2026-03-16T09:30:00.000Z',
+            lastContextRequestRole: 'planner',
+          }),
         ),
       },
     });
 
     await executor.run(['feature-a']);
 
-    const statePatchCalls = toolCaller.callTool.mock.calls.filter(
-      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
-    );
-    expect(statePatchCalls).toHaveLength(1);
-    const planSubmitCalls = toolCaller.callTool.mock.calls.filter(
-      (call) => call[1] === TOOLS.PLAN_SUBMIT,
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        expected_version: 3,
+        patch: {
+          front_matter: expect.objectContaining({
+            status: STATUS.BLOCKED,
+            status_reason: `${ERROR_CODES.PROVIDER_CONTEXT_STALL}: repeated context refresh with no progress`,
+            context_request_count: 2,
+            last_context_request_at: '2026-03-16T09:30:00.000Z',
+            last_context_request_role: 'planner',
+            recovery: expect.objectContaining({
+              state: 'retrying',
+              cause: ERROR_CODES.PROVIDER_CONTEXT_STALL,
+              role: 'planner',
+              resume_phase: 'planning',
+              attempt: 1,
+            }),
+          }),
+        },
+      }),
     );
-    expect(planSubmitCalls).toHaveLength(0);
+    const logged = readLoggedNote(toolCaller);
+    expect(logged).toMatchObject({
+      phase: 'planning',
+      error_code: ERROR_CODES.PROVIDER_CONTEXT_STALL,
+      context_request_count: 2,
+      last_context_request_role: 'planner',
+    });
   });
 
   it('resets planner loop state after blocked-to-planning transition', async () => {
@@ -606,4 +3064,732 @@ describe('PlanningWaveExecutor live watchdog and semantic policies', () => {
     expect(loopDetector.reset).toHaveBeenCalledTimes(1);
     expect(loopDetector.reset).toHaveBeenCalledWith('feature-a');
   });
+
+  it('returns the configured run id when a non-empty string run id is provided', () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      runId: 'run:planning:test',
+    });
+
+    expect((executor as unknown as { resolveRunId: () => string }).resolveRunId()).toBe(
+      'run:planning:test',
+    );
+  });
+
+  it('falls back to an unknown run id when a run-id callback returns an empty string', () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      runId: () => '',
+    });
+
+    expect((executor as unknown as { resolveRunId: () => string }).resolveRunId()).toMatch(
+      /^run:unknown:/,
+    );
+  });
+
+  it('rethrows runtime failures immediately when the planner is not running in live mode', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      providerMode: 'stub',
+    });
+    const error = new Error('stub failure');
+
+    await expect(
+      (
+        executor as unknown as {
+          handleRuntimeFailure: (error: Error, featureId: string) => Promise<boolean>;
+        }
+      ).handleRuntimeFailure(error, 'feature-a'),
+    ).rejects.toBe(error);
+  });
+
+  it('marks blocked features as stale when only full gate evidence is stale', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{ executionDisposition: string; reasons: string[] }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            evidence: {
+              last_gate_mode: 'fast',
+            },
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        gate_evidence_by_mode: {
+          fast: {
+            mode: 'fast',
+            overall: 'pass',
+            input_diff_hash: 'hash-current',
+            input_checkpoint_id: 'cp-1',
+            input_worktree_validity: 'valid',
+            finished_at: '2026-01-01T00:00:00.000Z',
+          },
+          full: {
+            mode: 'full',
+            overall: 'pass',
+            input_diff_hash: 'hash-stale',
+            input_checkpoint_id: 'cp-0',
+            input_worktree_validity: 'valid',
+            finished_at: '2025-12-31T00:00:00.000Z',
+          },
+        },
+        latest_evidence: {
+          mode: 'fast',
+          overall: 'pass',
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      basePlan('feature-a'),
+      STATUS.BLOCKED,
+    );
+
+    expect(decision.executionDisposition).toBe('rerun_full_gate');
+    expect(decision.reasons).toEqual(expect.arrayContaining(['gate_evidence_stale:full']));
+  });
+
+  it('marks QA features as converged when full gate evidence is current and no work remains', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{ executionDisposition: string }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        gate_evidence_by_mode: {
+          full: {
+            mode: 'full',
+            overall: 'pass',
+            input_diff_hash: 'hash-current',
+            input_checkpoint_id: 'cp-1',
+            input_worktree_validity: 'valid',
+            finished_at: '2026-01-01T00:00:00.000Z',
+          },
+        },
+        latest_evidence: {
+          mode: 'full',
+          overall: 'pass',
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      basePlan('feature-a'),
+      STATUS.QA,
+    );
+
+    expect(decision.executionDisposition).toBe('converged');
+  });
+
+  it('returns gate failure context without log analysis when the log file cannot be read', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      repoRoot: '/tmp/aop-missing-log-root',
+    });
+
+    const failureContext = await (
+      executor as unknown as {
+        extractGateFailureContext: (
+          context: Record<string, unknown>,
+        ) => Promise<Record<string, unknown> | null>;
+      }
+    ).extractGateFailureContext({
+      latest_evidence: {
+        mode: 'full',
+        overall: 'fail',
+        notes: ['gate failed'],
+        step_results: [
+          {
+            name: 'full-check',
+            cmd: ['npm', 'test'],
+            exit_code: 1,
+            log_path: 'missing.log',
+          },
+        ],
+      },
+    });
+
+    expect(failureContext).toMatchObject({
+      gate_name: 'full',
+      step_name: 'full-check',
+      exit_code: 1,
+      affected_files: [],
+      error_lines: [],
+      summary_lines: [],
+      notes: ['gate failed'],
+    });
+  });
+
+  it('marks blocked reconciliation as provider failure when status_reason carries provider_output_invalid', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{ executionDisposition: string; reasons: string[] }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            status_reason: `blocked:${ERROR_CODES.PROVIDER_OUTPUT_INVALID}`,
+            evidence: {
+              last_gate_mode: 'fast',
+            },
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        latest_evidence: {
+          mode: 'fast',
+          overall: 'fail',
+          input_diff_hash: 'hash-current',
+          input_checkpoint_id: 'cp-1',
+          input_worktree_validity: 'valid',
+        },
+        gate_evidence_by_mode: {
+          fast: {
+            mode: 'fast',
+            overall: 'fail',
+            input_diff_hash: 'hash-current',
+            input_checkpoint_id: 'cp-1',
+            input_worktree_validity: 'valid',
+          },
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      basePlan('feature-provider-invalid-direct'),
+      STATUS.BLOCKED,
+    );
+
+    expect(decision.executionDisposition).toBe('blocked_provider_failure');
+    expect(decision.reasons).toEqual(expect.arrayContaining(['provider_output_invalid']));
+  });
+
+  it('requests a plan update when verified manifest obligations are missing from plan_trace', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{
+          planDecision: string;
+          reasons: string[];
+          acceptanceCriteriaAdditions: string[];
+        }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        intake: {
+          verified_manifest: {
+            obligations: [
+              {
+                obligation_id: 'OBL-MISSING-TRACE',
+                kind: 'contract',
+                verification_hint: 'required',
+              },
+            ],
+          },
+        },
+        latest_evidence: {
+          mode: 'full',
+          overall: 'pass',
+          input_diff_hash: 'hash-current',
+          input_checkpoint_id: 'cp-1',
+          input_worktree_validity: 'valid',
+        },
+        gate_evidence_by_mode: {
+          full: {
+            mode: 'full',
+            overall: 'pass',
+            input_diff_hash: 'hash-current',
+            input_checkpoint_id: 'cp-1',
+            input_worktree_validity: 'valid',
+          },
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      {
+        ...basePlan('feature-missing-trace-direct'),
+        plan_trace: [],
+      },
+      STATUS.BLOCKED,
+    );
+
+    expect(decision.planDecision).toBe('update_required');
+    expect(decision.reasons).toEqual(expect.arrayContaining(['verified_manifest_trace_missing:1']));
+    expect(decision.acceptanceCriteriaAdditions).toEqual(
+      expect.arrayContaining([
+        'plan_trace maps every verified manifest obligation_id into planned implementation and verification work.',
+      ]),
+    );
+  });
+
+  it('marks blocked reconciliation as blocked_other when fast failure evidence is current', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{ executionDisposition: string }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            evidence: {
+              last_gate_mode: 'fast',
+            },
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        latest_evidence: {
+          mode: 'fast',
+          overall: 'fail',
+          input_diff_hash: 'hash-current',
+          input_checkpoint_id: 'cp-1',
+          input_worktree_validity: 'valid',
+        },
+        gate_evidence_by_mode: {
+          fast: {
+            mode: 'fast',
+            overall: 'fail',
+            input_diff_hash: 'hash-current',
+            input_checkpoint_id: 'cp-1',
+            input_worktree_validity: 'valid',
+          },
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      basePlan('feature-fast-fail-direct'),
+      STATUS.BLOCKED,
+    );
+
+    expect(decision.executionDisposition).toBe('blocked_other');
+  });
+
+  it('marks blocked reconciliation as stale evidence when the last full gate is stale', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const decision = await (
+      executor as unknown as {
+        evaluateReconciliationDecision: (
+          context: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          status: string,
+        ) => Promise<{ executionDisposition: string; reasons: string[] }>;
+      }
+    ).evaluateReconciliationDecision(
+      {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            evidence: {
+              last_gate_mode: 'full',
+            },
+            checkpoints: [
+              {
+                checkpoint_id: 'cp-1',
+                validation_status: 'valid',
+                diff_hash: 'hash-current',
+              },
+            ],
+          },
+        },
+        latest_evidence: {
+          mode: 'full',
+          overall: 'fail',
+          input_diff_hash: 'hash-stale',
+          input_checkpoint_id: 'cp-0',
+          input_worktree_validity: 'valid',
+        },
+        gate_evidence_by_mode: {
+          full: {
+            mode: 'full',
+            overall: 'fail',
+            input_diff_hash: 'hash-stale',
+            input_checkpoint_id: 'cp-0',
+            input_worktree_validity: 'valid',
+          },
+        },
+        qa_test_index: {
+          summary: { pending: 0, failed: 0, running: 0 },
+        },
+      },
+      basePlan('feature-full-stale-direct'),
+      STATUS.BLOCKED,
+    );
+
+    expect(decision.executionDisposition).toBe('blocked_stale_evidence');
+    expect(decision.reasons).toEqual(expect.arrayContaining(['gate_evidence_stale:full']));
+  });
+
+  it('returns false for stub auto-promotion when the bootstrap manifest is empty', () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const allowed = (
+      executor as unknown as {
+        policyAllowsStubAutoPromotion: (bootstrapManifest: Record<string, unknown>) => boolean;
+      }
+    ).policyAllowsStubAutoPromotion({});
+
+    expect(allowed).toBe(false);
+  });
+
+  it('returns false for stub auto-promotion when policy disables it', () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      getPolicySnapshot: () => ({
+        planning: {
+          intake: {
+            allow_auto_promotion: false,
+          },
+        },
+      }),
+    });
+
+    const allowed = (
+      executor as unknown as {
+        policyAllowsStubAutoPromotion: (bootstrapManifest: Record<string, unknown>) => boolean;
+      }
+    ).policyAllowsStubAutoPromotion({
+      obligations: [{ obligation_id: 'OBL-001', confidence: 'high' }],
+      ambiguities: [],
+    });
+
+    expect(allowed).toBe(false);
+  });
+
+  it('returns false for stub auto-promotion when bootstrap ambiguities remain', () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      getPolicySnapshot: () => ({
+        planning: {
+          intake: {
+            allow_auto_promotion: true,
+          },
+        },
+      }),
+    });
+
+    const allowed = (
+      executor as unknown as {
+        policyAllowsStubAutoPromotion: (bootstrapManifest: Record<string, unknown>) => boolean;
+      }
+    ).policyAllowsStubAutoPromotion({
+      obligations: [{ obligation_id: 'OBL-001', confidence: 'high' }],
+      ambiguities: [{ ambiguity_id: 'AMB-001' }],
+    });
+
+    expect(allowed).toBe(false);
+  });
+
+  it('returns false when accepted plan state is already normalized', async () => {
+    const executor = new PlanningWaveExecutor({
+      toolCaller: { callTool: vi.fn() } as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const changed = await (
+      executor as unknown as {
+        normalizeAcceptedPlanState: (
+          featureId: string,
+          frontMatter: Record<string, unknown>,
+          plan: Record<string, unknown>,
+        ) => Promise<boolean>;
+      }
+    ).normalizeAcceptedPlanState(
+      'feature_accepted_plan_healthy',
+      {
+        status: STATUS.BUILDING,
+        state_version: 3,
+        gates: {
+          plan: 'pass',
+        },
+      },
+      basePlan('feature_accepted_plan_healthy'),
+    );
+
+    expect(changed).toBe(false);
+  });
+
+  it('does not auto-heal planning into building when the accepted plan trace no longer matches the verified manifest', async () => {
+    const toolCaller = { callTool: vi.fn() };
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+    });
+
+    const changed = await (
+      executor as unknown as {
+        normalizeAcceptedPlanState: (
+          featureId: string,
+          frontMatter: Record<string, unknown>,
+          plan: Record<string, unknown>,
+          planTraceContract: {
+            valid: boolean;
+            missing_obligation_ids: string[];
+            unknown_obligation_ids: string[];
+            duplicate_obligation_ids: string[];
+            invalid_mappings: string[];
+          } | null,
+        ) => Promise<boolean>;
+      }
+    ).normalizeAcceptedPlanState(
+      'feature_stale_trace',
+      {
+        status: STATUS.PLANNING,
+        version: 3,
+        gates: {
+          plan: 'pass',
+        },
+      },
+      basePlan('feature_stale_trace'),
+      {
+        valid: false,
+        missing_obligation_ids: ['OBL-002'],
+        unknown_obligation_ids: ['OBL-999'],
+        duplicate_obligation_ids: [],
+        invalid_mappings: [],
+      },
+    );
+
+    expect(changed).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalled();
+  });
+
+  it('routes verified manifest trace gaps back to the planner instead of auto-submitting an invalid plan update', async () => {
+    const featureId = 'feature_trace_revision';
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: true,
+        patchApplied: false,
+        noteLogged: true,
+        requestHandled: false,
+        questionRequested: false,
+        contextStall: false,
+        contextRequestCount: 0,
+        lastContextRequestAt: null,
+        lastContextRequestRole: null,
+        invalidOutput: false,
+        noProgress: false,
+        outputTypes: [],
+        rawOutputs: [],
+        priorityOrder: [],
+        toolResults: [],
+        errorCode: null,
+        interactiveOutcome: null,
+        checkpoint: null,
+      })),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.READY_TO_MERGE,
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'cp-1',
+                      validation_status: 'valid',
+                      diff_hash: 'hash-current',
+                    },
+                  ],
+                },
+              },
+              intake: {
+                verified_manifest: {
+                  obligations: [
+                    {
+                      obligation_id: 'OBL-001',
+                      kind: 'artifact',
+                      verification_hint: 'required',
+                    },
+                    {
+                      obligation_id: 'OBL-002',
+                      kind: 'behavior',
+                      verification_hint: 'required',
+                    },
+                  ],
+                },
+              },
+              plan: {
+                ...basePlan(featureId),
+                plan_trace: [
+                  {
+                    obligation_id: 'OBL-001',
+                    disposition: 'in_scope',
+                    planned_paths: ['apps/control-plane/src/file.ts'],
+                    notes: 'covered',
+                  },
+                  {
+                    obligation_id: 'OBL-999',
+                    disposition: 'in_scope',
+                    planned_paths: ['apps/control-plane/src/file.ts'],
+                    notes: 'obsolete',
+                  },
+                ],
+              },
+              qa_test_index: {
+                summary: {
+                  pending: 0,
+                  failed: 0,
+                  running: 0,
+                },
+              },
+              latest_evidence: {
+                mode: 'full',
+                overall: 'pass',
+                input_diff_hash: 'hash-current',
+                input_checkpoint_id: 'cp-1',
+                input_worktree_validity: 'valid',
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'hash-current',
+                  input_checkpoint_id: 'cp-1',
+                  input_worktree_validity: 'valid',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        throw new Error(`unexpected_tool:${toolName}`);
+      }),
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn() } as never,
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.runPostQaReconciliation([featureId], 3);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: 'planner',
+        featureId,
+        contextBundle: expect.objectContaining({
+          plan_trace_contract: expect.objectContaining({
+            missing_obligation_ids: ['OBL-002'],
+            unknown_obligation_ids: ['OBL-999'],
+          }),
+        }),
+      }),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.any(Object),
+    );
+  });
 });