agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/worker-decision-loop.spec.ts

@@ -2,7 +2,8 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
-import { TOOLS } from '../src/core/constants.js';
+import { STATUS, TOOLS } from '../src/core/constants.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
 import {
   NOOP_WORKER_DECISION_RUNNER,
   WorkerDecisionLoop,
@@ -20,6 +21,18 @@ describe('WorkerDecisionLoop', () => {
     };
   }
 
+  function makeSequentialProvider(results: Record<string, unknown>[]) {
+    const queue = [...results];
+    return {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      runWorker: vi.fn(async () => queue.shift() ?? { outputs: [] }),
+    };
+  }
+
   function makeToolCaller() {
     return {
       callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
@@ -41,15 +54,25 @@ describe('WorkerDecisionLoop', () => {
 
     expect(result).toEqual({
       planSubmission: false,
+      intakeSubmission: false,
       patchApplied: false,
       noteLogged: false,
       requestHandled: false,
+      questionRequested: false,
+      contextStall: false,
+      contextRequestCount: 0,
+      lastContextRequestAt: null,
+      lastContextRequestRole: null,
       invalidOutput: false,
+      errorCode: null,
       noProgress: false,
       outputTypes: [],
       rawOutputs: [],
       priorityOrder: [],
       toolResults: [],
+      interactiveOutcome: null,
+      checkpoint: null,
+      usageRecords: [],
     });
   });
 
@@ -105,11 +128,11 @@ describe('WorkerDecisionLoop', () => {
     expect(provider.runWorker).toHaveBeenCalledWith(
       expect.objectContaining({
         last_tool_results: [],
-        runtime_selection: {
+        runtime_selection: expect.objectContaining({
           provider: 'custom',
           model: 'model-test',
           provider_config_ref: null,
-        },
+        }),
       }),
     );
     expect(toolCaller.callTool).toHaveBeenCalledWith(
@@ -121,6 +144,47 @@ describe('WorkerDecisionLoop', () => {
     );
   });
 
+  it('GIVEN_runtime_selection_override_WHEN_executed_THEN_passes_override_to_provider', async () => {
+    const provider = makeProvider({ type: 'NOTE', content: 'ok' });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      resolveRuntimeSelection: async () => ({
+        provider: 'custom',
+        model: 'tiny-model',
+        provider_config_env: 'ROLE_ENV',
+        provider_config_ref: 'role-token',
+        agent_config: {
+          command: 'custom',
+          args: ['run'],
+        },
+      }),
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(provider.runWorker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        runtime_selection: {
+          provider: 'custom',
+          model: 'tiny-model',
+          provider_config_env: 'ROLE_ENV',
+          provider_config_ref: 'role-token',
+          agent_config: {
+            command: 'custom',
+            args: ['run'],
+          },
+        },
+      }),
+    );
+  });
+
   it('GIVEN_planner_submission_with_unknown_plan_fields_WHEN_executed_THEN_drops_unrecognized_fields', async () => {
     const provider = makeProvider({
       type: 'PLAN_SUBMISSION',
@@ -192,51 +256,93 @@ describe('WorkerDecisionLoop', () => {
     );
   });
 
-  it('GIVEN_non_planner_or_empty_plan_submission_WHEN_executed_THEN_ignores_submission', async () => {
+  it('GIVEN_planner_submission_during_unverified_intake_WHEN_executed_THEN_routes_to_question_create_instead_of_plan_submit', async () => {
     const provider = makeProvider({
-      outputs: [
-        {
-          type: 'PLAN_SUBMISSION',
-          plan_json: {},
-        },
-        {
-          type: 'PLAN_SUBMISSION',
-          plan_json: {
-            feature_id: 'feature_a',
-            plan_version: 1,
-          },
-        },
-      ],
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Should not submit while intake is unresolved',
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'planner-session-intake',
     });
 
     const result = await loop.execute({
-      role: 'builder',
+      role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'build',
+      contextBundle: {
+        plan: null,
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-100',
+                status: 'open',
+                summary: 'Clarify the role-specific token telemetry contract.',
+                obligation_ids: ['OBL-100'],
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
     });
 
     expect(result.planSubmission).toBe(false);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        session_id: 'planner-session-intake',
+        phase: STATUS.INTAKE,
+        resume_status: STATUS.INTAKE,
+        resume_phase: STATUS.INTAKE,
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-100'],
+          obligation_ids: ['OBL-100'],
+          recovery_reason: 'verified_manifest_required',
+        }),
+      }),
+    );
     expect(toolCaller.callTool).not.toHaveBeenCalledWith(
       'planner',
       TOOLS.PLAN_SUBMIT,
-      expect.any(Object),
+      expect.anything(),
     );
   });
 
-  it('GIVEN_builder_patch_output_WHEN_executed_THEN_routes_to_repo_apply_patch', async () => {
+  it('GIVEN_planner_submission_during_intake_with_open_question_WHEN_executed_THEN_suppresses_plan_submission', async () => {
     const provider = makeProvider({
-      outputs: [
-        {
-          type: 'PATCH',
-          diff: 'diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-a\n+b\n',
-        },
-      ],
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Should be suppressed while a clarification question is open',
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
@@ -245,30 +351,66 @@ describe('WorkerDecisionLoop', () => {
     });
 
     const result = await loop.execute({
-      role: 'qa',
+      role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'qa',
+      contextBundle: {
+        plan: null,
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            intake: {
+              status: 'awaiting_input',
+              verified_manifest_version: 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-102',
+                status: 'open',
+                summary: 'Clarify the provider budget label.',
+                obligation_ids: ['OBL-102'],
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
     });
 
-    expect(result.patchApplied).toBe(true);
-    expect(toolCaller.callTool).toHaveBeenCalledWith(
-      'qa',
-      TOOLS.REPO_APPLY_PATCH,
-      expect.objectContaining({
-        feature_id: 'feature_a',
-      }),
+    expect(result.planSubmission).toBe(false);
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.anything(),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.anything(),
     );
   });
 
-  it('GIVEN_patch_without_diff_or_unsupported_role_WHEN_executed_THEN_skips_patch_routing', async () => {
+  it('GIVEN_planner_submission_during_intake_without_open_ambiguities_WHEN_executed_THEN_suppresses_plan_submission', async () => {
     const provider = makeProvider({
-      outputs: [
-        {
-          type: 'PATCH',
-          unified_diff: '   ',
-        },
-      ],
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Should be suppressed until intake is verified',
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
@@ -279,60 +421,107 @@ describe('WorkerDecisionLoop', () => {
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'plan',
+      contextBundle: {
+        plan: null,
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [],
+          },
+        },
+      },
+      instructions: 'intake',
     });
 
-    expect(result.patchApplied).toBe(false);
+    expect(result.planSubmission).toBe(false);
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(false);
     expect(toolCaller.callTool).not.toHaveBeenCalledWith(
       'planner',
-      TOOLS.REPO_APPLY_PATCH,
-      expect.any(Object),
+      TOOLS.PLAN_SUBMIT,
+      expect.anything(),
     );
   });
 
-  it('GIVEN_note_output_WHEN_log_append_succeeds_THEN_marks_note_logged', async () => {
-    const provider = makeProvider({
-      type: 'NOTE',
-      content: 'worker note',
-    });
-    const toolCaller = makeToolCaller();
+  it('GIVEN_planner_requests_context_refresh_before_amendment_WHEN_executed_THEN_uses_refreshed_plan_version', async () => {
+    const provider = makeSequentialProvider([
+      {
+        type: 'REQUEST',
+        request: { action: 'context_refresh' },
+      },
+      {
+        type: 'REQUEST',
+        request: {
+          action: 'amend_plan',
+          plan_json: {
+            feature_id: 'feature_a',
+            plan_version: 5,
+          },
+        },
+      },
+    ]);
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return { ok: true, data: { plan: { plan_version: 4 } } };
+        }
+        return { ok: true, data: { accepted: true, plan_version: 5 } };
+      }),
+    };
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
-      role: 'builder',
+      role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'note',
+      contextBundle: { plan: { plan_version: 3 } },
+      instructions: 'plan',
     });
 
-    expect(result.noteLogged).toBe(true);
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    expect(result.contextRequestCount).toBe(1);
+    expect(provider.runWorker).toHaveBeenCalledTimes(2);
     expect(toolCaller.callTool).toHaveBeenCalledWith(
-      'orchestrator',
-      TOOLS.FEATURE_LOG_APPEND,
+      'planner',
+      TOOLS.PLAN_UPDATE,
       expect.objectContaining({
         feature_id: 'feature_a',
-        note: 'worker note',
+        expected_plan_version: 4,
       }),
     );
   });
 
-  it('GIVEN_note_output_WHEN_log_append_fails_THEN_swallows_error_and_keeps_note_unset', async () => {
-    const provider = makeProvider({
-      type: 'NOTE',
-      metadata: { info: 'fallback-json' },
-    });
-    const toolCaller = {
-      callTool: vi.fn(async (role: string, toolName: string) => {
-        if (role === 'orchestrator' && toolName === TOOLS.FEATURE_LOG_APPEND) {
-          throw new Error('append_failed');
-        }
-        return { ok: true, data: {} };
-      }),
-    };
+  it('GIVEN_context_refresh_request_WHEN_executed_THEN_retries_same_turn_with_refreshed_context', async () => {
+    const provider = makeSequentialProvider([
+      {
+        type: 'REQUEST',
+        request: { action: 'more_context' },
+      },
+      {
+        type: 'NOTE',
+        content: 'refreshed context applied',
+      },
+    ]);
+    const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
@@ -341,22 +530,44 @@ describe('WorkerDecisionLoop', () => {
     const result = await loop.execute({
       role: 'qa',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'note',
+      contextBundle: { stale: true },
+      instructions: 'context',
     });
 
-    expect(result.noteLogged).toBe(false);
-    expect(result.toolResults).toEqual([]);
+    expect(result.contextRequestCount).toBe(1);
+    expect(result.contextStall).toBe(false);
+    expect(result.noteLogged).toBe(true);
+    expect(result.noProgress).toBe(true);
+    expect(provider.runWorker).toHaveBeenCalledTimes(2);
+    expect(provider.runWorker).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        context_bundle: { refreshed: true },
+        last_tool_results: [
+          expect.objectContaining({
+            tool_name: TOOLS.FEATURE_GET_CONTEXT,
+            feature_id: 'feature_a',
+          }),
+        ],
+      }),
+    );
   });
 
-  it('GIVEN_request_prioritize_with_empty_order_WHEN_executed_THEN_request_remains_unhandled', async () => {
-    const provider = makeProvider({
-      type: 'REQUEST',
-      request: {
-        action: 'prioritize',
-        feature_order: [null, '   '],
+  it('GIVEN_repeated_context_refresh_requests_WHEN_executed_THEN_marks_context_stall', async () => {
+    const provider = makeSequentialProvider([
+      {
+        type: 'REQUEST',
+        request: { action: 'context_refresh' },
       },
-    });
+      {
+        outputs: [
+          {
+            type: 'REQUEST',
+            request: { action: 'context_refresh' },
+          },
+        ],
+      },
+    ]);
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
@@ -364,106 +575,143 @@ describe('WorkerDecisionLoop', () => {
     });
 
     const result = await loop.execute({
-      role: 'orchestrator',
-      featureId: 'global',
+      role: 'builder',
+      featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'prioritize',
+      instructions: 'build',
     });
 
-    expect(result.requestHandled).toBe(false);
-    expect(result.priorityOrder).toEqual([]);
+    expect(result.contextStall).toBe(true);
+    expect(result.errorCode).toBe('provider_context_stall');
+    expect(result.noProgress).toBe(true);
+    expect(result.contextRequestCount).toBe(2);
+    const contextCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_GET_CONTEXT,
+    );
+    expect(contextCalls).toHaveLength(1);
   });
 
-  it('GIVEN_request_lock_acquire_and_release_WHEN_executed_THEN_routes_lock_operations', async () => {
+  it('GIVEN_worker_requests_user_input_WHEN_executed_THEN_creates_structured_question', async () => {
     const provider = makeProvider({
-      outputs: [
-        {
-          type: 'REQUEST',
-          request: { action: 'lock_acquire', resources: ['openapi'] },
-        },
-        {
-          type: 'REQUEST',
-          request: { action: 'lock_release', resources: ['openapi'] },
+      type: 'REQUEST',
+      request: {
+        action: 'ask_user_input',
+        question_type: 'external_decision',
+        prompt: 'Choose release strategy',
+        details: { impact: 'changes deployment timing' },
+        expected_answer: {
+          kind: 'single_choice',
+          choices: ['ship_now', 'hold'],
         },
-      ],
+      },
     });
-    const toolCaller = makeToolCaller();
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, input?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return {
+            ok: true,
+            data: {
+              question_id: 'q_123',
+              prompt: input?.prompt,
+            },
+          };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'session-build-1',
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'locks',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: 'building',
+          },
+        },
+      },
+      instructions: 'build',
     });
 
     expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(true);
+    expect(result.noProgress).toBe(false);
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
-      TOOLS.LOCKS_ACQUIRE,
-      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
-    );
-    expect(toolCaller.callTool).toHaveBeenCalledWith(
-      'orchestrator',
-      TOOLS.LOCKS_RELEASE,
-      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        role: 'builder',
+        session_id: 'session-build-1',
+        question_type: 'external_decision',
+        prompt: 'Choose release strategy',
+        phase: 'building',
+        expected_answer: {
+          kind: 'single_choice',
+          choices: ['ship_now', 'hold'],
+        },
+      }),
     );
   });
 
-  it('GIVEN_lock_requests_with_missing_resources_WHEN_executed_THEN_skips_lock_tool_calls', async () => {
-    const provider = makeProvider({
-      outputs: [
-        {
-          type: 'REQUEST',
-          request: { action: 'lock_acquire', resources: [] },
-        },
-        {
-          type: 'REQUEST',
-          request: { action: 'lock_release', resources: [null] },
-        },
-      ],
-    });
+  it('GIVEN_planner_blocked_in_unverified_intake_WHEN_executed_THEN_runs_with_intake_phase', async () => {
+    const provider = makeProvider({ type: 'NOTE', content: 'intake retry' });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
     });
 
-    const result = await loop.execute({
+    await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'locks',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            intake: {
+              status: 'in_progress',
+              bootstrap_manifest_version: 1,
+              verified_manifest_version: null,
+            },
+          },
+        },
+        intake: {
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          verified_manifest: null,
+        },
+      },
+      instructions: 'intake recovery',
     });
 
-    expect(result.requestHandled).toBe(false);
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
-      'orchestrator',
-      TOOLS.LOCKS_ACQUIRE,
-      expect.any(Object),
-    );
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
-      'orchestrator',
-      TOOLS.LOCKS_RELEASE,
-      expect.any(Object),
+    expect(provider.runWorker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        planner_phase: 'intake',
+      }),
     );
   });
 
-  it('GIVEN_context_refresh_requests_WHEN_executed_THEN_requests_feature_context', async () => {
+  it('GIVEN_planner_intake_submission_WHEN_executed_THEN_routes_to_feature_intake_submit', async () => {
     const provider = makeProvider({
-      outputs: [
-        {
-          type: 'REQUEST',
-          request: { action: 'more_context' },
-        },
-        {
-          type: 'REQUEST',
-          request: { request_type: 'context_refresh' },
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: {
+          feature_id: 'feature_a',
+          manifest_version: 1,
+          obligations: [{ obligation_id: 'OBL-001', name: 'Ship intake gating' }],
         },
-      ],
+        resolved_ambiguities: ['AMB-001'],
+        open_ambiguities: [],
+        requires_user_input: false,
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
@@ -472,28 +720,33 @@ describe('WorkerDecisionLoop', () => {
     });
 
     const result = await loop.execute({
-      role: 'qa',
+      role: 'planner',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'context',
+      instructions: 'intake',
     });
 
-    expect(result.requestHandled).toBe(true);
-    const contextCalls = toolCaller.callTool.mock.calls.filter(
-      (call) => call[1] === TOOLS.FEATURE_GET_CONTEXT,
+    expect(result.intakeSubmission).toBe(true);
+    expect(result.planSubmission).toBe(false);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.FEATURE_INTAKE_SUBMIT,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        intake_submission: expect.objectContaining({
+          requires_user_input: false,
+        }),
+      }),
     );
-    expect(contextCalls).toHaveLength(2);
   });
 
-  it('GIVEN_planner_amend_plan_request_WHEN_existing_version_missing_THEN_submits_new_plan', async () => {
+  it('GIVEN_planner_submission_with_verified_manifest_WHEN_executed_THEN_allows_plan_submit', async () => {
     const provider = makeProvider({
-      type: 'REQUEST',
-      request: {
-        action: 'amend_plan',
-        plan_json: {
-          feature_id: 'feature_a',
-          plan_version: 1,
-        },
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Planning can begin after verified intake.',
       },
     });
     const toolCaller = makeToolCaller();
@@ -505,175 +758,279 @@ describe('WorkerDecisionLoop', () => {
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: { plan: null },
-      instructions: 'amend',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+          },
+        },
+        intake: {
+          verified_manifest: {
+            feature_id: 'feature_a',
+            manifest_version: 1,
+            obligations: [{ obligation_id: 'OBL-001', name: 'Verified contract' }],
+          },
+        },
+      },
+      instructions: 'planning',
     });
 
-    expect(result.requestHandled).toBe(true);
     expect(result.planSubmission).toBe(true);
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'planner',
       TOOLS.PLAN_SUBMIT,
-      expect.objectContaining({ feature_id: 'feature_a' }),
+      expect.objectContaining({
+        feature_id: 'feature_a',
+      }),
     );
   });
 
-  it('GIVEN_planner_amend_plan_with_unknown_plan_fields_WHEN_executed_THEN_strips_unrecognized_fields', async () => {
+  it('GIVEN_planner_emits_question_and_intake_submission_WHEN_executed_THEN_prioritizes_the_question_and_stops_the_turn', async () => {
     const provider = makeProvider({
-      type: 'REQUEST',
-      request: {
-        action: 'amend_plan',
-        plan_json: {
-          feature_id: 'feature_a',
-          plan_version: 1,
-          summary: 'Plan with extra metadata',
-          phase_notes: ['drop me'],
-          gate_profile: 'merge',
+      outputs: [
+        {
+          type: 'REQUEST',
+          request: {
+            action: 'ask_user_input',
+            question_type: 'clarification',
+            prompt: 'Choose the provider/model truthfulness contract.',
+            details: {
+              ambiguity_ids: ['AMB-001', 'AMB-002'],
+              obligation_ids: ['OBL-001'],
+            },
+            expected_answer: { kind: 'free_text' },
+            blocking: true,
+          },
         },
-      },
+        {
+          type: 'INTAKE_SUBMISSION',
+          intake_submission: {
+            verified_manifest: {
+              feature_id: 'feature_a',
+              manifest_version: 1,
+              obligations: [{ obligation_id: 'OBL-001', name: 'Should be ignored' }],
+            },
+            resolved_ambiguities: [],
+            open_ambiguities: [],
+            requires_user_input: false,
+          },
+        },
+      ],
     });
-    const toolCaller = makeToolCaller();
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return {
+            ok: true,
+            data: {
+              question_id: 'q_intake_1',
+            },
+          };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'session-planner-1',
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: { plan: null },
-      instructions: 'amend',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: 'intake',
+          },
+        },
+      },
+      instructions: 'intake',
     });
 
-    expect(result.requestHandled).toBe(true);
-    expect(result.planSubmission).toBe(true);
-    const planSubmitCall = toolCaller.callTool.mock.calls.find(
-      (call) => call[0] === 'planner' && call[1] === TOOLS.PLAN_SUBMIT,
+    expect(result.questionRequested).toBe(true);
+    expect(result.intakeSubmission).toBe(false);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+      }),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.FEATURE_INTAKE_SUBMIT,
+      expect.any(Object),
     );
-    expect(planSubmitCall).toBeDefined();
-    const payload = planSubmitCall?.[2] as { plan_json?: Record<string, unknown> };
-    expect(payload.plan_json?.phase_notes).toBeUndefined();
-    expect(payload.plan_json?.gate_profile).toBeUndefined();
   });
 
-  it('GIVEN_planner_amend_plan_request_WHEN_existing_version_present_THEN_updates_plan', async () => {
+  it('GIVEN_planner_requests_user_input_while_blocked_in_intake_WHEN_executed_THEN_question_resumes_to_intake', async () => {
     const provider = makeProvider({
       type: 'REQUEST',
       request: {
-        action: 'amend_plan',
-        expected_plan_version: 3,
-        plan_json: {
-          feature_id: 'feature_a',
-          plan_version: 4,
+        action: 'ask_user_input',
+        question_type: 'clarification',
+        prompt: 'Clarify the intake ambiguity.',
+        details: {
+          ambiguity_ids: ['AMB-101'],
         },
+        expected_answer: { kind: 'free_text' },
+        blocking: true,
       },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'session-planner-intake',
     });
 
-    const result = await loop.execute({
+    await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: { plan: { plan_version: 2 } },
-      instructions: 'amend',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.BLOCKED,
+            intake: {
+              status: 'in_progress',
+              bootstrap_manifest_version: 1,
+              verified_manifest_version: null,
+            },
+          },
+        },
+        intake: {
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          verified_manifest: null,
+        },
+      },
+      instructions: 'intake',
     });
 
-    expect(result.requestHandled).toBe(true);
-    expect(result.planSubmission).toBe(true);
     expect(toolCaller.callTool).toHaveBeenCalledWith(
-      'planner',
-      TOOLS.PLAN_UPDATE,
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
       expect.objectContaining({
         feature_id: 'feature_a',
-        expected_plan_version: 3,
+        phase: STATUS.INTAKE,
+        resume_status: STATUS.INTAKE,
+        resume_phase: STATUS.INTAKE,
       }),
     );
   });
 
-  it('GIVEN_planner_amend_plan_without_plan_payload_WHEN_executed_THEN_skips_amendment', async () => {
+  it('GIVEN_user_input_request_without_prompt_WHEN_executed_THEN_skips_question_creation', async () => {
     const provider = makeProvider({
       type: 'REQUEST',
       request: {
-        action: 'amend_plan',
-        plan_json: {},
+        action: 'ask_user_input',
+        question_type: 'clarification',
+        prompt: '   ',
       },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'session-qa-1',
     });
 
     const result = await loop.execute({
-      role: 'planner',
+      role: 'qa',
       featureId: 'feature_a',
-      contextBundle: { plan: { plan_version: 2 } },
-      instructions: 'amend',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: 'qa',
+          },
+        },
+      },
+      instructions: 'qa',
     });
 
     expect(result.requestHandled).toBe(false);
-    expect(result.planSubmission).toBe(false);
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
-      'planner',
-      TOOLS.PLAN_UPDATE,
-      expect.any(Object),
-    );
+    expect(result.questionRequested).toBe(false);
     expect(toolCaller.callTool).not.toHaveBeenCalledWith(
-      'planner',
-      TOOLS.PLAN_SUBMIT,
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
       expect.any(Object),
     );
   });
 
-  it('GIVEN_amend_plan_without_payload_or_non_planner_role_WHEN_executed_THEN_ignores_request', async () => {
+  it('GIVEN_planner_emits_multiple_plan_mutations_in_one_turn_WHEN_executed_THEN_applies_only_the_first_mutation', async () => {
     const provider = makeProvider({
       outputs: [
         {
-          type: 'REQUEST',
-          request: {
-            action: 'amend_plan',
-            plan_json: {},
+          type: 'PLAN_SUBMISSION',
+          plan_json: {
+            feature_id: 'feature_a',
+            plan_version: 4,
+            summary: 'First revision',
           },
         },
         {
           type: 'REQUEST',
           request: {
             action: 'amend_plan',
+            expected_plan_version: 3,
             plan_json: {
               feature_id: 'feature_a',
+              plan_version: 4,
             },
           },
         },
       ],
     });
-    const toolCaller = makeToolCaller();
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 4 } };
+        }
+        return { ok: true, data: {} };
+      }),
+    };
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
-      role: 'builder',
+      role: 'planner',
       featureId: 'feature_a',
-      contextBundle: {},
-      instructions: 'amend',
+      contextBundle: { plan: { plan_version: 3 } },
+      instructions: 'plan',
     });
 
-    expect(result.planSubmission).toBe(false);
+    expect(result.planSubmission).toBe(true);
     expect(result.requestHandled).toBe(false);
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_UPDATE,
+    );
+    expect(planUpdateCalls).toHaveLength(1);
+    expect(planUpdateCalls[0]?.[2]).toMatchObject({
+      feature_id: 'feature_a',
+      expected_plan_version: 3,
+    });
   });
 
-  it('GIVEN_unknown_or_malformed_outputs_WHEN_executed_THEN_ignores_them_without_crashing', async () => {
+  it('GIVEN_non_planner_or_empty_plan_submission_WHEN_executed_THEN_ignores_submission', async () => {
     const provider = makeProvider({
       outputs: [
-        null,
-        {},
-        { type: 'UNSUPPORTED' },
-        { type: 'REQUEST', request: {} },
-        { type: 'NOTE', content: 'x' },
+        {
+          type: 'PLAN_SUBMISSION',
+          plan_json: {},
+        },
+        {
+          type: 'PLAN_SUBMISSION',
+          plan_json: {
+            feature_id: 'feature_a',
+            plan_version: 1,
+          },
+        },
       ],
     });
     const toolCaller = makeToolCaller();
@@ -683,76 +1040,60 @@ describe('WorkerDecisionLoop', () => {
     });
 
     const result = await loop.execute({
-      role: 'orchestrator',
-      featureId: 'global',
+      role: 'builder',
+      featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'noop',
+      instructions: 'build',
     });
 
-    expect(result.noteLogged).toBe(true);
     expect(result.planSubmission).toBe(false);
-    expect(result.patchApplied).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.any(Object),
+    );
   });
 
-  it('extracts orchestrator prioritize requests into deterministic priority ordering', async () => {
+  it('GIVEN_builder_patch_output_WHEN_executed_THEN_routes_to_repo_apply_patch', async () => {
     const provider = makeProvider({
-      type: 'REQUEST',
-      request: {
-        action: 'prioritize',
-        feature_order: ['feature_c', 'feature_a'],
-      },
-    });
-
-    const toolCaller = makeToolCaller();
-    const loop = new WorkerDecisionLoop({
+      outputs: [
+        {
+          type: 'PATCH',
+          diff: 'diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-a\n+b\n',
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
-      role: 'orchestrator',
-      featureId: 'global',
-      contextBundle: {
-        active_feature_ids: ['feature_a', 'feature_b', 'feature_c'],
-      },
-      instructions: 'prioritize',
+      role: 'qa',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'qa',
     });
 
-    expect(result.requestHandled).toBe(true);
-    expect(result.priorityOrder).toEqual(['feature_c', 'feature_a']);
-  });
-});
-
-describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
-  function makeProvider(runWorkerResult: Record<string, unknown>) {
-    return {
-      selection: { provider: 'custom', model: 'model-test', provider_config_ref: null },
-      runWorker: vi.fn(async () => runWorkerResult),
-    };
-  }
-
-  function makeToolCaller() {
-    return {
-      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
-        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
-          return { ok: true, data: { refreshed: true } };
-        }
-        return { ok: true, data: { accepted: true } };
+    expect(result.patchApplied).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'qa',
+      TOOLS.REPO_APPLY_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature_a',
       }),
-    };
-  }
+    );
+  });
 
-  it('GIVEN_amend_plan_with_non_integer_revision_of_WHEN_existing_version_present_THEN_falls_back_to_existing_version', async () => {
+  it('GIVEN_patch_without_diff_or_unsupported_role_WHEN_executed_THEN_skips_patch_routing', async () => {
     const provider = makeProvider({
-      type: 'REQUEST',
-      request: {
-        action: 'amend_plan',
-        expected_plan_version: 'not-a-number',
-        plan_json: {
-          feature_id: 'feature_a',
-          plan_version: 3,
+      outputs: [
+        {
+          type: 'PATCH',
+          unified_diff: '   ',
         },
-      },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
@@ -763,195 +1104,2761 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
-      contextBundle: { plan: { plan_version: 2 } },
-      instructions: 'amend',
+      contextBundle: {},
+      instructions: 'plan',
     });
 
-    expect(result.requestHandled).toBe(true);
-    expect(result.planSubmission).toBe(true);
-    expect(toolCaller.callTool).toHaveBeenCalledWith(
+    expect(result.patchApplied).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
       'planner',
-      TOOLS.PLAN_UPDATE,
-      expect.objectContaining({
-        feature_id: 'feature_a',
-        expected_plan_version: 2,
-      }),
+      TOOLS.REPO_APPLY_PATCH,
+      expect.any(Object),
     );
   });
-});
-
-describe('WorkerDecisionLoop runtime event journaling runId branches', () => {
-  function makeProvider(runWorkerResult: Record<string, unknown>) {
-    return {
-      selection: { provider: 'custom', model: 'model-test', provider_config_ref: null },
-      runWorker: vi.fn(async () => runWorkerResult),
-    };
-  }
-
-  function makeToolCaller() {
-    return {
-      callTool: vi.fn(async () => ({ ok: true, data: { accepted: true } })),
-    };
-  }
 
-  it('uses explicit string runId when journaling worker events', async () => {
-    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+  it('GIVEN_builder_patch_without_diff_WHEN_executed_THEN_skips_patch_routing', async () => {
+    const provider = makeProvider({
+      outputs: [
+        {
+          type: 'PATCH',
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
-      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
-      toolCaller: makeToolCaller() as never,
-      repoRoot,
-      runId: 'run:string-id',
+      provider: provider as never,
+      toolCaller: toolCaller as never,
     });
 
-    await loop.execute({
+    const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'note',
+      instructions: 'build',
     });
 
-    const filePath = path.join(repoRoot, '.aop', 'runtime', 'worker-events', 'run:string-id.jsonl');
-    await expect(fs.readFile(filePath, 'utf8')).resolves.toContain('"run_id":"run:string-id"');
+    expect(result.patchApplied).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'builder',
+      TOOLS.REPO_APPLY_PATCH,
+      expect.any(Object),
+    );
   });
 
-  it('falls back to generated runId when configured runId string is empty', async () => {
-    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+  it('GIVEN_note_output_WHEN_log_append_succeeds_THEN_marks_note_logged', async () => {
+    const provider = makeProvider({
+      type: 'NOTE',
+      content: 'worker note',
+    });
+    const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
-      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
-      toolCaller: makeToolCaller() as never,
-      repoRoot,
-      runId: '',
+      provider: provider as never,
+      toolCaller: toolCaller as never,
     });
 
-    await loop.execute({
+    const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
       instructions: 'note',
     });
 
-    const workerEventsDir = path.join(repoRoot, '.aop', 'runtime', 'worker-events');
-    const files = await fs.readdir(workerEventsDir);
-    expect(files.some((entry) => entry.startsWith('run:unknown:'))).toBe(true);
+    expect(result.noteLogged).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        note: 'worker note',
+      }),
+    );
   });
-});
 
-describe('WorkerDecisionLoop runtime failure event classification', () => {
-  function makeToolCaller() {
-    return {
-      callTool: vi.fn(async () => ({ ok: true, data: {} })),
+  it('GIVEN_note_output_WHEN_log_append_fails_THEN_swallows_error_and_keeps_note_unset', async () => {
+    const provider = makeProvider({
+      type: 'NOTE',
+      metadata: { info: 'fallback-json' },
+    });
+    const toolCaller = {
+      callTool: vi.fn(async (role: string, toolName: string) => {
+        if (role === 'orchestrator' && toolName === TOOLS.FEATURE_LOG_APPEND) {
+          throw new Error('append_failed');
+        }
+        return { ok: true, data: {} };
+      }),
     };
-  }
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
 
-  async function readWorkerEvents(
-    repoRoot: string,
-    runId: string,
-  ): Promise<Record<string, unknown>[]> {
-    const filePath = path.join(repoRoot, '.aop', 'runtime', 'worker-events', `${runId}.jsonl`);
-    const content = await fs.readFile(filePath, 'utf8');
-    return content
-      .trim()
-      .split('\n')
-      .filter((line) => line.length > 0)
-      .map((line) => JSON.parse(line) as Record<string, unknown>);
-  }
+    const result = await loop.execute({
+      role: 'qa',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'note',
+    });
 
-  it('classifies timeout-family runtime failures as worker_timeout with watchdog metadata', async () => {
-    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-failure-'));
-    const timeoutError = new Error('idle timeout') as Error & {
-      code?: string;
-      details?: Record<string, unknown>;
-    };
-    timeoutError.code = 'provider_stall_timeout';
-    timeoutError.details = {
-      watchdog_reason: 'idle_timeout',
-      timeout_ms: 600000,
-      idle_timeout_ms: 120000,
-      spawn_timeout_ms: 15000,
-      idle_for_ms: 120500,
-      elapsed_ms: 130000,
-      signal: 'SIGKILL',
-      exit_code: 1,
-    };
+    expect(result.noteLogged).toBe(false);
+    expect(result.toolResults).toEqual([]);
+  });
 
+  it('GIVEN_request_prioritize_with_empty_order_WHEN_executed_THEN_request_remains_unhandled', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'prioritize',
+        feature_order: [null, '   '],
+      },
+    });
+    const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
-      provider: {
-        selection: { provider: 'codex', model: 'model-test', provider_config_ref: null },
-        runWorker: vi.fn(async () => {
-          throw timeoutError;
-        }),
-      } as never,
-      toolCaller: makeToolCaller() as never,
-      repoRoot,
-      runId: 'run:timeout',
+      provider: provider as never,
+      toolCaller: toolCaller as never,
     });
 
-    await expect(
-      loop.execute({
-        role: 'builder',
-        featureId: 'feature-a',
-        contextBundle: {},
-        instructions: 'build',
-      }),
-    ).rejects.toMatchObject({ code: 'provider_stall_timeout' });
+    const result = await loop.execute({
+      role: 'orchestrator',
+      featureId: 'global',
+      contextBundle: {},
+      instructions: 'prioritize',
+    });
 
-    const events = await readWorkerEvents(repoRoot, 'run:timeout');
-    expect(events.at(-1)).toMatchObject({
-      event_type: 'worker_timeout',
-      error_code: 'provider_stall_timeout',
-      watchdog_reason: 'idle_timeout',
-      timeout_ms: 600000,
-      idle_timeout_ms: 120000,
-      spawn_timeout_ms: 15000,
-      idle_for_ms: 120500,
-      elapsed_ms: 130000,
-      signal: 'SIGKILL',
-      exit_code: 1,
+    expect(result.requestHandled).toBe(false);
+    expect(result.priorityOrder).toEqual([]);
+  });
+
+  it('GIVEN_request_lock_acquire_and_release_WHEN_executed_THEN_routes_lock_operations', async () => {
+    const provider = makeProvider({
+      outputs: [
+        {
+          type: 'REQUEST',
+          request: { action: 'lock_acquire', resources: ['openapi'] },
+        },
+        {
+          type: 'REQUEST',
+          request: { action: 'lock_release', resources: ['openapi'] },
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'locks',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_ACQUIRE,
+      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_RELEASE,
+      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
+    );
+  });
+
+  it('GIVEN_lock_requests_with_missing_resources_WHEN_executed_THEN_skips_lock_tool_calls', async () => {
+    const provider = makeProvider({
+      outputs: [
+        {
+          type: 'REQUEST',
+          request: { action: 'lock_acquire', resources: [] },
+        },
+        {
+          type: 'REQUEST',
+          request: { action: 'lock_release', resources: [null] },
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'locks',
+    });
+
+    expect(result.requestHandled).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_ACQUIRE,
+      expect.any(Object),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_RELEASE,
+      expect.any(Object),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_request_WHEN_existing_version_missing_THEN_submits_new_plan', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 1,
+        },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: null },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.objectContaining({ feature_id: 'feature_a' }),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_request_during_unverified_intake_WHEN_executed_THEN_routes_to_question_create_instead_of_plan_update', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 2,
+          summary: 'Should not amend a plan while intake is unresolved',
+        },
+        expected_plan_version: 1,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'planner-session-intake',
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        plan: {
+          plan_version: 1,
+        },
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-101',
+                status: 'open',
+                summary: 'Clarify the persisted usage burn aggregation window.',
+                obligation_ids: ['OBL-101'],
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(false);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-101'],
+          obligation_ids: ['OBL-101'],
+          recovery_reason: 'verified_manifest_required',
+        }),
+      }),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_unverified_intake_with_prior_clarification_answers_WHEN_amend_plan_is_rerouted_THEN_follow_up_prompt_includes_prior_answer_evidence', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 2,
+          summary: 'Should not amend a plan while intake is unresolved',
+        },
+        expected_plan_version: 1,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'planner-session-intake',
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        plan: {
+          plan_version: 1,
+        },
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-101',
+                status: 'open',
+                summary: 'Clarify the persisted usage burn aggregation window.',
+                obligation_ids: ['OBL-101'],
+              },
+            ],
+            clarification_answers: [
+              {
+                question_id: 'q_prior',
+                ambiguity_ids: ['AMB-101'],
+                answer: {
+                  aggregation_window: 'daily',
+                },
+                answered_at: '2026-01-01T00:05:00.000Z',
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        prompt: expect.stringContaining('Prior answered clarification evidence:'),
+      }),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        prompt: expect.stringContaining('"aggregation_window": "daily"'),
+      }),
+    );
+  });
+
+  it('GIVEN_intake_submission_resolves_unsupported_ambiguities_WHEN_validation_rejects_THEN_reroutes_to_clarification_question', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: {
+          feature_id: 'feature_a',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [
+          {
+            id: 'AMB-021',
+            summary: 'Clarify the provider profile selection boundary.',
+            status: 'resolved',
+            obligation_ids: ['OBL-021'],
+          },
+        ],
+        requires_user_input: false,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(
+      async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+          throw {
+            normalizedResponse: {
+              error: {
+                code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+                message: 'resolved intake ambiguities must map to answered intake questions',
+                details: {
+                  missing_ambiguity_evidence_ids: ['AMB-021'],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { accepted: true, question_id: 'q_follow_up' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      },
+    );
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'planner-session-intake',
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-021',
+                status: 'resolved',
+                summary: 'Clarify the provider profile selection boundary.',
+                obligation_ids: ['OBL-021'],
+              },
+            ],
+            clarification_answers: [],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.intakeSubmission).toBe(false);
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        prompt: expect.stringContaining(
+          'AMB-021: Clarify the provider profile selection boundary.',
+        ),
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-021'],
+          recovery_reason: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+          recovery_source: 'intake_submission_validation',
+        }),
+      }),
+    );
+  });
+
+  it('GIVEN_intake_submission_invalid_with_prior_answered_clarification_WHEN_rerouted_THEN_includes_prior_answer_evidence', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: {
+          feature_id: 'feature_a',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(
+      async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+          throw {
+            normalizedResponse: {
+              error: {
+                code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+                message: 'resolved intake ambiguities must map to answered intake questions',
+                details: {
+                  missing_ambiguity_evidence_ids: ['AMB-021'],
+                },
+              },
+            },
+          };
+        }
+        if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+          return { ok: true, data: { accepted: true, question_id: 'q_follow_up' } };
+        }
+        return { ok: true, data: { accepted: true } };
+      },
+    );
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      resolveRoleSessionId: () => 'planner-session-intake',
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-021',
+                status: 'resolved',
+                summary: 'Clarify the provider profile selection boundary.',
+                obligation_ids: ['OBL-021'],
+              },
+            ],
+            clarification_answers: [
+              {
+                question_id: 'q_prior',
+                ambiguity_ids: ['AMB-021'],
+                answer: {
+                  selected_profile: 'planner-fast',
+                },
+                answered_at: '2026-01-01T00:05:00.000Z',
+              },
+            ],
+          },
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        prompt: expect.stringContaining('Prior answered clarification evidence:'),
+        details: expect.objectContaining({
+          prior_answered_ambiguity_ids: ['AMB-021'],
+        }),
+      }),
+    );
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        prompt: expect.stringContaining('"selected_profile": "planner-fast"'),
+      }),
+    );
+  });
+
+  it('GIVEN_intake_submission_invalid_with_existing_open_question_WHEN_executed_THEN_skips_duplicate_question_creation', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: {
+          feature_id: 'feature_a',
+          manifest_version: 1,
+          artifact_type: 'verified',
+          verification_basis: 'questions_resolved',
+          verified_at: '2026-01-01T00:00:00.000Z',
+          source_bootstrap_version: 1,
+          obligations: [],
+        },
+        open_ambiguities: [],
+        resolved_ambiguities: [],
+        requires_user_input: false,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(
+      async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+          throw {
+            normalizedResponse: {
+              error: {
+                code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+                message: 'resolved intake ambiguities must map to answered intake questions',
+                details: {
+                  missing_ambiguity_evidence_ids: ['AMB-021'],
+                },
+              },
+            },
+          };
+        }
+        return { ok: true, data: { accepted: true } };
+      },
+    );
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+          },
+        },
+        human_input: {
+          open_questions: [{ question_id: 'q_existing' }],
+        },
+        intake: {
+          verified_manifest: null,
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-021',
+                status: 'open',
+                summary: 'Clarify the provider profile selection boundary.',
+                obligation_ids: ['OBL-021'],
+              },
+            ],
+            clarification_answers: [],
+          },
+          summary: {
+            status: 'awaiting_input',
+            verified_manifest_version: null,
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.FEATURE_INTAKE_SUBMIT,
+      expect.anything(),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_with_unknown_plan_fields_WHEN_executed_THEN_strips_unrecognized_fields', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 1,
+          summary: 'Plan with extra metadata',
+          phase_notes: ['drop me'],
+          gate_profile: 'merge',
+        },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: null },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    const planSubmitCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[0] === 'planner' && call[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(planSubmitCall).toBeDefined();
+    const payload = planSubmitCall?.[2] as { plan_json?: Record<string, unknown> };
+    expect(payload.plan_json?.phase_notes).toBeUndefined();
+    expect(payload.plan_json?.gate_profile).toBeUndefined();
+  });
+
+  it('GIVEN_planner_amend_plan_request_WHEN_existing_version_present_THEN_updates_plan', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        expected_plan_version: 3,
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 4,
+        },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: { plan_version: 2 } },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        expected_plan_version: 3,
+      }),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_without_plan_payload_WHEN_executed_THEN_skips_amendment', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {},
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: { plan_version: 2 } },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(false);
+    expect(result.planSubmission).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.any(Object),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.any(Object),
+    );
+  });
+
+  it('GIVEN_amend_plan_without_payload_or_non_planner_role_WHEN_executed_THEN_ignores_request', async () => {
+    const provider = makeProvider({
+      outputs: [
+        {
+          type: 'REQUEST',
+          request: {
+            action: 'amend_plan',
+            plan_json: {},
+          },
+        },
+        {
+          type: 'REQUEST',
+          request: {
+            action: 'amend_plan',
+            plan_json: {
+              feature_id: 'feature_a',
+            },
+          },
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'amend',
+    });
+
+    expect(result.planSubmission).toBe(false);
+    expect(result.requestHandled).toBe(false);
+  });
+
+  it('GIVEN_unknown_or_malformed_outputs_WHEN_executed_THEN_ignores_them_without_crashing', async () => {
+    const provider = makeProvider({
+      outputs: [
+        null,
+        {},
+        { type: 'UNSUPPORTED' },
+        { type: 'REQUEST', request: {} },
+        { type: 'NOTE', content: 'x' },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'orchestrator',
+      featureId: 'global',
+      contextBundle: {},
+      instructions: 'noop',
+    });
+
+    expect(result.noteLogged).toBe(true);
+    expect(result.planSubmission).toBe(false);
+    expect(result.patchApplied).toBe(false);
+  });
+
+  it('extracts orchestrator prioritize requests into deterministic priority ordering', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'prioritize',
+        feature_order: ['feature_c', 'feature_a'],
+      },
+    });
+
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'orchestrator',
+      featureId: 'global',
+      contextBundle: {
+        active_feature_ids: ['feature_a', 'feature_b', 'feature_c'],
+      },
+      instructions: 'prioritize',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.priorityOrder).toEqual(['feature_c', 'feature_a']);
+  });
+
+  it('GIVEN_provider_returns_usage_WHEN_executed_THEN_usageRecords_populated', async () => {
+    const usageData = {
+      status: 'reported',
+      input_tokens: 500,
+      output_tokens: 200,
+      total_tokens: 700,
+      provider: 'claude',
+      model: 'claude-3',
+      role: 'builder',
+      estimated_cost_usd: 0.02,
+    };
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+      usage: usageData,
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_usage',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.usageRecords).toHaveLength(1);
+    expect(result.usageRecords[0]).toMatchObject({
+      status: 'reported',
+      input_tokens: 500,
+      output_tokens: 200,
+      total_tokens: 700,
+    });
+  });
+
+  it('GIVEN_provider_returns_no_usage_WHEN_executed_THEN_usageRecords_empty', async () => {
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_no_usage',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.usageRecords).toHaveLength(0);
+  });
+
+  it('GIVEN_provider_returns_invalid_usage_shape_WHEN_executed_THEN_usageRecords_empty', async () => {
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+      usage: 'not-an-object',
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_bad_usage',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.usageRecords).toHaveLength(0);
+  });
+
+  it('GIVEN_provider_returns_usage_object_without_status_key_WHEN_executed_THEN_usageRecords_empty', async () => {
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+      usage: { input_tokens: 100, output_tokens: 50 },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_no_status',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.usageRecords).toHaveLength(0);
+  });
+
+  it('GIVEN_provider_returns_usage_object_with_non_string_status_WHEN_executed_THEN_usageRecords_empty', async () => {
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+      usage: { status: 123, input_tokens: 100, output_tokens: 50 },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_numeric_status',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.usageRecords).toHaveLength(0);
+  });
+
+  it('GIVEN_context_refresh_retry_with_usage_on_both_calls_WHEN_executed_THEN_collects_both_usage_records', async () => {
+    const usageFirst = {
+      status: 'reported',
+      input_tokens: 100,
+      output_tokens: 50,
+      total_tokens: 150,
+      provider: 'claude',
+      model: 'claude-3',
+      role: 'qa',
+      estimated_cost_usd: 0.01,
+    };
+    const usageSecond = {
+      status: 'reported',
+      input_tokens: 200,
+      output_tokens: 100,
+      total_tokens: 300,
+      provider: 'claude',
+      model: 'claude-3',
+      role: 'qa',
+      estimated_cost_usd: 0.02,
+    };
+    const provider = makeSequentialProvider([
+      {
+        type: 'REQUEST',
+        request: { action: 'more_context' },
+        usage: usageFirst,
+      },
+      {
+        type: 'NOTE',
+        content: 'refreshed context applied',
+        usage: usageSecond,
+      },
+    ]);
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'qa',
+      featureId: 'feature_retry_usage',
+      contextBundle: { stale: true },
+      instructions: 'context',
+    });
+
+    expect(result.usageRecords).toHaveLength(2);
+    expect(result.usageRecords[0]).toMatchObject({ input_tokens: 100 });
+    expect(result.usageRecords[1]).toMatchObject({ input_tokens: 200 });
+  });
+
+  it('GIVEN_builder_emits_PLAN_SUBMISSION_WHEN_executed_THEN_ignores_plan_submission_for_non_planner', async () => {
+    const provider = makeProvider({
+      type: 'PLAN_SUBMISSION',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'builder cannot submit plans',
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.planSubmission).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_builder_emits_INTAKE_SUBMISSION_WHEN_executed_THEN_ignores_intake_submission_for_non_planner', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: { feature_id: 'feature_a' },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(result.intakeSubmission).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.FEATURE_INTAKE_SUBMIT,
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_planner_emits_PLAN_SUBMISSION_with_plan_field_instead_of_plan_json_WHEN_executed_THEN_routes_via_plan_fallback', async () => {
+    const provider = makeProvider({
+      type: 'PLAN_SUBMISSION',
+      plan: {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        summary: 'Plan via plan field',
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'plan',
+    });
+
+    expect(result.planSubmission).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+      }),
+    );
+  });
+
+  it('GIVEN_planner_emits_PLAN_SUBMISSION_with_empty_plan_json_WHEN_executed_THEN_skips_plan_submission', async () => {
+    const provider = makeProvider({
+      type: 'PLAN_SUBMISSION',
+      plan_json: {},
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'plan',
+    });
+
+    expect(result.planSubmission).toBe(false);
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_planner_emits_two_PLAN_SUBMISSIONS_WHEN_executed_THEN_only_first_mutation_applies', async () => {
+    const provider = makeProvider({
+      outputs: [
+        {
+          type: 'PLAN_SUBMISSION',
+          plan_json: {
+            feature_id: 'feature_a',
+            plan_version: 1,
+            summary: 'first plan',
+          },
+        },
+        {
+          type: 'PLAN_SUBMISSION',
+          plan_json: {
+            feature_id: 'feature_a',
+            plan_version: 2,
+            summary: 'second plan ignored',
+          },
+        },
+      ],
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'plan',
+    });
+
+    expect(result.planSubmission).toBe(true);
+    const submitCalls = toolCaller.callTool.mock.calls.filter(
+      (c: unknown[]) => c[1] === TOOLS.PLAN_SUBMIT,
+    );
+    expect(submitCalls).toHaveLength(1);
+  });
+
+  it('GIVEN_planner_amend_plan_during_intake_with_verified_manifest_WHEN_executed_THEN_allows_plan_amendment', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 2,
+          summary: 'Amend plan after intake is verified',
+        },
+        expected_plan_version: 1,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        plan: {
+          plan_version: 1,
+        },
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: {
+              status: 'in_progress',
+              verified_manifest_version: null,
+            },
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: {
+            feature_id: 'feature_a',
+            manifest_version: 1,
+            obligations: [{ obligation_id: 'OBL-001', name: 'Already verified' }],
+          },
+          summary: {
+            status: 'in_progress',
+            verified_manifest_version: null,
+          },
+          review: {
+            ambiguities: [],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.planSubmission).toBe(true);
+    expect(result.questionRequested).toBe(false);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+      }),
+    );
+  });
+
+  it('GIVEN_activity_monitor_configured_WHEN_executed_THEN_checks_stuck_after_completion', async () => {
+    const provider = makeProvider({
+      outputs: [{ type: 'NOTE', content: 'done' }],
+    });
+    const toolCaller = makeToolCaller();
+    const activityMonitor = {
+      checkAndNotifyStuck: vi.fn(async () => undefined),
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      activityMonitor: activityMonitor as never,
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_monitor',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    expect(activityMonitor.checkAndNotifyStuck).toHaveBeenCalledWith('feature_monitor');
+  });
+
+  it('GIVEN_planner_intake_submission_fails_with_non_INTAKE_SUBMISSION_INVALID_error_WHEN_executed_THEN_rethrows_error', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: { feature_id: 'feature_a' },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: 'some_other_error',
+              message: 'unexpected failure',
+              details: {},
+            },
+          },
+        };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    await expect(
+      loop.execute({
+        role: 'planner',
+        featureId: 'feature_a',
+        contextBundle: {
+          state: {
+            front_matter: {
+              status: STATUS.INTAKE,
+            },
+          },
+          intake: {
+            verified_manifest: null,
+            summary: { status: 'in_progress', verified_manifest_version: null },
+            review: { ambiguities: [] },
+          },
+        },
+        instructions: 'intake',
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: expect.objectContaining({
+        error: expect.objectContaining({ code: 'some_other_error' }),
+      }),
+    });
+  });
+
+  it('GIVEN_planner_intake_submission_invalid_without_session_resolver_WHEN_rerouted_THEN_falls_back_to_bootstrap_session_id', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: { feature_id: 'feature_a' },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+              message: 'missing ambiguity evidence',
+              details: {
+                missing_ambiguity_evidence_ids: ['AMB-101'],
+              },
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+        return { ok: true, data: { accepted: true, question_id: 'q_fallback' } };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      // No resolveRoleSessionId — should fall back to bootstrap:planner
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+          },
+        },
+        human_input: {
+          open_questions: [],
+        },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-101',
+                status: 'open',
+                summary: 'Clarify the boundary.',
+                obligation_ids: ['OBL-101'],
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        session_id: 'bootstrap:planner',
+      }),
+    );
+  });
+
+  it('GIVEN_planner_intake_submission_throws_plain_error_WHEN_executed_THEN_rethrows_because_failure_details_are_null', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: { feature_id: 'feature_a' },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw new Error('plain error');
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    await expect(
+      loop.execute({
+        role: 'planner',
+        featureId: 'feature_a',
+        contextBundle: {
+          state: { front_matter: { status: STATUS.INTAKE } },
+          intake: {
+            verified_manifest: null,
+            summary: { status: 'in_progress', verified_manifest_version: null },
+            review: { ambiguities: [] },
+          },
+        },
+        instructions: 'intake',
+      }),
+    ).rejects.toThrow('plain error');
+  });
+
+  it('GIVEN_intake_submission_invalid_with_empty_ambiguity_ids_WHEN_rerouted_THEN_falls_back_to_open_ambiguities', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: {
+        verified_manifest: { feature_id: 'feature_a' },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+              message: 'no ambiguities specified',
+              details: {},
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+        return { ok: true, data: { accepted: true, question_id: 'q_open' } };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: { front_matter: { status: STATUS.INTAKE } },
+        human_input: { open_questions: [] },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-201',
+                status: 'open',
+                summary: 'Open ambiguity',
+                obligation_ids: ['OBL-201'],
+              },
+              { id: 'AMB-202', status: 'resolved', summary: 'Resolved one', obligation_ids: [] },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-201'],
+        }),
+      }),
+    );
+  });
+
+  it('GIVEN_intake_submission_invalid_with_multiple_ambiguities_and_prior_answers_WHEN_rerouted_THEN_prompt_covers_all_ambiguities', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: { verified_manifest: { feature_id: 'feature_a' } },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+              message: 'missing evidence',
+              details: {
+                missing_ambiguity_evidence_ids: ['AMB-301', 'AMB-302'],
+              },
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+        return { ok: true, data: { accepted: true, question_id: 'q_multi' } };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: { front_matter: { status: STATUS.INTAKE } },
+        human_input: { open_questions: [] },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-301',
+                status: 'open',
+                summary: 'First ambiguity',
+                obligation_ids: ['OBL-301'],
+              },
+              {
+                id: 'AMB-302',
+                status: 'open',
+                summary: 'Second ambiguity',
+                obligation_ids: ['OBL-302'],
+              },
+              // Ambiguity missing summary — should be skipped by readAllIntakeAmbiguities
+              { id: 'AMB-303', status: 'open', obligation_ids: [] },
+            ],
+            clarification_answers: [
+              {
+                // Missing question_id — falls back to 'unknown'
+                ambiguity_ids: ['AMB-301'],
+                // Non-string answer — gets JSON.stringified
+                answer: { key: 'structured' },
+                // Null answered_at — omits date from prompt line
+                answered_at: null,
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        prompt: expect.stringContaining('AMB-301'),
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-301', 'AMB-302'],
+          prior_answered_ambiguity_ids: ['AMB-301'],
+        }),
+      }),
+    );
+  });
+
+  it('GIVEN_planner_intake_submission_throws_null_error_WHEN_executed_THEN_rethrows_because_failure_details_are_null', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: { verified_manifest: { feature_id: 'feature_a' } },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw null;
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    await expect(
+      loop.execute({
+        role: 'planner',
+        featureId: 'feature_a',
+        contextBundle: {
+          state: { front_matter: { status: STATUS.INTAKE } },
+          intake: {
+            verified_manifest: null,
+            summary: { status: 'in_progress', verified_manifest_version: null },
+            review: { ambiguities: [] },
+          },
+        },
+        instructions: 'intake',
+      }),
+    ).rejects.toBeNull();
+  });
+
+  it('GIVEN_intake_submission_invalid_with_ambiguity_missing_id_WHEN_rerouted_THEN_skips_malformed_ambiguity', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: { verified_manifest: { feature_id: 'feature_a' } },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+              message: 'missing evidence',
+              details: {},
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+        return { ok: true, data: { accepted: true, question_id: 'q_skip' } };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: { front_matter: { status: STATUS.INTAKE } },
+        human_input: { open_questions: [] },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          review: {
+            ambiguities: [
+              // Valid ambiguity
+              { id: 'AMB-501', status: 'open', summary: 'Valid one', obligation_ids: ['OBL-501'] },
+              // Missing id — should be skipped
+              { status: 'open', summary: 'No id ambiguity', obligation_ids: [] },
+              // Missing summary — should be skipped
+              { id: 'AMB-503', status: 'open', obligation_ids: [] },
+              // Non-array ambiguities context — tests fallback to empty array
+              'not-an-object',
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-501'],
+        }),
+      }),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_during_intake_with_no_ambiguities_array_WHEN_executed_THEN_suppresses_plan_and_marks_handled', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: { feature_id: 'feature_a', plan_version: 2, summary: 'amend' },
+        expected_plan_version: 1,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        plan: { plan_version: 1 },
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: { status: 'in_progress', verified_manifest_version: null },
+          },
+        },
+        human_input: 'not-an-object',
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          // No review.ambiguities — tests non-array fallback branches
+          review: {},
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(false);
+    expect(result.questionRequested).toBe(false);
+  });
+
+  it('GIVEN_intake_submission_invalid_with_non_array_ambiguities_WHEN_recovery_routes_THEN_handles_gracefully', async () => {
+    const provider = makeProvider({
+      type: 'INTAKE_SUBMISSION',
+      intake_submission: { verified_manifest: { feature_id: 'feature_a' } },
+    });
+    const toolCaller = makeToolCaller();
+    toolCaller.callTool.mockImplementation(async (_role: string, toolName: string) => {
+      if (toolName === TOOLS.FEATURE_INTAKE_SUBMIT) {
+        throw {
+          normalizedResponse: {
+            error: {
+              code: ERROR_CODES.INTAKE_SUBMISSION_INVALID,
+              message: 'missing evidence',
+              details: { open_ambiguity_ids: ['AMB-601'] },
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_QUESTION_CREATE) {
+        return { ok: true, data: { accepted: true, question_id: 'q_fallback' } };
+      }
+      return { ok: true, data: { accepted: true } };
+    });
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        state: { front_matter: { status: STATUS.INTAKE } },
+        human_input: { open_questions: [] },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          // review.ambiguities is not an array — tests non-array fallback
+          review: { ambiguities: 'not-an-array' },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.questionRequested).toBe(true);
+    // AMB-601 comes from error details, not from context ambiguities
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        details: expect.objectContaining({
+          ambiguity_ids: ['AMB-601'],
+        }),
+      }),
+    );
+  });
+
+  it('GIVEN_planner_amend_plan_during_unverified_intake_without_session_resolver_WHEN_rerouted_THEN_uses_bootstrap_session_id', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 2,
+          summary: 'Amend attempt during intake',
+        },
+        expected_plan_version: 1,
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      // No resolveRoleSessionId — should fall back to bootstrap:planner
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: {
+        plan: { plan_version: 1 },
+        state: {
+          front_matter: {
+            status: STATUS.INTAKE,
+            intake: { status: 'in_progress', verified_manifest_version: null },
+          },
+        },
+        human_input: { open_questions: [] },
+        intake: {
+          verified_manifest: null,
+          summary: { status: 'in_progress', verified_manifest_version: null },
+          review: {
+            ambiguities: [
+              {
+                id: 'AMB-401',
+                status: 'open',
+                summary: 'Clarify boundary.',
+                obligation_ids: ['OBL-401'],
+              },
+            ],
+          },
+        },
+      },
+      instructions: 'intake',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.questionRequested).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_QUESTION_CREATE,
+      expect.objectContaining({
+        session_id: 'bootstrap:planner',
+      }),
+    );
+  });
+});
+
+describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
+  function makeProvider(runWorkerResult: Record<string, unknown>) {
+    return {
+      selection: { provider: 'custom', model: 'model-test', provider_config_ref: null },
+      runWorker: vi.fn(async () => runWorkerResult),
+    };
+  }
+
+  function makeToolCaller() {
+    return {
+      callTool: vi.fn(async (_role: string, toolName: string, _input?: unknown) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return { ok: true, data: { refreshed: true } };
+        }
+        return { ok: true, data: { accepted: true } };
+      }),
+    };
+  }
+
+  it('GIVEN_amend_plan_with_non_integer_revision_of_WHEN_existing_version_present_THEN_falls_back_to_existing_version', async () => {
+    const provider = makeProvider({
+      type: 'REQUEST',
+      request: {
+        action: 'amend_plan',
+        expected_plan_version: 'not-a-number',
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 3,
+        },
+      },
+    });
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+    });
+
+    const result = await loop.execute({
+      role: 'planner',
+      featureId: 'feature_a',
+      contextBundle: { plan: { plan_version: 2 } },
+      instructions: 'amend',
+    });
+
+    expect(result.requestHandled).toBe(true);
+    expect(result.planSubmission).toBe(true);
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_UPDATE,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        expected_plan_version: 2,
+      }),
+    );
+  });
+});
+
+describe('WorkerDecisionLoop runtime event journaling runId branches', () => {
+  function makeProvider(runWorkerResult: Record<string, unknown>) {
+    return {
+      selection: { provider: 'custom', model: 'model-test', provider_config_ref: null },
+      runWorker: vi.fn(async () => runWorkerResult),
+    };
+  }
+
+  function makeToolCaller() {
+    return {
+      callTool: vi.fn(async () => ({ ok: true, data: { accepted: true } })),
+    };
+  }
+
+  it('uses explicit string runId when journaling worker events', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:string-id',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'note',
+    });
+
+    const filePath = path.join(repoRoot, '.aop', 'runtime', 'worker-events', 'run:string-id.jsonl');
+    await expect(fs.readFile(filePath, 'utf8')).resolves.toContain('"run_id":"run:string-id"');
+  });
+
+  it('falls back to generated runId when configured runId string is empty', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: '',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'note',
+    });
+
+    const workerEventsDir = path.join(repoRoot, '.aop', 'runtime', 'worker-events');
+    const files = await fs.readdir(workerEventsDir);
+    expect(files.some((entry) => entry.startsWith('run:unknown:'))).toBe(true);
+  });
+
+  it('uses function-type runId when journaling worker events', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: () => 'run:from-fn',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'note',
+    });
+
+    const filePath = path.join(repoRoot, '.aop', 'runtime', 'worker-events', 'run:from-fn.jsonl');
+    await expect(fs.readFile(filePath, 'utf8')).resolves.toContain('"run_id":"run:from-fn"');
+  });
+
+  it('falls back to generated runId when function-type runId returns empty string', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({ type: 'NOTE', content: 'hello' }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: () => '',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'note',
+    });
+
+    const workerEventsDir = path.join(repoRoot, '.aop', 'runtime', 'worker-events');
+    const files = await fs.readdir(workerEventsDir);
+    expect(files.some((entry) => entry.startsWith('run:unknown:'))).toBe(true);
+  });
+
+  it('includes usage metadata in journal event when provider reports usage', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const usageData = {
+      status: 'reported',
+      input_tokens: 1000,
+      output_tokens: 500,
+      total_tokens: 1500,
+      provider: 'claude',
+      model: 'claude-3',
+      role: 'builder',
+      estimated_cost_usd: 0.05,
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({
+        outputs: [{ type: 'NOTE', content: 'done' }],
+        usage: usageData,
+      }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:usage-journal',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_usage_journal',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    const filePath = path.join(
+      repoRoot,
+      '.aop',
+      'runtime',
+      'worker-events',
+      'run:usage-journal.jsonl',
+    );
+    const content = await fs.readFile(filePath, 'utf8');
+    const events = content
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l));
+    const successEvent = events.find(
+      (e: Record<string, unknown>) => e.event_type === 'worker_completed',
+    );
+    expect(successEvent).toBeDefined();
+    expect(successEvent.usage).toMatchObject({
+      status: 'reported',
+      input_tokens: 1000,
+      output_tokens: 500,
+      total_tokens: 1500,
+    });
+  });
+
+  it('sets usage to null in journal event when provider returns no usage', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-events-'));
+    const loop = new WorkerDecisionLoop({
+      provider: makeProvider({ outputs: [{ type: 'NOTE', content: 'done' }] }) as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:no-usage-journal',
+    });
+
+    await loop.execute({
+      role: 'builder',
+      featureId: 'feature_no_usage_journal',
+      contextBundle: {},
+      instructions: 'build',
+    });
+
+    const filePath = path.join(
+      repoRoot,
+      '.aop',
+      'runtime',
+      'worker-events',
+      'run:no-usage-journal.jsonl',
+    );
+    const content = await fs.readFile(filePath, 'utf8');
+    const events = content
+      .trim()
+      .split('\n')
+      .map((l) => JSON.parse(l));
+    const successEvent = events.find(
+      (e: Record<string, unknown>) => e.event_type === 'worker_completed',
+    );
+    expect(successEvent).toBeDefined();
+    expect(successEvent.usage).toBeNull();
+  });
+});
+
+describe('WorkerDecisionLoop runtime failure event classification', () => {
+  function makeToolCaller() {
+    return {
+      callTool: vi.fn(async () => ({ ok: true, data: {} })),
+    };
+  }
+
+  async function readWorkerEvents(
+    repoRoot: string,
+    runId: string,
+  ): Promise<Record<string, unknown>[]> {
+    const filePath = path.join(repoRoot, '.aop', 'runtime', 'worker-events', `${runId}.jsonl`);
+    const content = await fs.readFile(filePath, 'utf8');
+    return content
+      .trim()
+      .split('\n')
+      .filter((line) => line.length > 0)
+      .map((line) => JSON.parse(line) as Record<string, unknown>);
+  }
+
+  it('classifies timeout-family runtime failures as worker_timeout with watchdog metadata', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-failure-'));
+    const timeoutError = new Error('idle timeout') as Error & {
+      code?: string;
+      details?: Record<string, unknown>;
+    };
+    timeoutError.code = 'provider_stall_timeout';
+    timeoutError.details = {
+      watchdog_reason: 'idle_timeout',
+      timeout_ms: 600000,
+      idle_timeout_ms: 120000,
+      spawn_timeout_ms: 15000,
+      idle_for_ms: 120500,
+      elapsed_ms: 130000,
+      signal: 'SIGKILL',
+      exit_code: 1,
+    };
+
+    const loop = new WorkerDecisionLoop({
+      provider: {
+        selection: { provider: 'codex', model: 'model-test', provider_config_ref: null },
+        runWorker: vi.fn(async () => {
+          throw timeoutError;
+        }),
+      } as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:timeout',
+    });
+
+    await expect(
+      loop.execute({
+        role: 'builder',
+        featureId: 'feature-a',
+        contextBundle: {},
+        instructions: 'build',
+      }),
+    ).rejects.toMatchObject({ code: 'provider_stall_timeout' });
+
+    const events = await readWorkerEvents(repoRoot, 'run:timeout');
+    expect(events.at(-1)).toMatchObject({
+      event_type: 'worker_timeout',
+      error_code: 'provider_stall_timeout',
+      watchdog_reason: 'idle_timeout',
+      timeout_ms: 600000,
+      idle_timeout_ms: 120000,
+      spawn_timeout_ms: 15000,
+      idle_for_ms: 120500,
+      elapsed_ms: 130000,
+      signal: 'SIGKILL',
+      exit_code: 1,
+    });
+  });
+
+  it('classifies non-timeout runtime failures as worker_failed with fallback error code', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-failure-'));
+    const failedError = new Error('provider crashed');
+
+    const loop = new WorkerDecisionLoop({
+      provider: {
+        selection: { provider: 'codex', model: 'model-test', provider_config_ref: null },
+        runWorker: vi.fn(async () => {
+          throw failedError;
+        }),
+      } as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:failed',
+    });
+
+    await expect(
+      loop.execute({
+        role: 'qa',
+        featureId: 'feature-b',
+        contextBundle: {},
+        instructions: 'qa',
+      }),
+    ).rejects.toThrow('provider crashed');
+
+    const events = await readWorkerEvents(repoRoot, 'run:failed');
+    expect(events.at(-1)).toMatchObject({
+      event_type: 'worker_failed',
+      error_code: 'provider_runtime_unavailable',
+      watchdog_reason: null,
+    });
+  });
+
+  it('includes stderr in failure event when provider error carries stderr details', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-failure-'));
+    const stderrError = new Error('runtime crashed') as Error & {
+      code?: string;
+      details?: Record<string, unknown>;
+    };
+    stderrError.code = 'provider_stall_timeout';
+    stderrError.details = {
+      watchdog_reason: 'spawn_timeout',
+      timeout_ms: 60000,
+      stderr: 'fatal: out of memory',
+      signal: 'SIGTERM',
+      exit_code: 137,
+    };
+
+    const loop = new WorkerDecisionLoop({
+      provider: {
+        selection: { provider: 'codex', model: 'model-test', provider_config_ref: null },
+        runWorker: vi.fn(async () => {
+          throw stderrError;
+        }),
+      } as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot,
+      runId: 'run:stderr',
+    });
+
+    await expect(
+      loop.execute({
+        role: 'builder',
+        featureId: 'feature-stderr',
+        contextBundle: {},
+        instructions: 'build',
+      }),
+    ).rejects.toMatchObject({ code: 'provider_stall_timeout' });
+
+    const events = await readWorkerEvents(repoRoot, 'run:stderr');
+    expect(events.at(-1)).toMatchObject({
+      event_type: 'worker_timeout',
+      stderr: 'fatal: out of memory',
+      signal: 'SIGTERM',
+      exit_code: 137,
+    });
+  });
+});
+
+describe('WorkerDecisionLoop interactive execution mode', () => {
+  function makeToolCaller() {
+    return {
+      callTool: vi.fn(async () => ({ ok: true, data: {} })),
+    };
+  }
+
+  it('passes working_directory and execution_mode to provider and records final checkpoint progress', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'interactive done' }],
+      })),
+    };
+    const watchdog = {
+      startWatching: vi.fn(async () => undefined),
+      stopWatching: vi.fn(async () => undefined),
+      on: vi.fn(),
+      off: vi.fn(),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-1',
+          timestamp: new Date().toISOString(),
+          files_changed: ['src/changed.ts'],
+          validation_status: 'valid',
+          violations: [],
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-1.diff',
+          net_new_worktree_change: true,
+        },
+        valid: true,
+        blockMerge: false,
+      })),
+    };
+    const toolCaller = makeToolCaller();
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'warning',
+      }),
+      watchdog: watchdog as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'work directly in the worktree',
+    });
+
+    expect(provider.runWorker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        execution_mode: 'interactive',
+        instructions: expect.stringContaining(
+          'Ignore any generic instruction that asks you to emit PATCH or unified diff output.',
+        ),
+        working_directory: '/tmp/worktrees/feature_a',
+      }),
+    );
+    expect(checkpointService.createCheckpoint).toHaveBeenCalledWith(
+      expect.objectContaining({
+        featureId: 'feature_a',
+        trigger: 'final',
+      }),
+    );
+    expect(result.patchApplied).toBe(true);
+    expect(result.invalidOutput).toBe(false);
+  });
+
+  it('marks decision checkpoint_invalid when final checkpoint validation fails with blockMerge', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'done' }],
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-invalid',
+          timestamp: new Date().toISOString(),
+          files_changed: ['src/disallowed.ts'],
+          validation_status: 'invalid',
+          violations: ['src/disallowed.ts: outside_allowed_areas'],
+          severity: 'error',
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-invalid.diff',
+          net_new_worktree_change: true,
+        },
+        valid: false,
+        blockMerge: true,
+      })),
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'error',
+      }),
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'write files',
+    });
+
+    expect(result.invalidOutput).toBe(false);
+    expect(result.errorCode).toBe('interactive_checkpoint_invalid');
+    expect(result.interactiveOutcome).toBe('checkpoint_invalid');
+    expect(result.checkpoint?.violations).toEqual(['src/disallowed.ts: outside_allowed_areas']);
+  });
+
+  it('does not block interactive progress when checkpoint violations are warning-only', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'done' }],
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-warning',
+          timestamp: new Date().toISOString(),
+          files_changed: ['src/warn.ts'],
+          validation_status: 'invalid',
+          violations: ['src/warn.ts: outside_allowed_areas'],
+          severity: 'warning',
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-warning.diff',
+          net_new_worktree_change: true,
+        },
+        valid: false,
+        blockMerge: false,
+      })),
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'warning',
+      }),
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'write files',
+    });
+
+    expect(result.errorCode).toBeNull();
+    expect(result.interactiveOutcome).toBe('progress_applied');
+    expect(result.patchApplied).toBe(true);
+    expect(result.noProgress).toBe(false);
+  });
+
+  it('captures error message in synthetic checkpoint when createCheckpoint throws', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'done' }],
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => {
+        throw new Error('Lock acquisition timed out');
+      }),
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'error',
+      }),
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'write files',
+    });
+
+    expect(result.interactiveOutcome).toBe('checkpoint_invalid');
+    expect(result.errorCode).toBe('interactive_checkpoint_invalid');
+    expect(result.checkpoint).toBeDefined();
+    expect(result.checkpoint?.violations).toEqual(['Lock acquisition timed out']);
+    expect(result.checkpoint?.validation_status).toBe('invalid');
+  });
+
+  it('marks malformed interactive provider output as provider_output_invalid', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ content: 'missing type field' }],
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-valid',
+          timestamp: new Date().toISOString(),
+          files_changed: [],
+          validation_status: 'valid',
+          violations: [],
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-valid.diff',
+          net_new_worktree_change: false,
+        },
+        valid: true,
+        blockMerge: false,
+      })),
+    };
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'warning',
+      }),
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'write files',
     });
-  });
 
-  it('classifies non-timeout runtime failures as worker_failed with fallback error code', async () => {
-    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-worker-failure-'));
-    const failedError = new Error('provider crashed');
+    expect(result.invalidOutput).toBe(true);
+    expect(result.errorCode).toBe('provider_output_invalid');
+    expect(result.interactiveOutcome).toBe('provider_output_invalid');
+  });
 
+  it('treats empty interactive provider output with no file changes as provider_output_invalid', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [
+          {
+            type: 'NOTE',
+            content: 'Interactive worker exited without a textual summary.',
+          },
+        ],
+        provider_meta: {
+          provider: 'custom',
+          model: 'model-test',
+          parse_fallback_reason: 'empty_output',
+        },
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-empty',
+          timestamp: new Date().toISOString(),
+          files_changed: [],
+          validation_status: 'valid',
+          violations: [],
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-empty.diff',
+          net_new_worktree_change: false,
+        },
+        valid: true,
+        blockMerge: false,
+      })),
+    };
     const loop = new WorkerDecisionLoop({
-      provider: {
-        selection: { provider: 'codex', model: 'model-test', provider_config_ref: null },
-        runWorker: vi.fn(async () => {
-          throw failedError;
-        }),
-      } as never,
+      provider: provider as never,
       toolCaller: makeToolCaller() as never,
-      repoRoot,
-      runId: 'run:failed',
-    });
-
-    await expect(
-      loop.execute({
-        role: 'qa',
-        featureId: 'feature-b',
-        contextBundle: {},
-        instructions: 'qa',
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'warning',
       }),
-    ).rejects.toThrow('provider crashed');
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
 
-    const events = await readWorkerEvents(repoRoot, 'run:failed');
-    expect(events.at(-1)).toMatchObject({
-      event_type: 'worker_failed',
-      error_code: 'provider_runtime_unavailable',
-      watchdog_reason: null,
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'write files',
     });
-  });
-});
 
-describe('WorkerDecisionLoop interactive execution mode', () => {
-  function makeToolCaller() {
-    return {
-      callTool: vi.fn(async () => ({ ok: true, data: {} })),
-    };
-  }
+    expect(result.invalidOutput).toBe(true);
+    expect(result.errorCode).toBe('provider_output_invalid');
+    expect(result.noteLogged).toBe(false);
+    expect(result.noProgress).toBe(true);
+    expect(result.interactiveOutcome).toBe('provider_output_invalid');
+  });
 
-  it('passes working_directory and execution_mode to provider and records final checkpoint progress', async () => {
+  it('does not treat PATCH payload output as progress in interactive mode without file changes', async () => {
     const provider = {
       selection: {
         provider: 'custom',
@@ -966,33 +3873,27 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
         supportsAcknowledgment: false,
       }),
       runWorker: vi.fn(async () => ({
-        outputs: [{ type: 'NOTE', content: 'interactive done' }],
+        outputs: [{ type: 'PATCH', unified_diff: '--- a/file\n+++ b/file\n@@ -0,0 +1 @@\n+x' }],
       })),
     };
-    const watchdog = {
-      startWatching: vi.fn(async () => undefined),
-      stopWatching: vi.fn(async () => undefined),
-      on: vi.fn(),
-      off: vi.fn(),
-    };
     const checkpointService = {
       createCheckpoint: vi.fn(async () => ({
         checkpoint: {
-          checkpoint_id: 'checkpoint-1',
+          checkpoint_id: 'checkpoint-empty',
           timestamp: new Date().toISOString(),
-          files_changed: ['src/changed.ts'],
+          files_changed: [],
           validation_status: 'valid',
           violations: [],
-          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-1.diff',
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-empty.diff',
+          net_new_worktree_change: false,
         },
         valid: true,
         blockMerge: false,
       })),
     };
-    const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never,
+      toolCaller: makeToolCaller() as never,
       repoRoot: '/tmp/repo',
       resolveExecutionMode: async () => 'interactive',
       resolveInteractiveConfig: () => ({
@@ -1003,7 +3904,12 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
         revertOnViolation: false,
         violationSeverity: 'warning',
       }),
-      watchdog: watchdog as never,
+      watchdog: {
+        startWatching: vi.fn(async () => undefined),
+        stopWatching: vi.fn(async () => undefined),
+        on: vi.fn(),
+        off: vi.fn(),
+      } as never,
       checkpointService: checkpointService as never,
       resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
       resolveRoleSessionId: () => 'builder-session-1',
@@ -1013,26 +3919,15 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'work directly in the worktree',
+      instructions: 'build',
     });
 
-    expect(provider.runWorker).toHaveBeenCalledWith(
-      expect.objectContaining({
-        execution_mode: 'interactive',
-        working_directory: '/tmp/worktrees/feature_a',
-      }),
-    );
-    expect(checkpointService.createCheckpoint).toHaveBeenCalledWith(
-      expect.objectContaining({
-        featureId: 'feature_a',
-        trigger: 'final',
-      }),
-    );
-    expect(result.patchApplied).toBe(true);
+    expect(result.patchApplied).toBe(false);
+    expect(result.noProgress).toBe(true);
     expect(result.invalidOutput).toBe(false);
   });
 
-  it('marks decision invalid when final checkpoint validation fails', async () => {
+  it('preserves interactive fallback NOTE output when the checkpoint proves file progress', async () => {
     const provider = {
       selection: {
         provider: 'custom',
@@ -1047,22 +3942,27 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
         supportsAcknowledgment: false,
       }),
       runWorker: vi.fn(async () => ({
-        outputs: [{ type: 'NOTE', content: 'done' }],
+        outputs: [{ type: 'NOTE', content: 'Completed edits directly in worktree' }],
+        provider_meta: {
+          provider: 'custom',
+          model: 'model-test',
+          parse_fallback_reason: 'invalid_json',
+        },
       })),
     };
     const checkpointService = {
       createCheckpoint: vi.fn(async () => ({
         checkpoint: {
-          checkpoint_id: 'checkpoint-invalid',
+          checkpoint_id: 'checkpoint-progress',
           timestamp: new Date().toISOString(),
-          files_changed: ['src/disallowed.ts'],
-          validation_status: 'invalid',
-          violations: ['src/disallowed.ts: outside_allowed_areas'],
-          severity: 'error',
-          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-invalid.diff',
+          files_changed: ['src/feature.ts'],
+          validation_status: 'valid',
+          violations: [],
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-progress.diff',
+          net_new_worktree_change: true,
         },
-        valid: false,
-        blockMerge: true,
+        valid: true,
+        blockMerge: false,
       })),
     };
     const loop = new WorkerDecisionLoop({
@@ -1076,7 +3976,7 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
         maxUncommittedChanges: 50,
         validationOnCheckpoint: true,
         revertOnViolation: false,
-        violationSeverity: 'error',
+        violationSeverity: 'warning',
       }),
       watchdog: {
         startWatching: vi.fn(async () => undefined),
@@ -1096,11 +3996,14 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
       instructions: 'write files',
     });
 
-    expect(result.invalidOutput).toBe(true);
-    expect(result.noProgress).toBe(false);
+    expect(result.invalidOutput).toBe(false);
+    expect(result.errorCode).toBeNull();
+    expect(result.noteLogged).toBe(true);
+    expect(result.patchApplied).toBe(true);
+    expect(result.interactiveOutcome).toBe('progress_applied');
   });
 
-  it('falls back to deterministic worker input when interactive mode is requested but ineligible', async () => {
+  it('does not treat duplicate checkpoint snapshots as new patch progress in interactive mode', async () => {
     const provider = {
       selection: {
         provider: 'custom',
@@ -1115,25 +4018,85 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
         supportsAcknowledgment: false,
       }),
       runWorker: vi.fn(async () => ({
-        outputs: [{ type: 'NOTE', content: 'planner-pass' }],
+        outputs: [{ type: 'NOTE', content: 'no new changes' }],
+      })),
+    };
+    const checkpointService = {
+      createCheckpoint: vi.fn(async () => ({
+        checkpoint: {
+          checkpoint_id: 'checkpoint-duplicate',
+          timestamp: new Date().toISOString(),
+          files_changed: ['src/stale.ts'],
+          validation_status: 'skipped',
+          violations: [],
+          diff_snapshot: '.aop/features/feature_a/checkpoints/checkpoint-duplicate.diff',
+          net_new_worktree_change: false,
+          duplicate_of_checkpoint_id: 'checkpoint-prev',
+        },
+        valid: true,
+        blockMerge: false,
       })),
     };
-
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
       toolCaller: makeToolCaller() as never,
       repoRoot: '/tmp/repo',
       resolveExecutionMode: async () => 'interactive',
-      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveInteractiveConfig: () => ({
+        checkpointIntervalMs: 60_000,
+        watchdogPollIntervalMs: 2_000,
+        maxUncommittedChanges: 50,
+        validationOnCheckpoint: true,
+        revertOnViolation: false,
+        violationSeverity: 'warning',
+      }),
       watchdog: {
         startWatching: vi.fn(async () => undefined),
         stopWatching: vi.fn(async () => undefined),
         on: vi.fn(),
         off: vi.fn(),
       } as never,
-      checkpointService: {
-        createCheckpoint: vi.fn(),
-      } as never,
+      checkpointService: checkpointService as never,
+      resolveWorktreePath: (featureId: string) => `/tmp/worktrees/${featureId}`,
+      resolveRoleSessionId: () => 'builder-session-1',
+    });
+
+    const result = await loop.execute({
+      role: 'builder',
+      featureId: 'feature_a',
+      contextBundle: {},
+      instructions: 'inspect the worktree',
+    });
+
+    expect(result.patchApplied).toBe(false);
+    expect(result.noProgress).toBe(true);
+    expect(result.invalidOutput).toBe(false);
+  });
+
+  it('runs planner interactively from the feature directory when interactive mode is requested', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'planner-pass' }],
+      })),
+    };
+
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      repoRoot: '/tmp/repo',
+      resolveExecutionMode: async () => 'interactive',
     });
 
     const result = await loop.execute({
@@ -1143,12 +4106,52 @@ describe('WorkerDecisionLoop interactive execution mode', () => {
       instructions: 'plan',
     });
 
+    expect(provider.runWorker).toHaveBeenCalledWith(
+      expect.objectContaining({
+        execution_mode: 'interactive',
+        working_directory: '/tmp/repo/.aop/features/feature_planner',
+      }),
+    );
+    expect(result.invalidOutput).toBe(false);
+  });
+
+  it('falls back to deterministic planner input when interactive mode is requested without a repo root', async () => {
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test',
+        provider_config_ref: null,
+      },
+      getCapabilities: () => ({
+        supportsInteractiveMode: true,
+        supportsWorkingDirectory: true,
+        supportsPauseResume: false,
+        supportsMessagePassing: false,
+        supportsAcknowledgment: false,
+      }),
+      runWorker: vi.fn(async () => ({
+        outputs: [{ type: 'NOTE', content: 'planner-pass' }],
+      })),
+    };
+
+    const loop = new WorkerDecisionLoop({
+      provider: provider as never,
+      toolCaller: makeToolCaller() as never,
+      resolveExecutionMode: async () => 'interactive',
+    });
+
+    await loop.execute({
+      role: 'planner',
+      featureId: 'feature_planner',
+      contextBundle: {},
+      instructions: 'plan',
+    });
+
     expect(provider.runWorker).toHaveBeenCalledWith(
       expect.objectContaining({
         execution_mode: 'deterministic',
         working_directory: undefined,
       }),
     );
-    expect(result.invalidOutput).toBe(false);
   });
 });