agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/supervisor.spec.ts

@@ -71,12 +71,17 @@ async function initFeature(kernel: AopKernel, featureId: string) {
   const init = await kernel.invoke('feature.init', { feature_id: featureId }, { actor_type: 'orchestrator', actor_id: 'test' });
   expect(init.ok).toBe(true);
 }
-
-async function readIndex() {
-  const raw = await fs.readFile(path.join(repoRoot, '.aop', 'features', 'index.json'), 'utf8');
+async function readRunLease() {
+  const leaseFile = path.join(repoRoot, '.aop', 'runtime', 'default', 'run-lease.json');
+  const raw = await fs.readFile(leaseFile, 'utf8');
   return JSON.parse(raw);
 }
 
+async function writeRunLease(data: Record<string, unknown>) {
+  const leaseFile = path.join(repoRoot, '.aop', 'runtime', 'default', 'run-lease.json');
+  await fs.writeFile(leaseFile, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
 function expectConcreteWorkerSessions(assignment: Record<string, string>) {
   expect(assignment.planner_session_id).not.toBe('unassigned');
   expect(assignment.builder_session_id).not.toBe('unassigned');
@@ -131,8 +136,7 @@ describe('SupervisorRuntime topology', () => {
 
     await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
 
-    const index = await readIndex();
-    const sessions = index.runtime_sessions;
+    const sessions = await readRunLease();
 
     expect(sessions.orchestrator_session_id).not.toBe('unknown');
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_a);
@@ -164,8 +168,7 @@ describe('SupervisorRuntime topology', () => {
 
     await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }, { feature_id: 'feature_c' }]);
 
-    const index = await readIndex();
-    const sessions = index.runtime_sessions;
+    const sessions = await readRunLease();
     expect(sessions.orchestrator_session_id).not.toBe('unknown');
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_a);
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_b);
@@ -201,8 +204,7 @@ describe('SupervisorRuntime topology', () => {
     const result = await runtime.start(featureIds.map((feature_id) => ({ feature_id })));
     expect(result.queue_depth).toBe(2);
 
-    const index = await readIndex();
-    const sessions = index.runtime_sessions;
+    const sessions = await readRunLease();
     const active = ['feature_a', 'feature_b', 'feature_c'];
     const queued = ['feature_d', 'feature_e'];
 
@@ -220,6 +222,15 @@ describe('SupervisorRuntime topology', () => {
 
   it('promotes queued feature when an admitted feature is already terminal at admission time', async () => {
     const { kernel, tooling, provider } = await boot();
+    kernel.policy.reactions = {
+      gate_failed: {
+        enabled: false,
+        max_retries: 0,
+        action: 'notify_only',
+        escalate_after: 0,
+        retry_delay_ms: 0
+      }
+    };
 
     for (const featureId of ['feature_a', 'feature_b']) {
       await writeFeatureSpec(repoRoot, featureId);
@@ -264,8 +275,7 @@ describe('SupervisorRuntime topology', () => {
     const result = await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
     expect(result.queue_depth).toBe(0);
 
-    const index = await readIndex();
-    const sessions = index.runtime_sessions;
+    const sessions = await readRunLease();
     expectConcreteWorkerSessions(sessions.feature_sessions.feature_b);
     expect(sessions.feature_sessions.feature_a).toBeUndefined();
     expect(countAllocatedSessionIds(sessions)).toBe(4);
@@ -287,12 +297,11 @@ describe('SupervisorRuntime topology', () => {
     });
 
     await runtime.start(featureIds.map((feature_id) => ({ feature_id })));
-    const firstIndex = await readIndex();
-    expect(Object.keys(firstIndex.runtime_sessions.feature_sessions).sort()).toEqual(featureIds);
+    const firstLease = await readRunLease();
+    expect(Object.keys(firstLease.feature_sessions).sort()).toEqual(featureIds);
 
     await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
-    const secondIndex = await readIndex();
-    const secondSessions = secondIndex.runtime_sessions;
+    const secondSessions = await readRunLease();
 
     expect(Object.keys(secondSessions.feature_sessions).sort()).toEqual(['feature_a', 'feature_b']);
     expect(countAllocatedSessionIds(secondSessions)).toBe(7);
@@ -336,10 +345,9 @@ describe('SupervisorRuntime topology', () => {
     });
     await first.start([{ feature_id: 'feature_takeover' }]);
 
-    const indexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
-    const index = await readIndex();
-    index.runtime_sessions.lease_expires_at = new Date(Date.now() - 60_000).toISOString();
-    await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, 'utf8');
+    const lease = await readRunLease();
+    lease.lease_expires_at = new Date(Date.now() - 60_000).toISOString();
+    await writeRunLease(lease);
 
     const withoutTakeover = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:stale-target-no-takeover',
@@ -363,9 +371,9 @@ describe('SupervisorRuntime topology', () => {
 
     await withTakeover.start([{ feature_id: 'feature_takeover' }]);
 
-    const postTakeover = await readIndex();
-    expect(postTakeover.runtime_sessions.run_id).toBe('run:stale-target-with-takeover');
-    expect(postTakeover.runtime_sessions.owner_instance_id).toContain('supervisor:');
+    const postTakeover = await readRunLease();
+    expect(postTakeover.run_id).toBe('run:stale-target-with-takeover');
+    expect(postTakeover.owner_instance_id).toContain('supervisor:');
   });
 
   it('recreates orchestrator on timed-out reattach with epoch increment and orphan audit metadata', async () => {
@@ -388,18 +396,16 @@ describe('SupervisorRuntime topology', () => {
     });
 
     await runtime.start([{ feature_id: 'feature_recovery' }]);
-    const firstIndex = await readIndex();
-    const firstOrchestratorSession = firstIndex.runtime_sessions.orchestrator_session_id;
+    const firstLease = await readRunLease();
+    const firstOrchestratorSession = firstLease.orchestrator_session_id;
 
-    const indexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
-    firstIndex.runtime_sessions.lease_expires_at = new Date(Date.now() - 60_000).toISOString();
-    await fs.writeFile(indexPath, `${JSON.stringify(firstIndex, null, 2)}\n`, 'utf8');
+    firstLease.lease_expires_at = new Date(Date.now() - 60_000).toISOString();
+    await writeRunLease(firstLease);
 
     await runtime.start([{ feature_id: 'feature_recovery' }]);
 
-    const recoveredIndex = await readIndex();
-    const sessions = recoveredIndex.runtime_sessions;
-    expect(sessions.orchestrator_epoch).toBe(firstIndex.runtime_sessions.orchestrator_epoch + 1);
+    const sessions = await readRunLease();
+    expect(sessions.orchestrator_epoch).toBe(firstLease.orchestrator_epoch + 1);
     expect(sessions.orchestrator_session_id).not.toBe(firstOrchestratorSession);
     expect(provider.orchestratorSessionIds).toHaveLength(2);
     expect(provider.orchestratorSessionIds[0]).toBe(firstOrchestratorSession);

package/apps/control-plane/test/supervisor.unit.spec.ts

@@ -520,3 +520,408 @@ describe('SupervisorRuntime unit behavior', () => {
     vi.restoreAllMocks();
   });
 });
+
+describe('SupervisorRuntime delegation methods', () => {
+  it('GIVEN_policy_with_agent_idle_threshold_WHEN_runtime_created_THEN_applies_configured_idle_threshold', () => {
+    const { kernel, provider, toolClient } = makeRuntime();
+    kernel.getPolicySnapshot.mockReturnValue({
+      recovery: { orchestrator_session_reattach_timeout_ms: 5000, orphan_session_cleanup_enabled: true },
+      supervisor: { agent_idle_threshold_ms: 60000 }
+    });
+
+    expect(() => new SupervisorRuntime(kernel as any, provider as any, toolClient as any)).not.toThrow();
+  });
+
+  it('GIVEN_planner_role_with_sessions_WHEN_calling_tool_THEN_uses_planner_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: { result: 'plan-submitted' } });
+
+    await runtime.callTool('planner', TOOLS.PLAN_SUBMIT, { feature_id: 'feature_a', plan_json: {} });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.PLAN_SUBMIT,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'planner-session', actor_type: 'planner' })
+    );
+  });
+
+  it('GIVEN_qa_role_with_sessions_WHEN_calling_tool_THEN_uses_qa_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
+
+    await runtime.callTool('qa', TOOLS.GATES_RUN, { feature_id: 'feature_a', mode: 'full' });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'qa-session', actor_type: 'qa' })
+    );
+  });
+
+  it('GIVEN_orchestrator_role_WHEN_calling_tool_THEN_uses_orchestrator_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.orchestratorSessionId = 'orch-main';
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
+
+    await runtime.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, { feature_id: 'global', note: 'test' });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_LOG_APPEND,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'orch-main', actor_type: 'orchestrator' })
+    );
+  });
+
+  it('GIVEN_no_feature_id_in_args_WHEN_calling_tool_THEN_uses_bootstrap_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
+
+    await runtime.callTool('builder', TOOLS.FEATURE_STATE_GET, {});
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_GET,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'bootstrap:builder' })
+    );
+  });
+
+  it('GIVEN_feature_not_in_sessions_map_WHEN_calling_tool_THEN_uses_bootstrap_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
+
+    await runtime.callTool('planner', TOOLS.FEATURE_STATE_GET, { feature_id: 'feature_not_tracked' });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_GET,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'bootstrap:planner' })
+    );
+  });
+
+  it('GIVEN_unknown_role_with_sessions_WHEN_calling_tool_THEN_uses_bootstrap_session', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+    toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
+
+    await runtime.callTool('unknown' as never, TOOLS.FEATURE_STATE_GET, { feature_id: 'feature_a' });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_GET,
+      expect.anything(),
+      expect.objectContaining({ session_id: 'bootstrap:unknown' })
+    );
+  });
+
+  it('GIVEN_feature_id_WHEN_running_post_qa_reconciliation_wave_THEN_delegates_to_planning_executor', async () => {
+    const { runtime } = makeRuntime();
+    const callTool = vi.spyOn(runtime, 'callTool');
+    callTool.mockImplementation(async (_role, toolName) => {
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+        return {
+          ok: true,
+          data: {
+            state: { front_matter: { status: STATUS.QA } },
+            plan: { plan_version: 1, acceptance_criteria: [], risk: [] },
+            spec: '',
+            qa_test_index: { summary: { pending: 0, failed: 0, running: 0 } },
+            latest_evidence: {}
+          }
+        } as any;
+      }
+      return { ok: true, data: {} } as any;
+    });
+
+    await runtime.runPostQaReconciliationWave(['feature_a'], 1);
+
+    expect(callTool).toHaveBeenCalledWith('planner', TOOLS.FEATURE_GET_CONTEXT, { feature_id: 'feature_a' });
+  });
+
+  it('GIVEN_orphan_cleanup_disabled_WHEN_reattach_fails_THEN_skips_orphan_log', async () => {
+    const { runtime, kernel, provider, toolClient } = makeRuntime();
+    kernel.getPolicySnapshot.mockReturnValue({
+      recovery: {
+        orchestrator_session_reattach_timeout_ms: 10,
+        orphan_session_cleanup_enabled: false
+      }
+    });
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch-old',
+      orchestrator_epoch: 4,
+      feature_sessions: {}
+    });
+    provider.reattachSession.mockImplementation(
+      () => new Promise(() => { /* intentionally unresolved to force timeout */ })
+    );
+    provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
+
+    await runtime.ensureGlobalOrchestratorSession();
+
+    expect(runtime.orchestratorSessionId).toBe('orch-new');
+    const logCalls = toolClient.call.mock.calls.filter((call: unknown[]) => call[0] === TOOLS.FEATURE_LOG_APPEND);
+    expect(logCalls).toHaveLength(0);
+  });
+
+  it('GIVEN_feature_id_WHEN_initializeFeatureCluster_called_THEN_delegates_to_session_orchestrator', async () => {
+    const { runtime, provider, toolClient } = makeRuntime();
+    runtime.orchestratorSessionId = 'orch-main';
+    provider.createSession.mockResolvedValue({ session_id: 'created-session' });
+    vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
+      planner: { system: 'planner-prompt', tools: [], model_hint: null },
+      builder: { system: 'builder-prompt', tools: [], model_hint: null },
+      qa: { system: 'qa-prompt', tools: [], model_hint: null }
+    } as never);
+    toolClient.call.mockResolvedValue({ ok: true, data: { front_matter: { version: 1, cluster: {} } } });
+
+    await runtime.initializeFeatureCluster('feature_init');
+
+    // createSession should have been called for planner, builder, qa roles
+    expect(provider.createSession).toHaveBeenCalledTimes(3);
+  });
+
+  it('GIVEN_cluster_patch_WHEN_patchFeatureCluster_called_THEN_delegates_to_session_orchestrator', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    toolClient.call.mockResolvedValue({ ok: true, data: { front_matter: { version: 1, cluster: {} } } });
+
+    await runtime.patchFeatureCluster('feature_patch', { planner: 'planner-session', builder: 'builder-session', qa: 'qa-session' });
+
+    expect(toolClient.call).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({ feature_id: 'feature_patch' }),
+      expect.any(Object)
+    );
+  });
+
+  it('GIVEN_runtime_WHEN_ensureGlobalOrchestratorSession_called_THEN_creates_orchestrator_session', async () => {
+    const { runtime, provider, kernel } = makeRuntime();
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      orchestrator_session_id: null,
+      orchestrator_epoch: 0,
+      feature_sessions: {}
+    });
+    provider.createSession.mockResolvedValue({ session_id: 'new-orch-session', role: 'orchestrator', feature_id: 'global', system_prompt_loaded: false });
+
+    await runtime.ensureGlobalOrchestratorSession();
+    expect(provider.createSession).toHaveBeenCalled();
+  });
+
+  it('GIVEN_active_feature_ids_WHEN_cleanupOrphanWorkerSessions_called_THEN_delegates_to_session_orchestrator', async () => {
+    const { runtime, kernel } = makeRuntime();
+    kernel.getRuntimeSessions.mockResolvedValue({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'orch-session',
+      orchestrator_epoch: 1,
+      feature_sessions: {}
+    });
+
+    // Should complete without throwing
+    await expect(runtime.cleanupOrphanWorkerSessions(['feature_a', 'feature_b'])).resolves.toBeUndefined();
+  });
+
+  it('GIVEN_queue_WHEN_reconcileQueuedFeatures_called_THEN_delegates_to_session_orchestrator', async () => {
+    const { runtime } = makeRuntime();
+    // reconcileQueuedFeatures delegates to sessionOrchestrator using internal queue
+    await expect(runtime.reconcileQueuedFeatures()).resolves.toBeUndefined();
+  });
+
+  it('GIVEN_prompts_cached_WHEN_loadRolePrompts_called_THEN_returns_prompt_bundle', async () => {
+    const { runtime } = makeRuntime();
+    vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
+      planner: { system: 'p', tools: [], model_hint: null },
+      builder: { system: 'b', tools: [], model_hint: null },
+      qa: { system: 'q', tools: [], model_hint: null }
+    } as never);
+
+    const bundle = await runtime.loadRolePrompts();
+    expect(bundle.planner.system).toBe('p');
+  });
+
+  it('GIVEN_runtime_WHEN_sessionsByFeature_set_THEN_roundtrips_value', () => {
+    const { runtime } = makeRuntime();
+    const newMap = new Map([['feat1', { planner: 's1', builder: 's2', qa: 's3' }]]);
+    runtime.sessionsByFeature = newMap as never;
+    expect(runtime.sessionsByFeature.get('feat1')).toEqual({ planner: 's1', builder: 's2', qa: 's3' });
+  });
+
+  it('GIVEN_runtime_WHEN_queue_set_THEN_roundtrips_value', () => {
+    const { runtime } = makeRuntime();
+    const newQueue = [{ feature_id: 'q1' }, { feature_id: 'q2' }];
+    runtime.queue = newQueue as never;
+    expect(runtime.queue).toHaveLength(2);
+    expect(runtime.queue[0]).toEqual({ feature_id: 'q1' });
+  });
+
+  it('GIVEN_runtime_WHEN_runMetadata_set_and_get_THEN_roundtrips_value', () => {
+    const { runtime } = makeRuntime();
+    const meta = { run_id: 'abc', custom_field: 42 };
+    runtime.runMetadata = meta;
+    expect(runtime.runMetadata).toEqual(meta);
+  });
+
+  it('GIVEN_runtime_WHEN_promptsCache_set_and_get_THEN_roundtrips_value', () => {
+    const { runtime } = makeRuntime();
+    const bundle = {
+      planner: { system: 'planner-sys', tools: [], model_hint: null },
+      builder: { system: 'builder-sys', tools: [], model_hint: null },
+      qa: { system: 'qa-sys', tools: [], model_hint: null }
+    };
+    runtime.promptsCache = bundle as never;
+    expect(runtime.promptsCache).toEqual(bundle);
+  });
+
+  it('GIVEN_runtime_WHEN_promptsCache_set_to_null_THEN_returns_null', () => {
+    const { runtime } = makeRuntime();
+    runtime.promptsCache = null;
+    expect(runtime.promptsCache).toBeNull();
+  });
+
+  it('GIVEN_provider_with_config_ref_WHEN_providerConfigRefHash_called_THEN_returns_stable_hash', () => {
+    const { runtime, provider } = makeRuntime();
+    provider.selection.provider_config_ref = '/path/to/config.yaml';
+    const hash = runtime.providerConfigRefHash();
+    expect(typeof hash).toBe('string');
+    expect(hash.length).toBeGreaterThan(0);
+    // Calling again returns the same value
+    expect(runtime.providerConfigRefHash()).toBe(hash);
+  });
+
+  it('GIVEN_provider_with_null_config_ref_WHEN_providerConfigRefHash_called_THEN_returns_hash_of_none', () => {
+    const { runtime, provider } = makeRuntime();
+    provider.selection.provider_config_ref = null;
+    const hash = runtime.providerConfigRefHash();
+    expect(typeof hash).toBe('string');
+    expect(hash.length).toBeGreaterThan(0);
+  });
+
+  it('GIVEN_cli_override_iterations_WHEN_runtime_created_THEN_uses_cli_value', () => {
+    const { runtime } = makeRuntime({ max_iterations_per_phase: 12 });
+    // The resolved value is stored internally; verifying via runMetadata isn't needed
+    // but the construction should not throw
+    expect(runtime).toBeDefined();
+  });
+
+  it('GIVEN_policy_max_iterations_WHEN_no_cli_override_THEN_uses_policy_value', () => {
+    const { kernel } = makeRuntime();
+    kernel.getPolicySnapshot.mockReturnValue({
+      recovery: { orchestrator_session_reattach_timeout_ms: 5000, orphan_session_cleanup_enabled: true },
+      supervisor: { max_iterations_per_phase: 10, max_parallel_gate_runs: 2 }
+    });
+    const runtime2 = new SupervisorRuntime(kernel as any, { selection: { provider: 'custom', model: 'm', provider_config_ref: null }, createSession: vi.fn(), reattachSession: vi.fn(), closeSession: vi.fn() } as any, { call: vi.fn() } as any, { run_id: 'r', owner_instance_id: 'o' });
+    expect(runtime2).toBeDefined();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+});
+
+describe('PromptBundleLoader branches', () => {
+  it('GIVEN_behavior_error_WHEN_prompt_file_missing_THEN_throws_MISSING_ROLE_PROMPT', async () => {
+    const { PromptBundleLoader } = await import('../src/supervisor/prompt-bundle-loader.js');
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-prompt-'));
+    const reader = {
+      getRepoRoot: () => tmpDir,
+      getAgentsConfig: () => ({
+        roles: {
+          planner: { system_prompt_path: 'prompts/planner.md' }
+        },
+        missing_prompt_behavior: 'error'
+      })
+    };
+    const loader = new PromptBundleLoader(reader as never);
+    await expect(loader.loadRolePrompts()).rejects.toMatchObject({ code: ERROR_CODES.MISSING_ROLE_PROMPT });
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+});
+
+describe('BuildWaveExecutor branches', () => {
+  it('GIVEN_feature_in_building_status_WHEN_gate_passes_THEN_completes_without_retry', async () => {
+    const { BuildWaveExecutor } = await import('../src/supervisor/build-wave-executor.js');
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args?: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0 } } };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return { ok: true, data: { plan: null } };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+    const executor = new BuildWaveExecutor({ toolCaller: toolCaller as never });
+    await expect(executor.run(['feature_a'], 5)).resolves.toBeUndefined();
+    const gateRuns = toolCaller.callTool.mock.calls.filter((c) => c[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(1);
+  });
+});
+
+describe('QaWaveExecutor gate run throws exception', () => {
+  it('GIVEN_gates_run_throws_WHEN_qa_wave_executed_THEN_gate_overall_is_FAIL', async () => {
+    const { QaWaveExecutor } = await import('../src/supervisor/qa-wave-executor.js');
+    const sessionsByFeature = new Map<string, Record<string, string>>();
+    sessionsByFeature.set('feature_qa', { planner: 's1', builder: 's2', qa: 's3' });
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return { ok: true, data: { front_matter: { status: STATUS.QA, gate_retry_count: 0 } } };
+        }
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return { ok: true, data: { plan: null } };
+        }
+        if (toolName === TOOLS.GATES_RUN) {
+          throw new Error('gate execution failed');
+        }
+        return { ok: true, data: {} };
+      })
+    };
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch-sess',
+      sessionsByFeature
+    };
+    const kernel = {
+      updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } }))
+    };
+    const provider = {
+      closeSession: vi.fn(async () => ({ closed: true })),
+      createSession: vi.fn(async () => ({ session_id: 'new-session' }))
+    };
+    const promptProvider = {
+      loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null }))
+    };
+    const featureClusterPatcher = {
+      patchFeatureCluster: vi.fn(async () => ({}))
+    };
+    const executor = new QaWaveExecutor({
+      kernel: kernel as never,
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      promptProvider: promptProvider as never,
+      featureClusterPatcher: featureClusterPatcher as never,
+      state: state as never
+    });
+    await expect(executor.run(['feature_qa'], 5)).resolves.toBeUndefined();
+  });
+});

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

@@ -585,3 +585,60 @@ describe('WorkerDecisionLoop', () => {
     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) => {
+        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
+      })
+    );
+  });
+});