agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/worker-execution-policy.spec.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { STATUS, TOOLS } from '../src/core/constants.js';
 import { BuildWaveExecutor } from '../src/supervisor/build-wave-executor.js';
@@ -11,9 +11,15 @@ import type { WorkerDecisionResult } from '../src/supervisor/worker-decision-loo
 function decision(overrides: Partial<WorkerDecisionResult>): WorkerDecisionResult {
   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: [],
@@ -169,6 +175,112 @@ describe('BuildWaveExecutor live policy branches', () => {
     });
   });
 
+  it('GIVEN_checkpoint_invalid_WHEN_run_THEN_continues_without_blocking_the_feature', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      malformedOutputAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'progress_applied',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-1',
+              timestamp: '2026-03-12T16:00:00.000Z',
+              files_changed: ['apps/control-plane/src/supervisor/build-wave-executor.ts'],
+              validation_status: 'invalid',
+              severity: 'warning',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-1.diff',
+              violations: ['outside_allowed_areas'],
+            },
+          }),
+        ),
+      },
+    });
+
+    await expect(executor.run(['feature-a'], 1)).resolves.toBeUndefined();
+
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(0);
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+  });
+
+  it('GIVEN_checkpoint_invalid_with_empty_violations_WHEN_run_THEN_blocks_with_fallback_message', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            interactiveOutcome: 'checkpoint_invalid',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-synthetic',
+              timestamp: '2026-03-21T00:00:00.000Z',
+              files_changed: [],
+              validation_status: 'skipped',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/synthetic.diff',
+              violations: [],
+            },
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(1);
+    const args = statePatches[0][2];
+    const patch = args?.patch as Record<string, unknown> | undefined;
+    const fm = patch?.front_matter as Record<string, unknown> | undefined;
+    const reason = fm?.status_reason as string | undefined;
+    expect(reason).toContain('checkpoint validation failed');
+    expect(reason?.endsWith(': ')).toBe(false);
+  });
+
+  it('GIVEN_checkpoint_invalid_with_violations_WHEN_run_THEN_blocks_with_joined_violations', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            interactiveOutcome: 'checkpoint_invalid',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-1',
+              timestamp: '2026-03-21T00:00:00.000Z',
+              files_changed: ['src/foo.ts'],
+              validation_status: 'invalid',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-1.diff',
+              violations: ['lint failure in foo.ts', 'type error in bar.ts'],
+            },
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(1);
+    const args = statePatches[0][2];
+    const patch = args?.patch as Record<string, unknown> | undefined;
+    const fm = patch?.front_matter as Record<string, unknown> | undefined;
+    const reason = fm?.status_reason as string | undefined;
+    expect(reason).toContain('lint failure in foo.ts; type error in bar.ts');
+  });
+
   it('GIVEN_no_progress_below_limit_WHEN_run_THEN_skips_current_cycle_without_blocking', async () => {
     const toolCaller = buildToolCaller();
     const executor = new BuildWaveExecutor({
@@ -190,6 +302,76 @@ describe('BuildWaveExecutor live policy branches', () => {
     expect(statePatches).toHaveLength(0);
   });
 
+  it('GIVEN_question_requested_WHEN_build_wave_runs_THEN_skips_gate_without_blocking', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ questionRequested: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(gateRuns).toHaveLength(0);
+    expect(statePatches).toHaveLength(0);
+  });
+
+  it('GIVEN_context_stall_WHEN_build_wave_runs_THEN_blocks_feature_with_request_metadata', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            contextStall: true,
+            contextRequestCount: 2,
+            lastContextRequestAt: '2026-03-16T10:00:00.000Z',
+            lastContextRequestRole: 'builder',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        expected_version: 7,
+        patch: {
+          front_matter: {
+            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-16T10:00:00.000Z',
+            last_context_request_role: 'builder',
+          },
+        },
+      }),
+    );
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
+    expect(logCall?.[2]).toMatchObject({
+      feature_id: 'feature-a',
+    });
+    expect(JSON.parse(String(logCall?.[2]?.note ?? '{}'))).toMatchObject({
+      phase: 'build',
+      error_code: ERROR_CODES.PROVIDER_CONTEXT_STALL,
+      context_request_count: 2,
+      last_context_request_role: 'builder',
+    });
+  });
+
   it('GIVEN_no_progress_at_limit_and_fail_run_policy_WHEN_run_THEN_throws_provider_no_progress', async () => {
     const toolCaller = buildToolCaller();
     const executor = new BuildWaveExecutor({
@@ -207,7 +389,7 @@ describe('BuildWaveExecutor live policy branches', () => {
     });
   });
 
-  it('GIVEN_runtime_hard_timeout_and_block_policy_WHEN_run_THEN_blocks_feature', async () => {
+  it('GIVEN_runtime_hard_timeout_and_block_policy_WHEN_run_twice_THEN_blocks_feature_on_second_timeout', async () => {
     const toolCaller = buildToolCaller();
     const hardTimeoutError = new Error('hard timeout') as Error & { code?: string };
     hardTimeoutError.code = ERROR_CODES.PROVIDER_HARD_TIMEOUT;
@@ -222,6 +404,11 @@ describe('BuildWaveExecutor live policy branches', () => {
       },
     });
 
+    // First run: auto-retry once returns false, error re-thrown
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_HARD_TIMEOUT,
+    });
+    // Second run: timeout retry already used, now blocks
     await executor.run(['feature-a'], 1);
     const statePatches = toolCaller.callTool.mock.calls.filter(
       (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
@@ -257,6 +444,11 @@ describe('BuildWaveExecutor live policy branches', () => {
         },
       });
 
+      // First run: auto-retry once at same phase, error re-thrown
+      await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+        code: ERROR_CODES.PROVIDER_HARD_TIMEOUT,
+      });
+      // Second run: timeout retry used, now blocks and journals
       await executor.run(['feature-a'], 1);
       const events = await readWorkerEvents(repoRoot, 'run:build-policy-journal');
       expect(events).toEqual(
@@ -341,7 +533,7 @@ describe('BuildWaveExecutor live policy branches', () => {
     }
   });
 
-  it('GIVEN_runtime_spawn_timeout_and_block_policy_WHEN_run_THEN_blocks_feature', async () => {
+  it('GIVEN_runtime_spawn_timeout_and_block_policy_WHEN_run_twice_THEN_blocks_feature_on_second_timeout', async () => {
     const toolCaller = buildToolCaller();
     const spawnTimeoutError = new Error('spawn timeout') as Error & { code?: string };
     spawnTimeoutError.code = ERROR_CODES.PROVIDER_SPAWN_TIMEOUT;
@@ -356,6 +548,11 @@ describe('BuildWaveExecutor live policy branches', () => {
       },
     });
 
+    // First run: auto-retry once at same phase, error re-thrown
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_SPAWN_TIMEOUT,
+    });
+    // Second run: timeout retry used, now blocks
     await executor.run(['feature-a'], 1);
     const statePatches = toolCaller.callTool.mock.calls.filter(
       (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
@@ -570,6 +767,328 @@ describe('BuildWaveExecutor live policy branches', () => {
       code: ERROR_CODES.PROVIDER_OUTPUT_LOOP,
     });
   });
+
+  describe('BuildWaveExecutor repair loop log extraction', () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('GIVEN_gate_fails_and_log_exists_WHEN_repair_runs_THEN_context_is_refreshed_each_iteration', async () => {
+      let contextCallCount = 0;
+      const toolCaller = {
+        callTool: vi.fn(async (_role: string, toolName: string) => {
+          if (toolName === TOOLS.FEATURE_STATE_GET) {
+            return {
+              ok: true,
+              data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0, version: 1 } },
+            };
+          }
+          if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+            contextCallCount += 1;
+            return {
+              ok: true,
+              data: {
+                state: { front_matter: { status: STATUS.BUILDING, gates: { fast: 'fail' } } },
+                latest_evidence: {
+                  overall: 'fail',
+                  mode: 'fast',
+                  coverage_status: 'unknown',
+                  step_results: [{ name: 'typecheck', exit_code: 1, log_path: '/tmp/test.log' }],
+                },
+              },
+            };
+          }
+          if (toolName === TOOLS.GATES_RUN) {
+            return { ok: true, data: { overall: 'fail', evidence_path: 'evidence.json' } };
+          }
+          if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+            return { ok: true, data: {} };
+          }
+          if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+            return { ok: true, data: {} };
+          }
+          return { ok: true, data: {} };
+        }),
+      };
+      vi.spyOn(fs, 'readFile').mockResolvedValue(
+        'src/foo.ts:1:1: error TS2345: bad type\n1 error' as never,
+      );
+
+      const workerDecisionRunner = {
+        execute: vi.fn(async () => ({
+          planSubmission: false,
+          patchApplied: true,
+          noteLogged: false,
+          requestHandled: false,
+          invalidOutput: false,
+          noProgress: false,
+          outputTypes: ['PATCH'],
+          rawOutputs: [],
+          priorityOrder: [],
+          toolResults: [],
+        })),
+      };
+      const reactionsService = {
+        shouldRetry: vi.fn().mockReturnValueOnce(true).mockReturnValue(false),
+        shouldEscalate: vi.fn().mockReturnValue(false),
+        retryDelayMs: vi.fn().mockReturnValue(0),
+        waitBeforeRetry: vi.fn().mockResolvedValue(undefined),
+        buildRepairPrompt: vi.fn().mockReturnValue('repair prompt'),
+        recordRetry: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const executor = new BuildWaveExecutor({
+        toolCaller: toolCaller as never,
+        workerDecisionRunner: workerDecisionRunner as never,
+        reactionsService: reactionsService as never,
+        providerMode: 'live',
+        repoRoot: '/repo',
+      });
+
+      await executor.run(['feature_a'], 1);
+
+      // context should be fetched: once pre-work + once for repair (at minimum 2 total)
+      expect(contextCallCount).toBeGreaterThanOrEqual(2);
+    });
+
+    it('GIVEN_gate_fails_and_log_readable_WHEN_repair_runs_THEN_buildRepairPrompt_receives_failureAnalysis', async () => {
+      const toolCaller = {
+        callTool: vi.fn(async (_role: string, toolName: string) => {
+          if (toolName === TOOLS.FEATURE_STATE_GET) {
+            return {
+              ok: true,
+              data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0, version: 1 } },
+            };
+          }
+          if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+            return {
+              ok: true,
+              data: {
+                state: { front_matter: { status: STATUS.BUILDING, gates: {} } },
+                latest_evidence: {
+                  overall: 'fail',
+                  mode: 'fast',
+                  coverage_status: 'unknown',
+                  step_results: [{ name: 'lint', exit_code: 1, log_path: '/tmp/lint.log' }],
+                },
+              },
+            };
+          }
+          if (toolName === TOOLS.GATES_RUN) {
+            return { ok: true, data: { overall: 'fail', evidence_path: 'ev.json' } };
+          }
+          if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+            return { ok: true, data: {} };
+          }
+          if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+            return { ok: true, data: {} };
+          }
+          return { ok: true, data: {} };
+        }),
+      };
+      vi.spyOn(fs, 'readFile').mockResolvedValue(
+        'src/a.ts:5:3: error no-unused-vars\n1 error' as never,
+      );
+
+      const workerDecisionRunner = {
+        execute: vi.fn(async () => ({
+          planSubmission: false,
+          patchApplied: true,
+          noteLogged: false,
+          requestHandled: false,
+          invalidOutput: false,
+          noProgress: false,
+          outputTypes: ['PATCH'],
+          rawOutputs: [],
+          priorityOrder: [],
+          toolResults: [],
+        })),
+      };
+      const capturedCtxs: unknown[] = [];
+      const reactionsService = {
+        shouldRetry: vi.fn().mockReturnValueOnce(true).mockReturnValue(false),
+        shouldEscalate: vi.fn().mockReturnValue(false),
+        retryDelayMs: vi.fn().mockReturnValue(0),
+        waitBeforeRetry: vi.fn().mockResolvedValue(undefined),
+        buildRepairPrompt: vi.fn((ctx: unknown) => {
+          capturedCtxs.push(ctx);
+          return 'repair';
+        }),
+        recordRetry: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const executor = new BuildWaveExecutor({
+        toolCaller: toolCaller as never,
+        workerDecisionRunner: workerDecisionRunner as never,
+        reactionsService: reactionsService as never,
+        providerMode: 'live',
+        repoRoot: '/repo',
+      });
+
+      await executor.run(['feature_a'], 1);
+
+      expect(reactionsService.buildRepairPrompt).toHaveBeenCalled();
+      const ctx = capturedCtxs[0] as Record<string, unknown>;
+      expect(ctx).toHaveProperty('failureAnalysis');
+      const analysis = ctx.failureAnalysis as Record<string, unknown>;
+      expect(analysis.stepName).toBe('lint');
+      expect(analysis.exitCode).toBe(1);
+      expect(Array.isArray(analysis.affectedFiles)).toBe(true);
+    });
+
+    it('GIVEN_log_file_unreadable_WHEN_repair_runs_THEN_failureAnalysis_absent_and_no_crash', async () => {
+      const toolCaller = {
+        callTool: vi.fn(async (_role: string, toolName: string) => {
+          if (toolName === TOOLS.FEATURE_STATE_GET) {
+            return {
+              ok: true,
+              data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0, version: 1 } },
+            };
+          }
+          if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+            return {
+              ok: true,
+              data: {
+                state: { front_matter: { status: STATUS.BUILDING, gates: {} } },
+                latest_evidence: {
+                  overall: 'fail',
+                  mode: 'fast',
+                  coverage_status: 'unknown',
+                  step_results: [{ name: 'lint', exit_code: 1, log_path: '/tmp/missing.log' }],
+                },
+              },
+            };
+          }
+          if (toolName === TOOLS.GATES_RUN) {
+            return { ok: true, data: { overall: 'fail', evidence_path: 'ev.json' } };
+          }
+          if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+            return { ok: true, data: {} };
+          }
+          if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+            return { ok: true, data: {} };
+          }
+          return { ok: true, data: {} };
+        }),
+      };
+      vi.spyOn(fs, 'readFile').mockRejectedValue(new Error('ENOENT'));
+
+      const workerDecisionRunner = {
+        execute: vi.fn(async () => ({
+          planSubmission: false,
+          patchApplied: true,
+          noteLogged: false,
+          requestHandled: false,
+          invalidOutput: false,
+          noProgress: false,
+          outputTypes: ['PATCH'],
+          rawOutputs: [],
+          priorityOrder: [],
+          toolResults: [],
+        })),
+      };
+      const capturedCtxs: unknown[] = [];
+      const reactionsService = {
+        shouldRetry: vi.fn().mockReturnValueOnce(true).mockReturnValue(false),
+        shouldEscalate: vi.fn().mockReturnValue(false),
+        retryDelayMs: vi.fn().mockReturnValue(0),
+        waitBeforeRetry: vi.fn().mockResolvedValue(undefined),
+        buildRepairPrompt: vi.fn((ctx: unknown) => {
+          capturedCtxs.push(ctx);
+          return 'repair';
+        }),
+        recordRetry: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const executor = new BuildWaveExecutor({
+        toolCaller: toolCaller as never,
+        workerDecisionRunner: workerDecisionRunner as never,
+        reactionsService: reactionsService as never,
+        providerMode: 'live',
+        repoRoot: '/repo',
+      });
+
+      await expect(executor.run(['feature_a'], 1)).resolves.not.toThrow();
+      const ctx = capturedCtxs[0] as Record<string, unknown>;
+      expect(ctx.failureAnalysis).toBeUndefined();
+    });
+
+    it('GIVEN_gate_fails_with_empty_step_results_WHEN_repair_runs_THEN_failureAnalysis_absent_and_no_crash', async () => {
+      const toolCaller = {
+        callTool: vi.fn(async (_role: string, toolName: string) => {
+          if (toolName === TOOLS.FEATURE_STATE_GET) {
+            return {
+              ok: true,
+              data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0, version: 1 } },
+            };
+          }
+          if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+            return {
+              ok: true,
+              data: {
+                state: { front_matter: { status: STATUS.BUILDING, gates: {} } },
+                latest_evidence: {
+                  overall: 'fail',
+                  mode: 'fast',
+                  coverage_status: 'unknown',
+                  step_results: [],
+                },
+              },
+            };
+          }
+          if (toolName === TOOLS.GATES_RUN) {
+            return { ok: true, data: { overall: 'fail', evidence_path: 'ev.json' } };
+          }
+          if (toolName === TOOLS.FEATURE_STATE_PATCH) {
+            return { ok: true, data: {} };
+          }
+          if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+            return { ok: true, data: {} };
+          }
+          return { ok: true, data: {} };
+        }),
+      };
+
+      const workerDecisionRunner = {
+        execute: vi.fn(async () => ({
+          planSubmission: false,
+          patchApplied: true,
+          noteLogged: false,
+          requestHandled: false,
+          invalidOutput: false,
+          noProgress: false,
+          outputTypes: ['PATCH'],
+          rawOutputs: [],
+          priorityOrder: [],
+          toolResults: [],
+        })),
+      };
+      const capturedCtxs: unknown[] = [];
+      const reactionsService = {
+        shouldRetry: vi.fn().mockReturnValueOnce(true).mockReturnValue(false),
+        shouldEscalate: vi.fn().mockReturnValue(false),
+        retryDelayMs: vi.fn().mockReturnValue(0),
+        waitBeforeRetry: vi.fn().mockResolvedValue(undefined),
+        buildRepairPrompt: vi.fn((ctx: unknown) => {
+          capturedCtxs.push(ctx);
+          return 'repair';
+        }),
+        recordRetry: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const executor = new BuildWaveExecutor({
+        toolCaller: toolCaller as never,
+        workerDecisionRunner: workerDecisionRunner as never,
+        reactionsService: reactionsService as never,
+        providerMode: 'live',
+        repoRoot: '/repo',
+      });
+
+      await expect(executor.run(['feature_a'], 1)).resolves.not.toThrow();
+      const ctx = capturedCtxs[0] as Record<string, unknown>;
+      expect(ctx.failureAnalysis).toBeUndefined();
+    });
+  });
 });
 
 describe('QaWaveExecutor live policy branches', () => {
@@ -622,6 +1141,125 @@ describe('QaWaveExecutor live policy branches', () => {
     expect(deps.kernel.updateFeatureSessionAssignment).not.toHaveBeenCalled();
   });
 
+  it('GIVEN_qa_checkpoint_invalid_WHEN_run_THEN_continues_without_blocking_the_feature', async () => {
+    const deps = qaDependencies(qaToolCaller());
+    const executor = new QaWaveExecutor({
+      kernel: deps.kernel as never,
+      provider: deps.provider as never,
+      toolCaller: deps.toolCaller as never,
+      promptProvider: deps.promptProvider as never,
+      featureClusterPatcher: deps.featureClusterPatcher as never,
+      state: deps.state as never,
+      providerMode: 'live',
+      malformedOutputAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'progress_applied',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-1',
+              timestamp: '2026-03-12T16:00:00.000Z',
+              files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+              validation_status: 'invalid',
+              severity: 'warning',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-1.diff',
+              violations: ['outside_allowed_areas'],
+            },
+          }),
+        ),
+      },
+    });
+
+    await expect(executor.run(['feature-a'], 1)).resolves.toBeUndefined();
+
+    const statePatches = deps.toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(0);
+  });
+
+  it('GIVEN_qa_checkpoint_invalid_with_empty_violations_WHEN_run_THEN_blocks_with_fallback_message', async () => {
+    const deps = qaDependencies(qaToolCaller());
+    const executor = new QaWaveExecutor({
+      kernel: deps.kernel as never,
+      provider: deps.provider as never,
+      toolCaller: deps.toolCaller as never,
+      promptProvider: deps.promptProvider as never,
+      featureClusterPatcher: deps.featureClusterPatcher as never,
+      state: deps.state as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            interactiveOutcome: 'checkpoint_invalid',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-synthetic',
+              timestamp: '2026-03-21T00:00:00.000Z',
+              files_changed: [],
+              validation_status: 'skipped',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/synthetic.diff',
+              violations: [],
+            },
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const statePatches = deps.toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(1);
+    const args = statePatches[0][2];
+    const patch = args?.patch as Record<string, unknown> | undefined;
+    const fm = patch?.front_matter as Record<string, unknown> | undefined;
+    const reason = fm?.status_reason as string | undefined;
+    expect(reason).toContain('checkpoint validation failed');
+    expect(reason?.endsWith(': ')).toBe(false);
+  });
+
+  it('GIVEN_qa_checkpoint_invalid_with_violations_WHEN_run_THEN_blocks_with_joined_violations', async () => {
+    const deps = qaDependencies(qaToolCaller());
+    const executor = new QaWaveExecutor({
+      kernel: deps.kernel as never,
+      provider: deps.provider as never,
+      toolCaller: deps.toolCaller as never,
+      promptProvider: deps.promptProvider as never,
+      featureClusterPatcher: deps.featureClusterPatcher as never,
+      state: deps.state as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            interactiveOutcome: 'checkpoint_invalid',
+            checkpoint: {
+              checkpoint_id: 'checkpoint-1',
+              timestamp: '2026-03-21T00:00:00.000Z',
+              files_changed: ['src/foo.ts'],
+              validation_status: 'invalid',
+              diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-1.diff',
+              violations: ['lint failure', 'type error'],
+            },
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const statePatches = deps.toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(1);
+    const args = statePatches[0][2];
+    const patch = args?.patch as Record<string, unknown> | undefined;
+    const fm = patch?.front_matter as Record<string, unknown> | undefined;
+    const reason = fm?.status_reason as string | undefined;
+    expect(reason).toContain('lint failure; type error');
+  });
+
   it('GIVEN_no_progress_below_limit_WHEN_run_THEN_skips_current_cycle', async () => {
     const toolCaller = qaToolCaller();
     const executor = new QaWaveExecutor({
@@ -637,7 +1275,7 @@ describe('QaWaveExecutor live policy branches', () => {
         runId: 'run:test',
         ownerInstanceId: 'owner:test',
         orchestratorSessionId: 'orch-session',
-        sessionsByFeature: new Map(),
+        sessionsByFeature: new Map([['feature-a', { planner: 'p-1', builder: 'b-1', qa: 'q-1' }]]),
       } as never,
       providerMode: 'live',
       noProgressLimit: 3,
@@ -651,6 +1289,402 @@ describe('QaWaveExecutor live policy branches', () => {
     expect(gateRuns).toHaveLength(0);
   });
 
+  it('GIVEN_question_requested_WHEN_qa_wave_runs_THEN_skips_gate_and_session_rotation', async () => {
+    const deps = qaDependencies(qaToolCaller());
+    const executor = new QaWaveExecutor({
+      kernel: deps.kernel as never,
+      provider: deps.provider as never,
+      toolCaller: deps.toolCaller as never,
+      promptProvider: deps.promptProvider as never,
+      featureClusterPatcher: deps.featureClusterPatcher as never,
+      state: deps.state as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ questionRequested: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = deps.toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.GATES_RUN,
+    );
+    expect(gateRuns).toHaveLength(0);
+    expect(deps.provider.closeSession).not.toHaveBeenCalled();
+    expect(deps.kernel.updateFeatureSessionAssignment).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_context_stall_WHEN_qa_wave_runs_THEN_blocks_feature_with_request_metadata', async () => {
+    const deps = qaDependencies(qaToolCaller());
+    const executor = new QaWaveExecutor({
+      kernel: deps.kernel as never,
+      provider: deps.provider as never,
+      toolCaller: deps.toolCaller as never,
+      promptProvider: deps.promptProvider as never,
+      featureClusterPatcher: deps.featureClusterPatcher as never,
+      state: deps.state as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            contextStall: true,
+            contextRequestCount: 3,
+            lastContextRequestAt: '2026-03-16T11:00:00.000Z',
+            lastContextRequestRole: 'qa',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(deps.toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature-a',
+        expected_version: 9,
+        patch: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            status_reason: `${ERROR_CODES.PROVIDER_CONTEXT_STALL}: repeated context refresh with no progress`,
+            context_request_count: 3,
+            last_context_request_at: '2026-03-16T11:00:00.000Z',
+            last_context_request_role: 'qa',
+          },
+        },
+      }),
+    );
+    const logCall = deps.toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
+    expect(JSON.parse(String(logCall?.[2]?.note ?? '{}'))).toMatchObject({
+      phase: 'qa',
+      error_code: ERROR_CODES.PROVIDER_CONTEXT_STALL,
+      context_request_count: 3,
+      last_context_request_role: 'qa',
+    });
+  });
+
+  it('GIVEN_interactive_no_new_work_with_stale_fast_evidence_WHEN_run_THEN_reruns_fast_gate', async () => {
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'builder') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.BUILDING,
+                gate_retry_count: 0,
+                version: 3,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-new',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/run-coordinator.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                    diff_hash: 'diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'orchestrator') {
+          return { ok: true, data: { front_matter: { version: 7 } } };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-new',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/run-coordinator.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                fast: {
+                  mode: 'fast',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-old',
+                },
+              },
+              latest_evidence: {
+                mode: 'fast',
+                overall: 'fail',
+                input_diff_hash: 'diff-old',
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'no_new_work',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(1);
+    const patchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(patchCalls).toHaveLength(0);
+  });
+
+  it('GIVEN_interactive_no_new_work_with_empty_fast_checkpoint_diff_WHEN_run_THEN_skips_fast_gate_refresh', async () => {
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'builder') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.BUILDING,
+                gate_retry_count: 0,
+                version: 3,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-empty',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: [],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-empty.diff',
+                    diff_hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                    net_new_worktree_change: false,
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-empty',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: [],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-empty.diff',
+                      diff_hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                      net_new_worktree_change: false,
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {},
+              latest_evidence: null,
+            },
+          };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'no_new_work',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+  });
+
+  it('GIVEN_recovered_fast_gate_refresh_reason_WHEN_run_THEN_bypasses_worker_and_reruns_gate', async () => {
+    const workerDecisionRunner = {
+      execute: vi.fn(async () =>
+        decision({
+          noProgress: true,
+          interactiveOutcome: 'no_new_work',
+        }),
+      ),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'builder') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.BUILDING,
+                status_reason: 'recovered_from_blocked:gate_refresh:fast',
+                gate_retry_count: 0,
+                version: 3,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-new',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/build-wave-executor.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                    diff_hash: 'diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-new',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/build-wave-executor.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                fast: {
+                  mode: 'fast',
+                  overall: 'fail',
+                  input_diff_hash: 'diff-old',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(workerDecisionRunner.execute).not.toHaveBeenCalled();
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(1);
+  });
+
+  it('GIVEN_recovered_fast_gate_refresh_reason_with_current_evidence_WHEN_run_THEN_worker_still_executes', async () => {
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => decision({ patchApplied: true })),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'builder') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.BUILDING,
+                status_reason: 'recovered_from_blocked:gate_refresh:fast',
+                gate_retry_count: 0,
+                version: 3,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-new',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/build-wave-executor.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                    diff_hash: 'diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-new',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/build-wave-executor.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-new.diff',
+                      diff_hash: 'diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                fast: {
+                  mode: 'fast',
+                  overall: 'pass',
+                  input_diff_hash: 'diff-new',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledTimes(1);
+  });
+
   it('GIVEN_no_progress_at_limit_and_fail_run_policy_WHEN_run_THEN_throws_provider_no_progress', async () => {
     const toolCaller = qaToolCaller();
     const executor = new QaWaveExecutor({
@@ -666,7 +1700,7 @@ describe('QaWaveExecutor live policy branches', () => {
         runId: 'run:test',
         ownerInstanceId: 'owner:test',
         orchestratorSessionId: 'orch-session',
-        sessionsByFeature: new Map(),
+        sessionsByFeature: new Map([['feature-a', { planner: 'p-1', builder: 'b-1', qa: 'q-1' }]]),
       } as never,
       providerMode: 'live',
       noProgressLimit: 1,
@@ -681,6 +1715,377 @@ describe('QaWaveExecutor live policy branches', () => {
     });
   });
 
+  it('GIVEN_interactive_no_new_work_with_stale_full_evidence_WHEN_run_THEN_reruns_full_gate', async () => {
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'qa') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.QA,
+                gate_retry_count: 0,
+                version: 5,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-qa',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                    diff_hash: 'qa-diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'orchestrator') {
+          return { ok: true, data: { front_matter: { version: 9 } } };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-qa',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                      diff_hash: 'qa-diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'fail',
+                  input_diff_hash: 'qa-diff-old',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'qa-evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(async () => ({ session_id: 'new-qa-session' })),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: {
+        loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
+      } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'no_new_work',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(1);
+    const patchCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(patchCalls).toHaveLength(0);
+  });
+
+  it('GIVEN_interactive_no_new_work_with_empty_full_checkpoint_diff_WHEN_run_THEN_skips_full_gate_refresh', async () => {
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'qa') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.QA,
+                gate_retry_count: 0,
+                version: 5,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-empty',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: [],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-empty.diff',
+                    diff_hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                    net_new_worktree_change: false,
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-empty',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: [],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-empty.diff',
+                      diff_hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                      net_new_worktree_change: false,
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {},
+            },
+          };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(async () => ({ session_id: 'new-qa-session' })),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: {
+        loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
+      } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      workerDecisionRunner: {
+        execute: vi.fn(async () =>
+          decision({
+            noProgress: true,
+            interactiveOutcome: 'no_new_work',
+          }),
+        ),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+  });
+
+  it('GIVEN_recovered_full_gate_refresh_reason_WHEN_run_THEN_bypasses_worker_and_reruns_gate', async () => {
+    const workerDecisionRunner = {
+      execute: vi.fn(async () =>
+        decision({
+          noProgress: true,
+          interactiveOutcome: 'no_new_work',
+        }),
+      ),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'qa') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.QA,
+                status_reason: 'recovered_from_blocked:gate_refresh:full',
+                gate_retry_count: 0,
+                version: 5,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-qa',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                    diff_hash: 'qa-diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-qa',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                      diff_hash: 'qa-diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'fail',
+                  input_diff_hash: 'qa-diff-old',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'qa-evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(async () => ({ session_id: 'new-qa-session' })),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: {
+        loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
+      } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(workerDecisionRunner.execute).not.toHaveBeenCalled();
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(1);
+  });
+
+  it('GIVEN_recovered_full_gate_refresh_reason_with_current_evidence_WHEN_run_THEN_worker_still_executes', async () => {
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => decision({ patchApplied: true })),
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && role === 'qa') {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: STATUS.QA,
+                status_reason: 'recovered_from_blocked:gate_refresh:full',
+                gate_retry_count: 0,
+                version: 5,
+                checkpoints: [
+                  {
+                    checkpoint_id: 'checkpoint-qa',
+                    timestamp: '2026-03-12T16:00:00.000Z',
+                    files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                    validation_status: 'valid',
+                    diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                    diff_hash: 'qa-diff-new',
+                  },
+                ],
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              state: {
+                front_matter: {
+                  checkpoints: [
+                    {
+                      checkpoint_id: 'checkpoint-qa',
+                      timestamp: '2026-03-12T16:00:00.000Z',
+                      files_changed: ['apps/control-plane/src/supervisor/qa-wave-executor.ts'],
+                      validation_status: 'valid',
+                      diff_snapshot: '.aop/features/feature-a/checkpoints/checkpoint-qa.diff',
+                      diff_hash: 'qa-diff-new',
+                    },
+                  ],
+                },
+              },
+              gate_evidence_by_mode: {
+                full: {
+                  mode: 'full',
+                  overall: 'pass',
+                  input_diff_hash: 'qa-diff-new',
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'qa-evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(async () => ({ session_id: 'new-qa-session' })),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: {
+        loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
+      } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      workerDecisionRunner: workerDecisionRunner as never,
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledTimes(1);
+  });
+
   it('GIVEN_plan_conformance_stall_and_fail_run_policy_WHEN_run_THEN_throws_provider_plan_conformance_stall', async () => {
     const toolCaller = qaToolCaller();
     const executor = new QaWaveExecutor({
@@ -737,7 +2142,7 @@ describe('QaWaveExecutor live policy branches', () => {
     });
   });
 
-  it('GIVEN_runtime_stall_timeout_and_block_policy_WHEN_run_THEN_blocks_feature_and_skips_rotation', async () => {
+  it('GIVEN_runtime_stall_timeout_and_block_policy_WHEN_run_twice_THEN_blocks_feature_and_skips_rotation', async () => {
     const deps = qaDependencies(qaToolCaller());
     const stallTimeoutError = new Error('stall timeout') as Error & { code?: string };
     stallTimeoutError.code = ERROR_CODES.PROVIDER_STALL_TIMEOUT;
@@ -757,6 +2162,11 @@ describe('QaWaveExecutor live policy branches', () => {
       },
     });
 
+    // First run: auto-retry once at same phase, error re-thrown
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_STALL_TIMEOUT,
+    });
+    // Second run: timeout retry used, now blocks
     await executor.run(['feature-a'], 1);
     const statePatches = deps.toolCaller.callTool.mock.calls.filter(
       (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,