agentic-orchestrator 0.1.0

package/apps/control-plane/test/spec-input-resolver.spec.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+
+const callCliToolMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../src/cli/tooling.js', () => ({
+  callCliTool: callCliToolMock
+}));
+
+import { SpecInputResolver } from '../src/cli/spec-input-resolver.js';
+
+describe('SpecInputResolver', () => {
+  let repoRoot: string;
+
+  beforeEach(async () => {
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-spec-input-resolver-'));
+    callCliToolMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_folder_with_nested_markdown_WHEN_resolving_folder_input_THEN_recurses_and_returns_sorted_markdown_paths', async () => {
+    const incoming = path.join(repoRoot, 'incoming');
+    const nested = path.join(incoming, 'nested');
+    await fs.mkdir(nested, { recursive: true });
+    await fs.writeFile(path.join(incoming, 'b.md'), '# B\n', 'utf8');
+    await fs.writeFile(path.join(incoming, 'ignore.txt'), 'x\n', 'utf8');
+    await fs.writeFile(path.join(nested, 'a.md'), '# A\n', 'utf8');
+
+    const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
+    const files = await resolver.resolve({ command: 'run', folder_input: 'incoming' });
+
+    expect(files).toEqual([
+      path.join(incoming, 'b.md'),
+      path.join(nested, 'a.md')
+    ].sort((a, b) => a.localeCompare(b)));
+  });
+
+  it('GIVEN_folder_input_pointing_to_file_WHEN_resolving_THEN_returns_input_path_not_found', async () => {
+    await fs.writeFile(path.join(repoRoot, 'not-a-folder.md'), '# spec\n', 'utf8');
+    const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
+
+    await expect(resolver.resolve({ command: 'run', folder_input: 'not-a-folder.md' })).rejects.toMatchObject({
+      code: ERROR_CODES.INPUT_PATH_NOT_FOUND
+    });
+  });
+
+  it('GIVEN_discovery_payload_without_specs_WHEN_resolving_without_inputs_THEN_returns_no_specs_found', async () => {
+    callCliToolMock.mockResolvedValue({ ok: true, data: {} });
+    const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
+
+    await expect(resolver.resolve({ command: 'run' })).rejects.toMatchObject({
+      code: ERROR_CODES.NO_SPECS_FOUND
+    });
+  });
+
+  it('GIVEN_discovery_specs_WHEN_resolving_without_inputs_THEN_returns_repo_relative_specs', async () => {
+    callCliToolMock.mockResolvedValue({
+      ok: true,
+      data: {
+        specs: [{ spec_path: '.aop/features/alpha/spec.md' }]
+      }
+    });
+
+    const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
+    const files = await resolver.resolve({ command: 'run' });
+
+    expect(files).toEqual([path.join(repoRoot, '.aop/features/alpha/spec.md')]);
+  });
+});

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

@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from 'vitest';
+import { STATUS, TOOLS } from '../src/core/constants.js';
+import { QaWaveExecutor } from '../src/supervisor/qa-wave-executor.js';
+import { SessionOrchestrator } from '../src/supervisor/session-orchestrator.js';
+import { UNASSIGNED_SESSION_ID } from '../src/supervisor/types.js';
+
+describe('QaWaveExecutor collaborator branches', () => {
+  it('GIVEN_missing_feature_sessions_or_orchestrator_WHEN_running_qa_wave_THEN_uses_unassigned_and_unknown_defaults', async () => {
+    const state = {
+      runId: 'run-qa',
+      ownerInstanceId: 'owner-qa',
+      orchestratorSessionId: null,
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>()
+    };
+    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 } }
+          };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+    const provider = {
+      closeSession: vi.fn(async () => ({ closed: true })),
+      createSession: vi.fn(async () => ({ session_id: 'qa-new' }))
+    };
+    const kernel = {
+      updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } }))
+    };
+    const promptProvider = {
+      loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: 'qa prompt' }))
+    };
+    const featureClusterPatcher = {
+      patchFeatureCluster: vi.fn(async () => undefined)
+    };
+    const executor = new QaWaveExecutor({
+      kernel: kernel as any,
+      provider: provider as any,
+      toolCaller: toolCaller as any,
+      promptProvider: promptProvider as any,
+      featureClusterPatcher: featureClusterPatcher as any,
+      state: state as any
+    });
+
+    await executor.run(['feature_a'], 1);
+
+    expect(provider.closeSession).not.toHaveBeenCalled();
+    expect(kernel.updateFeatureSessionAssignment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        planner_session_id: UNASSIGNED_SESSION_ID,
+        builder_session_id: UNASSIGNED_SESSION_ID,
+        qa_session_id: 'qa-new'
+      })
+    );
+    expect(featureClusterPatcher.patchFeatureCluster).toHaveBeenCalledWith('feature_a', {
+      orchestrator_session_id: 'unknown',
+      qa_session_id: 'qa-new'
+    });
+  });
+});
+
+describe('SessionOrchestrator collaborator branches', () => {
+  function createOrchestrator() {
+    const runtimeStateReader = {
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run-session',
+        owner_instance_id: 'owner-session',
+        orchestrator_session_id: 'orch-session'
+      }))
+    };
+    const provider = {
+      createSession: vi
+        .fn()
+        .mockResolvedValueOnce({ session_id: 'planner-1' })
+        .mockResolvedValueOnce({ session_id: 'builder-1' })
+        .mockResolvedValueOnce({ session_id: 'qa-1' })
+        .mockResolvedValue({ session_id: 'generic-1' }),
+      closeSession: vi.fn(async () => ({ closed: true }))
+    };
+    const kernel = {
+      updateOrchestratorSession: vi.fn(async () => ({ data: {} })),
+      updateFeatureSessionAssignment: vi.fn(async () => ({ data: {} }))
+    };
+    const promptProvider = {
+      loadRolePrompts: vi.fn(async () => ({ planner: 'p', builder: 'b', qa: 'q' }))
+    };
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, args: any) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET && args.feature_id === 'feature_a') {
+          return { ok: true, data: { front_matter: { version: 2 } } };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET && args.feature_id === 'feature_b') {
+          return {
+            ok: true,
+            data: { front_matter: { version: 3, cluster: { orchestrator_session_id: 'orch-main' } } }
+          };
+        }
+        if (toolName === TOOLS.FEATURE_STATE_GET && args.feature_id === 'feature_patch') {
+          return { ok: true, data: { front_matter: { version: 7 } } };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+    const state = {
+      runId: 'run-session',
+      ownerInstanceId: 'owner-session',
+      orchestratorSessionId: null as string | null,
+      runMetadata: {},
+      queue: [{ feature_id: 'feature_q' }],
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>()
+    };
+
+    return {
+      runtimeStateReader,
+      provider,
+      kernel,
+      promptProvider,
+      toolCaller,
+      state,
+      orchestrator: new SessionOrchestrator({
+        runtimeStateReader: runtimeStateReader as any,
+        provider: provider as any,
+        kernel: kernel as any,
+        promptProvider: promptProvider as any,
+        toolCaller: toolCaller as any,
+        state: state as any
+      })
+    };
+  }
+
+  it('GIVEN_missing_feature_sessions_WHEN_cleaning_orphans_THEN_uses_empty_assignment_default', async () => {
+    const { orchestrator, provider } = createOrchestrator();
+    await orchestrator.cleanupOrphanWorkerSessions(['feature_a']);
+    expect(provider.closeSession).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_null_orchestrator_session_WHEN_initializing_or_reconciling_THEN_uses_unknown_cluster_default', async () => {
+    const { orchestrator, state } = createOrchestrator();
+    const patchSpy = vi.spyOn(orchestrator, 'patchFeatureCluster').mockResolvedValue(undefined);
+
+    state.orchestratorSessionId = null;
+    await orchestrator.initializeFeatureCluster('feature_init');
+    await orchestrator.reconcileQueuedFeatures([{ feature_id: 'feature_q' } as any]);
+
+    expect(patchSpy).toHaveBeenCalledWith(
+      'feature_init',
+      expect.objectContaining({ orchestrator_session_id: 'unknown' })
+    );
+    expect(patchSpy).toHaveBeenCalledWith(
+      'feature_q',
+      expect.objectContaining({ orchestrator_session_id: 'unknown' })
+    );
+  });
+
+  it('GIVEN_missing_or_aligned_cluster_WHEN_enforcing_invariant_THEN_patches_only_mismatched_features', async () => {
+    const { orchestrator, toolCaller, state } = createOrchestrator();
+    state.orchestratorSessionId = 'orch-main';
+
+    await orchestrator.enforceActiveFeatureInvariant(['feature_a', 'feature_b']);
+
+    const patchCalls = toolCaller.callTool.mock.calls.filter(
+      (call: any[]) => call[1] === TOOLS.FEATURE_STATE_PATCH
+    );
+    expect(patchCalls).toHaveLength(1);
+    expect(patchCalls[0][2]).toMatchObject({
+      feature_id: 'feature_a',
+      patch: {
+        front_matter: {
+          cluster: {
+            orchestrator_session_id: 'orch-main'
+          }
+        }
+      }
+    });
+  });
+
+  it('GIVEN_missing_existing_cluster_WHEN_patching_feature_cluster_THEN_merges_against_empty_object', async () => {
+    const { orchestrator, toolCaller } = createOrchestrator();
+
+    await orchestrator.patchFeatureCluster('feature_patch', { qa_session_id: 'qa-new' });
+
+    expect(toolCaller.callTool).toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        feature_id: 'feature_patch',
+        patch: {
+          front_matter: {
+            cluster: {
+              qa_session_id: 'qa-new'
+            }
+          }
+        }
+      })
+    );
+  });
+});

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

@@ -0,0 +1,120 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SupervisorRuntime } from '../src/index.js';
+import { TOOLS } from '../src/core/constants.js';
+
+function makeRuntime() {
+  const kernel = {
+    getRepoRoot: vi.fn(() => ''),
+    getAgentsConfig: vi.fn(() => ({ roles: {}, missing_prompt_behavior: 'ignore' })),
+    getPolicySnapshot: vi.fn(() => ({
+      supervisor: {
+        max_iterations_per_phase: 6
+      }
+    })),
+    getRuntimeSessions: vi.fn(async () => ({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      orchestrator_session_id: 'unknown',
+      feature_sessions: {}
+    })),
+    updateOrchestratorSession: vi.fn(async () => ({ data: {} })),
+    updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } })),
+    pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] } })),
+    ensureLoaded: vi.fn(async () => undefined),
+    recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+    acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+    renewLeases: vi.fn(async () => undefined),
+    renewRunLease: vi.fn(async () => undefined),
+    repoDiff: vi.fn(async () => ({ data: { diff: '' } }))
+  };
+
+  const provider = {
+    selection: {
+      provider: 'custom',
+      model: 'model-x',
+      provider_config_ref: null
+    },
+    createSession: vi.fn(async () => ({ session_id: 'session-created' })),
+    closeSession: vi.fn(async () => ({ closed: true }))
+  };
+
+  const toolClient: { call: any } = {
+    call: vi.fn(async () => ({ ok: true, data: { accepted: true } }))
+  };
+
+  const runtime = new SupervisorRuntime(kernel as any, provider as any, toolClient as any, {
+    run_id: 'run:test',
+    owner_instance_id: 'owner:test'
+  });
+
+  return { runtime, toolClient };
+}
+
+describe('SupervisorRuntime callTool routing', () => {
+  it('uses orchestrator and worker session ids and injects operation ids for mutating tools', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    runtime.orchestratorSessionId = 'orch-main';
+    runtime.sessionsByFeature.set('feature_a', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session'
+    });
+
+    await runtime.callTool('orchestrator', TOOLS.FEATURE_INIT, { feature_id: 'feature_a' });
+    await runtime.callTool('planner', TOOLS.PLAN_SUBMIT, {
+      feature_id: 'feature_a',
+      plan_json: {
+        feature_id: 'feature_a',
+        plan_version: 1
+      }
+    });
+    await runtime.callTool('builder', TOOLS.REPO_DIFF, { feature_id: 'missing_feature' });
+    await runtime.callTool('qa', TOOLS.GATES_RUN, { feature_id: 'feature_a', mode: 'fast' });
+    await runtime.callTool('unknown_role' as any, TOOLS.REPO_DIFF, { feature_id: 'feature_a' });
+
+    const calls = (toolClient.call).mock.calls as any[];
+    expect(calls).toHaveLength(5);
+
+    const orchestratorCall = calls[0];
+    expect(orchestratorCall[2]).toMatchObject({
+      run_id: 'run:test',
+      session_id: 'orch-main',
+      actor_type: 'orchestrator'
+    });
+    expect(typeof orchestratorCall[1].operation_id).toBe('string');
+
+    const plannerCall = calls[1];
+    expect(plannerCall[2].session_id).toBe('planner-session');
+    expect(typeof plannerCall[1].operation_id).toBe('string');
+
+    const builderCall = calls[2];
+    expect(builderCall[2].session_id).toBe('bootstrap:builder');
+    expect(builderCall[1].operation_id).toBeUndefined();
+
+    const qaCall = calls[3];
+    expect(qaCall[2].session_id).toBe('qa-session');
+
+    const unknownRoleCall = calls[4];
+    expect(unknownRoleCall[2].session_id).toBe('bootstrap:unknown_role');
+  });
+
+  it('throws normalized AppError when tool call fails', async () => {
+    const { runtime, toolClient } = makeRuntime();
+    (toolClient.call).mockResolvedValue({
+      ok: false,
+      error: {
+        code: 'forbidden_tool_for_role',
+        message: 'Not allowed',
+        details: { reason: 'rbac' }
+      }
+    });
+
+    await expect(
+      runtime.callTool('builder', TOOLS.REPO_APPLY_PATCH, { feature_id: 'feature_a', unified_diff: '' })
+    ).rejects.toMatchObject({
+      message: 'Not allowed',
+      code: 'forbidden_tool_for_role',
+      details: { reason: 'rbac' }
+    });
+  });
+});