agentic-orchestrator 0.1.13 → 0.1.15

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

@@ -0,0 +1,284 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { STATUS, TOOLS } from '../src/core/constants.js';
+import { BuildWaveExecutor } from '../src/supervisor/build-wave-executor.js';
+import { QaWaveExecutor } from '../src/supervisor/qa-wave-executor.js';
+import type { WorkerDecisionResult } from '../src/supervisor/worker-decision-loop.js';
+
+function decision(overrides: Partial<WorkerDecisionResult>): WorkerDecisionResult {
+  return {
+    planSubmission: false,
+    patchApplied: false,
+    noteLogged: false,
+    requestHandled: false,
+    invalidOutput: false,
+    noProgress: false,
+    outputTypes: [],
+    priorityOrder: [],
+    toolResults: [],
+    ...overrides,
+  };
+}
+
+function buildToolCaller() {
+  const callTool = vi.fn(
+    async (role: string, toolName: string, _args?: Record<string, unknown>) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET && role === 'builder') {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              status: STATUS.BUILDING,
+              gate_retry_count: 0,
+              version: 3,
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_STATE_GET && role === 'orchestrator') {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 7,
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+        return { ok: true, data: { state: 'ctx' } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
+      }
+      return { ok: true, data: {} };
+    },
+  );
+  return { callTool };
+}
+
+function qaToolCaller() {
+  const callTool = vi.fn(
+    async (role: string, toolName: string, _args?: Record<string, unknown>) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET && role === 'qa') {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              status: STATUS.QA,
+              gate_retry_count: 0,
+              version: 5,
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_STATE_GET && role === 'orchestrator') {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 9,
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+        return { ok: true, data: { state: 'ctx' } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass', evidence_path: 'qa-evidence.json' } };
+      }
+      return { ok: true, data: {} };
+    },
+  );
+  return { callTool };
+}
+
+describe('BuildWaveExecutor live policy branches', () => {
+  it('GIVEN_invalid_output_and_block_policy_WHEN_run_THEN_blocks_feature_and_skips_gates', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(1);
+    expect(statePatches[0][2]).toMatchObject({
+      feature_id: 'feature-a',
+      patch: {
+        front_matter: {
+          status: STATUS.BLOCKED,
+        },
+      },
+    });
+  });
+
+  it('GIVEN_invalid_output_and_fail_run_policy_WHEN_run_THEN_throws_provider_output_invalid', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      malformedOutputAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ invalidOutput: true })),
+      },
+    });
+
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+    });
+  });
+
+  it('GIVEN_no_progress_below_limit_WHEN_run_THEN_skips_current_cycle_without_blocking', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      noProgressLimit: 2,
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ noProgress: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+    const statePatches = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_STATE_PATCH,
+    );
+    expect(statePatches).toHaveLength(0);
+  });
+
+  it('GIVEN_no_progress_at_limit_and_fail_run_policy_WHEN_run_THEN_throws_provider_no_progress', async () => {
+    const toolCaller = buildToolCaller();
+    const executor = new BuildWaveExecutor({
+      toolCaller: toolCaller as never,
+      providerMode: 'live',
+      noProgressLimit: 1,
+      noProgressAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ noProgress: true })),
+      },
+    });
+
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_NO_PROGRESS,
+    });
+  });
+});
+
+describe('QaWaveExecutor live policy branches', () => {
+  it('GIVEN_invalid_output_and_block_policy_WHEN_run_THEN_blocks_feature_and_skips_gate_and_session_rotation', async () => {
+    const toolCaller = qaToolCaller();
+    const kernel = {
+      updateFeatureSessionAssignment: vi.fn(async () => ({ ok: true })),
+    };
+    const provider = {
+      closeSession: vi.fn(async () => ({ closed: true })),
+      createSession: vi.fn(async () => ({ session_id: 'new-qa-session' })),
+    };
+    const promptProvider = {
+      loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
+    };
+    const featureClusterPatcher = {
+      patchFeatureCluster: vi.fn(async () => ({ ok: true })),
+    };
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch-session',
+      sessionsByFeature: new Map([['feature-a', { planner: 'p-1', builder: 'b-1', qa: 'q-1' }]]),
+    };
+    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,
+      providerMode: 'live',
+      malformedOutputAction: 'block_feature',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ invalidOutput: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+    expect(provider.closeSession).not.toHaveBeenCalled();
+    expect(kernel.updateFeatureSessionAssignment).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_no_progress_below_limit_WHEN_run_THEN_skips_current_cycle', async () => {
+    const toolCaller = qaToolCaller();
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: { loadRolePrompts: vi.fn() } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      noProgressLimit: 3,
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ noProgress: true })),
+      },
+    });
+
+    await executor.run(['feature-a'], 1);
+    const gateRuns = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.GATES_RUN);
+    expect(gateRuns).toHaveLength(0);
+  });
+
+  it('GIVEN_no_progress_at_limit_and_fail_run_policy_WHEN_run_THEN_throws_provider_no_progress', async () => {
+    const toolCaller = qaToolCaller();
+    const executor = new QaWaveExecutor({
+      kernel: { updateFeatureSessionAssignment: vi.fn() } as never,
+      provider: {
+        closeSession: vi.fn(),
+        createSession: vi.fn(),
+      } as never,
+      toolCaller: toolCaller as never,
+      promptProvider: { loadRolePrompts: vi.fn() } as never,
+      featureClusterPatcher: { patchFeatureCluster: vi.fn() } as never,
+      state: {
+        runId: 'run:test',
+        ownerInstanceId: 'owner:test',
+        orchestratorSessionId: 'orch-session',
+        sessionsByFeature: new Map(),
+      } as never,
+      providerMode: 'live',
+      noProgressLimit: 1,
+      noProgressAction: 'fail_run',
+      workerDecisionRunner: {
+        execute: vi.fn(async () => decision({ noProgress: true })),
+      },
+    });
+
+    await expect(executor.run(['feature-a'], 1)).rejects.toMatchObject({
+      code: ERROR_CODES.PROVIDER_NO_PROGRESS,
+    });
+  });
+});