agentic-orchestrator 0.1.0

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

@@ -0,0 +1,229 @@
+import { describe, expect, it, vi } from 'vitest';
+import { STATUS, TOOLS } from '../src/core/constants.js';
+import { PlanningWaveExecutor } from '../src/supervisor/planning-wave-executor.js';
+
+function basePlan(featureId: string) {
+  return {
+    feature_id: featureId,
+    plan_version: 2,
+    summary: `Plan for ${featureId}`,
+    allowed_areas: ['apps/control-plane'],
+    forbidden_areas: [],
+    base_ref: 'HEAD',
+    files: {
+      create: [],
+      modify: ['apps/control-plane/src/file.ts'],
+      delete: []
+    },
+    contracts: {
+      openapi: 'none',
+      events: 'none',
+      db: 'none'
+    },
+    acceptance_criteria: ['Existing acceptance criterion.'],
+    gate_profile: 'default'
+  };
+}
+
+describe('PlanningWaveExecutor post-QA reconciliation', () => {
+  it('GIVEN_worker_emits_plan_submission_WHEN_running_planning_wave_THEN_skips_fallback_plan_generation', async () => {
+    const featureId = 'feature_worker_plan';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              state: {
+                front_matter: {
+                  status: STATUS.PLANNING
+                }
+              },
+              plan: null
+            }
+          };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+
+    const planGenerator = {
+      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId }))
+    };
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: true,
+        patchApplied: false,
+        noteLogged: true,
+        requestHandled: false,
+        priorityOrder: [],
+        toolResults: []
+      }))
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: planGenerator as never,
+      workerDecisionRunner: workerDecisionRunner as never
+    });
+
+    await executor.run([featureId]);
+
+    expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: 'planner',
+        featureId
+      })
+    );
+    expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
+    const planSubmitCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_SUBMIT);
+    expect(planSubmitCalls).toHaveLength(0);
+  });
+
+  it('GIVEN_post_qa_gaps_WHEN_reconciling_THEN_emits_plan_update_with_edge_case_hardening', async () => {
+    const featureId = 'feature_gap';
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, args: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Handle missing inputs and timeout retries under concurrent requests.',
+              state: {
+                front_matter: {
+                  status: STATUS.BLOCKED
+                }
+              },
+              plan: basePlan(featureId),
+              qa_test_index: {
+                summary: {
+                  pending: 1,
+                  failed: 1,
+                  running: 0,
+                  passed: 0,
+                  waived: 0
+                }
+              },
+              latest_evidence: {
+                overall: 'fail'
+              }
+            }
+          };
+        }
+        if (toolName === TOOLS.PLAN_UPDATE) {
+          return { ok: true, data: { accepted: true, plan_version: 3 } };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        throw new Error(`unexpected_tool:${toolName}:${String(args.feature_id ?? '')}`);
+      })
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) }
+    });
+
+    await executor.runPostQaReconciliation([featureId], 1);
+
+    const updateCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.PLAN_UPDATE);
+    expect(updateCall).toBeTruthy();
+    expect(updateCall?.[0]).toBe('planner');
+    expect(updateCall?.[2]).toMatchObject({
+      feature_id: featureId,
+      expected_plan_version: 2,
+      plan_json: {
+        plan_version: 3,
+        revision_of: 2
+      }
+    });
+
+    const updatedPlan = updateCall?.[2].plan_json as Record<string, unknown>;
+    expect(updatedPlan.acceptance_criteria).toEqual(
+      expect.arrayContaining([
+        'Reconcile QA/gate findings against plan scope and apply corrective updates before merge.',
+        'Planner reconciliation checkpoint [status=blocked;failed=1;pending=1;latest=fail]'
+      ])
+    );
+    expect(updatedPlan.risk).toEqual(
+      expect.arrayContaining([
+        'Edge-case: boundary values and size limits are covered.',
+        'Edge-case: empty/null/missing input handling is covered.',
+        'Edge-case: timeout, retry, and latency behavior is covered.',
+        'Edge-case: concurrent access and race-condition behavior are covered.'
+      ])
+    );
+
+    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    expect(logCall?.[0]).toBe('orchestrator');
+    const note = JSON.parse(String(logCall?.[2].note)) as Record<string, unknown>;
+    expect(note.decision).toBe('plan_update');
+  });
+
+  it('GIVEN_reconciled_post_qa_context_WHEN_reconciling_THEN_logs_no_update_and_skips_plan_update', async () => {
+    const featureId = 'feature_reconciled';
+    const edgeChecklist = [
+      'Edge-case: boundary values and size limits are covered.',
+      'Edge-case: negative-path input validation and error handling are covered.',
+      'Edge-case: dependency failure and retry behavior are covered.'
+    ];
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
+          return {
+            ok: true,
+            data: {
+              feature_id: featureId,
+              spec: 'Simple feature flow.',
+              state: {
+                front_matter: {
+                  status: STATUS.READY_TO_MERGE
+                }
+              },
+              plan: {
+                ...basePlan(featureId),
+                risk: edgeChecklist
+              },
+              qa_test_index: {
+                summary: {
+                  pending: 0,
+                  failed: 0,
+                  running: 0,
+                  passed: 2,
+                  waived: 0
+                }
+              },
+              latest_evidence: {
+                overall: 'pass'
+              }
+            }
+          };
+        }
+        if (toolName === TOOLS.FEATURE_LOG_APPEND) {
+          return { ok: true, data: { appended: true } };
+        }
+        throw new Error(`unexpected_tool:${toolName}`);
+      })
+    };
+
+    const executor = new PlanningWaveExecutor({
+      toolCaller: toolCaller as never,
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) }
+    });
+
+    await executor.runPostQaReconciliation([featureId], 2);
+
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_UPDATE);
+    expect(planUpdateCalls).toHaveLength(0);
+
+    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    expect(logCall).toBeTruthy();
+    const logArgs = logCall?.[2] ?? {};
+    const note = JSON.parse(String(logArgs.note));
+    expect(note.decision).toBe('no_update');
+    expect(note.reasons).toEqual(['reconciled_no_gaps']);
+  });
+});

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

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { NullWorkerProvider, resolveProviderSelection } from '../src/index.js';
+
+describe('provider selection', () => {
+  it('GIVEN_cli_env_and_config_WHEN_resolving_THEN_cli_values_win', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'custom',
+        agent_model: 'cli-model',
+        provider_config_env: 'CLI_CONFIG'
+      },
+      env: {
+        AOP_AGENT_PROVIDER: 'codex',
+        AOP_AGENT_MODEL: 'env-model',
+        AOP_PROVIDER_CONFIG_ENV: 'ENV_CONFIG'
+      },
+      agentsConfig: {
+        runtime: {
+          default_provider: 'claude',
+          default_model: 'cfg-model',
+          provider_config_env: 'CFG_CONFIG'
+        }
+      }
+    });
+
+    expect(selection.provider).toBe('custom');
+    expect(selection.model).toBe('cli-model');
+    expect(selection.provider_config_env).toBe('CLI_CONFIG');
+  });
+
+  it('GIVEN_no_provider_WHEN_resolving_THEN_throws_agent_provider_not_configured', () => {
+    expect(() =>
+      resolveProviderSelection({
+        cli: {},
+        env: {},
+        agentsConfig: {}
+      })
+    ).toThrow(ERROR_CODES.AGENT_PROVIDER_NOT_CONFIGURED);
+  });
+
+  it('GIVEN_unsupported_provider_WHEN_resolving_THEN_throws_unsupported_provider_error', () => {
+    expect(() =>
+      resolveProviderSelection({
+        cli: { agent_provider: 'bogus' },
+        env: {},
+        agentsConfig: {}
+      })
+    ).toThrow(ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
+  });
+
+  it('GIVEN_non_custom_provider_without_credentials_WHEN_resolving_THEN_throws_provider_auth_missing', () => {
+    expect(() =>
+      resolveProviderSelection({
+        cli: { agent_provider: 'codex', provider_config_env: 'AOP_KEY' },
+        env: {},
+        agentsConfig: {}
+      })
+    ).toThrow(ERROR_CODES.PROVIDER_AUTH_MISSING);
+  });
+
+  it('GIVEN_non_custom_provider_without_model_WHEN_resolving_THEN_uses_default_model_name', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'codex',
+        provider_config_env: 'AOP_KEY'
+      },
+      env: {
+        AOP_KEY: 'token'
+      },
+      agentsConfig: {}
+    });
+
+    expect(selection.model).toBe('codex-default');
+    expect(selection.provider_config_ref).toBe('token');
+  });
+
+  it('GIVEN_custom_provider_without_credentials_WHEN_resolving_THEN_allows_null_config_ref', () => {
+    const selection = resolveProviderSelection({
+      cli: {
+        agent_provider: 'custom'
+      },
+      env: {},
+      agentsConfig: {}
+    });
+
+    expect(selection.provider).toBe('custom');
+    expect(selection.provider_config_ref).toBeNull();
+  });
+});
+
+describe('NullWorkerProvider', () => {
+  const selection = {
+    provider: 'custom' as const,
+    model: 'test-model',
+    provider_config_env: null,
+    provider_config_ref: null
+  };
+
+  it('GIVEN_system_prompt_WHEN_createSession_THEN_marks_prompt_loaded', async () => {
+    const provider = new NullWorkerProvider(selection);
+    const session = await provider.createSession('planner', 'feature_one', 'prompt content');
+
+    expect(session.role).toBe('planner');
+    expect(session.feature_id).toBe('feature_one');
+    expect(session.session_id).toMatch(/^planner-feature_one-/);
+    expect(session.system_prompt_loaded).toBe(true);
+  });
+
+  it('GIVEN_planner_role_WHEN_runWorker_THEN_returns_context_snapshot', async () => {
+    const provider = new NullWorkerProvider(selection);
+    const output = await provider.runWorker({
+      role: 'planner',
+      feature_id: 'feature_two',
+      context_bundle: { state: { front_matter: { status: 'building' } } }
+    });
+
+    expect(output).toMatchObject({
+      type: 'NOTE',
+      content: 'Planner session active for feature_two.',
+      context_snapshot: { status: 'building' }
+    });
+  });
+
+  it('GIVEN_non_planner_role_WHEN_runWorker_THEN_returns_simple_note', async () => {
+    const provider = new NullWorkerProvider(selection);
+    const output = await provider.runWorker({ role: 'qa', feature_id: 'feature_three' });
+
+    expect(output).toMatchObject({
+      type: 'NOTE',
+      content: 'qa session active for feature_three.'
+    });
+  });
+
+  it('GIVEN_planner_without_context_WHEN_runWorker_THEN_returns_unknown_status_snapshot', async () => {
+    const provider = new NullWorkerProvider(selection);
+    const output = await provider.runWorker({
+      role: 'planner',
+      feature_id: 'feature_unknown'
+    });
+
+    expect(output).toMatchObject({
+      type: 'NOTE',
+      content: 'Planner session active for feature_unknown.',
+      context_snapshot: { status: 'unknown' }
+    });
+  });
+
+  it('GIVEN_planner_with_non_object_state_WHEN_runWorker_THEN_handles_gracefully', async () => {
+    const provider = new NullWorkerProvider(selection);
+    const output = await provider.runWorker({
+      role: 'planner',
+      feature_id: 'feature_weird',
+      context_bundle: { state: 'invalid' as unknown as Record<string, unknown> }
+    });
+
+    expect(output).toMatchObject({
+      type: 'NOTE',
+      content: 'Planner session active for feature_weird.',
+      context_snapshot: { status: 'unknown' }
+    });
+  });
+
+  it('GIVEN_session_id_WHEN_closeSession_THEN_returns_closed_true', async () => {
+    const provider = new NullWorkerProvider(selection);
+    await expect(provider.closeSession('session:1')).resolves.toEqual({ closed: true });
+  });
+});

package/apps/control-plane/test/qa-index-service.spec.ts

@@ -0,0 +1,187 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { QaIndexService } from '../src/application/services/qa-index-service.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+
+type AnyRecord = Record<string, unknown>;
+
+async function writeJson(filePath: string, value: unknown): Promise<void> {
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+describe('QaIndexService', () => {
+  const cleanupPaths: string[] = [];
+
+  afterEach(async () => {
+    while (cleanupPaths.length > 0) {
+      const target = cleanupPaths.pop();
+      if (target) {
+        await fs.rm(target, { recursive: true, force: true });
+      }
+    }
+  });
+
+  it('GIVEN_missing_index_file_WHEN_qa_test_index_get_THEN_returns_default_index_and_empty_summary', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-qa-index-get-'));
+    cleanupPaths.push(tempDir);
+
+    const validateSchema = vi.fn(async () => ({ valid: true }));
+    const service = new QaIndexService({
+      qaIndexPath: () => path.join(tempDir, 'qa_test_index.json'),
+      validateSchema
+    });
+
+    const result = await service.qaTestIndexGet('feature_qa');
+
+    expect(result.data.index).toMatchObject({
+      feature_id: 'feature_qa',
+      version: 1,
+      items: []
+    });
+    expect(result.data.summary).toEqual({
+      pending: 0,
+      running: 0,
+      passed: 0,
+      failed: 0,
+      waived: 0
+    });
+    expect(result.data.pending_required_tests).toEqual({});
+    expect(validateSchema).toHaveBeenCalledWith('qa_test_index.schema.json', expect.any(Object));
+  });
+
+  it('GIVEN_invalid_index_schema_WHEN_qa_test_index_get_THEN_returns_internal_error', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-qa-index-invalid-'));
+    cleanupPaths.push(tempDir);
+
+    const service = new QaIndexService({
+      qaIndexPath: () => path.join(tempDir, 'qa_test_index.json'),
+      validateSchema: async () => ({ valid: false, errors: [{ message: 'invalid_schema' }] })
+    });
+
+    await expect(service.qaTestIndexGet('feature_invalid')).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTERNAL_ERROR
+        }
+      }
+    });
+  });
+
+  it('GIVEN_missing_index_file_WHEN_qa_test_index_update_THEN_returns_file_not_found', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-qa-index-missing-update-'));
+    cleanupPaths.push(tempDir);
+
+    const service = new QaIndexService({
+      qaIndexPath: () => path.join(tempDir, 'qa_test_index.json'),
+      validateSchema: async () => ({ valid: true })
+    });
+
+    await expect(
+      service.qaTestIndexUpdate('feature_missing', 1, [], [])
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.FILE_NOT_FOUND
+        }
+      }
+    });
+  });
+
+  it('GIVEN_schema_validation_fails_on_update_WHEN_qa_test_index_update_THEN_returns_internal_error', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-qa-index-update-invalid-'));
+    cleanupPaths.push(tempDir);
+
+    const qaIndexPath = path.join(tempDir, 'qa_test_index.json');
+    const initialIndex: AnyRecord = {
+      feature_id: 'feature_update_invalid',
+      version: 1,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/sample.ts',
+          hunks: [{ start_line: 1, end_line: 2, change_type: 'modify' }],
+          required_tests: ['default:fast:lint'],
+          status: 'pending'
+        }
+      ]
+    };
+    await writeJson(qaIndexPath, initialIndex);
+
+    const service = new QaIndexService({
+      qaIndexPath: () => qaIndexPath,
+      validateSchema: async () => ({ valid: false, errors: [{ message: 'schema_failed' }] })
+    });
+
+    await expect(
+      service.qaTestIndexUpdate(
+        'feature_update_invalid',
+        1,
+        [
+          {
+            path: 'src/sample.ts',
+            hunk: { start_line: 1, end_line: 2, change_type: 'modify' },
+            status: 'passed'
+          }
+        ],
+        ['evidence://run-1']
+      )
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTERNAL_ERROR
+        }
+      }
+    });
+  });
+
+  it('GIVEN_valid_update_request_WHEN_qa_test_index_update_THEN_persists_incremented_version_and_status', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-qa-index-update-pass-'));
+    cleanupPaths.push(tempDir);
+
+    const qaIndexPath = path.join(tempDir, 'qa_test_index.json');
+    await writeJson(qaIndexPath, {
+      feature_id: 'feature_update_ok',
+      version: 1,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/sample.ts',
+          hunks: [{ start_line: 3, end_line: 4, change_type: 'modify' }],
+          required_tests: ['default:fast:lint'],
+          status: 'pending'
+        }
+      ]
+    });
+
+    const service = new QaIndexService({
+      qaIndexPath: () => qaIndexPath,
+      validateSchema: async () => ({ valid: true })
+    });
+
+    const result = await service.qaTestIndexUpdate(
+      'feature_update_ok',
+      1,
+      [
+        {
+          path: 'src/sample.ts',
+          hunk: { start_line: 3, end_line: 4, change_type: 'modify' },
+          status: 'passed'
+        }
+      ],
+      ['evidence://run-ok']
+    );
+
+    expect(result.data).toEqual({
+      feature_id: 'feature_update_ok',
+      version: 2
+    });
+
+    const persisted = JSON.parse(await fs.readFile(qaIndexPath, 'utf8'));
+    expect(persisted.version).toBe(2);
+    expect(persisted.items[0].status).toBe('passed');
+    expect(persisted.items[0].evidence_refs).toEqual(['evidence://run-ok']);
+    expect(typeof persisted.items[0].last_run_at).toBe('string');
+  });
+});