agentic-orchestrator 0.1.27 → 0.2.0

package/apps/control-plane/test/execution-control-service.spec.ts

@@ -0,0 +1,535 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ExecutionControlService } from '../src/application/services/execution-control-service.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
+
+function makeRunLease(overrides: Partial<RuntimeSessionsSnapshot> = {}): RuntimeSessionsSnapshot {
+  const now = new Date().toISOString();
+  return {
+    run_id: 'run:test',
+    orchestrator_session_id: 'orch:test',
+    provider: 'custom',
+    model: 'test-model',
+    provider_config_ref_hash: 'hash',
+    owner_instance_id: 'owner:test',
+    lease_id: 'lease:test',
+    started_at: now,
+    last_heartbeat_at: now,
+    lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
+    orchestrator_epoch: 0,
+    feature_sessions: {},
+    ...overrides,
+  };
+}
+
+describe('ExecutionControlService', () => {
+  let tempRoot: string;
+  let runLease: RuntimeSessionsSnapshot;
+
+  beforeEach(async () => {
+    tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-execution-control-'));
+    runLease = makeRunLease();
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  function makeService() {
+    return new ExecutionControlService({
+      instanceId: 'default',
+      executionControlPath: (instanceId: string) =>
+        path.join(tempRoot, '.aop', 'runtime', instanceId, 'execution-control.json'),
+      withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+      readRunLease: async () => runLease,
+      normalizeRuntimeSessions: (value: unknown) => value as RuntimeSessionsSnapshot,
+      isRunLeaseFresh: (runtimeSessions: RuntimeSessionsSnapshot) =>
+        new Date(runtimeSessions.lease_expires_at).getTime() > Date.now(),
+      validateSchema: async () => ({ valid: true }),
+    });
+  }
+
+  async function writeSnapshot(value: unknown) {
+    const targetPath = path.join(tempRoot, '.aop', 'runtime', 'default', 'execution-control.json');
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, JSON.stringify(value, null, 2), 'utf8');
+  }
+
+  it('submits, lists, and marks execution requests processed', async () => {
+    const service = makeService();
+
+    const submitted = await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:add:feature_a',
+    });
+    expect(submitted.data).toMatchObject({
+      run_id: 'run:test',
+      request_status: 'pending',
+      requested_features: [{ feature_id: 'feature_a' }],
+    });
+
+    const drained = await service.drainPendingExecutionRequests('run:test', 'owner:test');
+    expect(drained.data.items).toHaveLength(1);
+    expect(drained.data.items[0].request_id).toBe(submitted.data.request_id);
+
+    await service.markExecutionRequestProcessed(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      'applied',
+      {
+        queued: ['feature_a'],
+        skipped: [],
+      },
+    );
+
+    const listed = await service.listExecutionRequests();
+    expect(listed.data.items[0]).toMatchObject({
+      request_id: submitted.data.request_id,
+      status: 'applied',
+      outcome: { queued: ['feature_a'], skipped: [] },
+    });
+  });
+
+  it('replays identical operation ids and rejects mismatched payload reuse', async () => {
+    const service = makeService();
+
+    const first = await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:replay',
+    });
+    const replay = await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:replay',
+    });
+    expect(replay.data.request_id).toBe(first.data.request_id);
+
+    await expect(
+      service.submitExecutionRequest({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        request_type: 'add_features',
+        features: [{ feature_id: 'feature_b', spec_path: '.aop/features/feature_b/spec.md' }],
+        operation_id: 'op:replay',
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.DUPLICATE_EXECUTION_REQUEST,
+        },
+      },
+    });
+  });
+
+  it('rejects submission when no active run is fresh', async () => {
+    const service = makeService();
+    runLease = makeRunLease({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      lease_expires_at: new Date(0).toISOString(),
+    });
+
+    await expect(
+      service.submitExecutionRequest({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        request_type: 'add_features',
+        features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+        operation_id: 'op:no-run',
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.RUN_NOT_ACTIVE,
+        },
+      },
+    });
+  });
+
+  it('returns an empty snapshot when no control file exists and resets mismatched active-run snapshots', async () => {
+    const service = makeService();
+
+    const empty = await service.listExecutionRequests();
+    expect(empty.data).toMatchObject({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      items: [],
+    });
+
+    await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:existing',
+    });
+
+    runLease = makeRunLease({
+      run_id: 'run:other',
+      owner_instance_id: 'owner:other',
+    });
+
+    const reset = await service.listExecutionRequests();
+    expect(reset.data).toMatchObject({
+      run_id: 'run:other',
+      owner_instance_id: 'owner:other',
+      items: [],
+    });
+  });
+
+  it('returns an empty default snapshot when no control file exists and no active run is fresh', async () => {
+    const service = makeService();
+    runLease = makeRunLease({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      lease_expires_at: new Date(0).toISOString(),
+    });
+
+    const listed = await service.listExecutionRequests();
+
+    expect(listed.data).toMatchObject({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      items: [],
+    });
+  });
+
+  it('normalizes malformed persisted snapshots when listing requests', async () => {
+    const service = makeService();
+    await writeSnapshot({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      updated_at: 123,
+      items: [
+        null,
+        {
+          request_id: 'req_pending',
+          request_type: 'custom_type',
+          status: 'pending',
+          requested_at: '2026-03-15T00:01:00.000Z',
+          requested_by: 'planner',
+          operation_id: 'op:pending',
+          processed_at: 123,
+          features: [
+            { feature_id: 'feature_b', spec_path: 'b.md' },
+            { feature_id: 'feature_a', spec_path: 'a.md' },
+            { feature_id: 'missing_spec' },
+            'bad',
+          ],
+          progress: {
+            detected_at: 123,
+            last_evaluated_at: '2026-03-15T00:02:00.000Z',
+            queued: ['feature_c', 99, 'feature_a'],
+            skipped: [
+              { feature_id: 'feature_skip', reason: 'capacity_full' },
+              { feature_id: 'feature_bad', reason: 123 },
+              null,
+            ],
+            deferred: 'invalid',
+          },
+          outcome: {
+            queued: ['feature_b', 99, 'feature_a', 'feature_a'],
+            skipped: [
+              { feature_id: 'feature_skip', reason: 'capacity_full' },
+              { feature_id: 'feature_bad', reason: 123 },
+              null,
+            ],
+          },
+        },
+        {
+          request_id: 'req_rejected',
+          request_type: 'unexpected',
+          status: 'rejected',
+          requested_at: '2026-03-15T00:00:00.000Z',
+          requested_by: 'qa',
+          operation_id: 'op:rejected',
+          processed_at: '2026-03-15T00:03:00.000Z',
+          features: 'invalid',
+          progress: 'invalid',
+          outcome: {
+            code: 'capacity_full',
+            message: 'No slots remain',
+          },
+        },
+        {
+          request_id: 'req_invalid_status',
+          request_type: 'add_features',
+          status: 'unknown',
+          requested_at: '2026-03-15T00:04:00.000Z',
+          requested_by: 'qa',
+          operation_id: 'op:invalid-status',
+        },
+        {
+          request_id: 'req_invalid_shape',
+          request_type: 'add_features',
+          status: 'pending',
+          requested_at: '2026-03-15T00:05:00.000Z',
+          requested_by: 'qa',
+        },
+      ],
+    });
+
+    const listed = await service.listExecutionRequests();
+
+    expect(listed.data.items).toHaveLength(2);
+    expect(listed.data.items[0]).toEqual({
+      request_id: 'req_rejected',
+      request_type: 'add_features',
+      status: 'rejected',
+      requested_at: '2026-03-15T00:00:00.000Z',
+      processed_at: '2026-03-15T00:03:00.000Z',
+      requested_by: 'qa',
+      operation_id: 'op:rejected',
+      features: [],
+      progress: null,
+      outcome: {
+        code: 'capacity_full',
+        message: 'No slots remain',
+      },
+    });
+    expect(listed.data.items[1]).toEqual({
+      request_id: 'req_pending',
+      request_type: 'add_features',
+      status: 'pending',
+      requested_at: '2026-03-15T00:01:00.000Z',
+      processed_at: null,
+      requested_by: 'planner',
+      operation_id: 'op:pending',
+      features: [
+        { feature_id: 'feature_a', spec_path: 'a.md' },
+        { feature_id: 'feature_b', spec_path: 'b.md' },
+      ],
+      progress: {
+        detected_at: null,
+        last_evaluated_at: '2026-03-15T00:02:00.000Z',
+        queued: ['feature_c', 'feature_a'],
+        skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+        deferred: [],
+      },
+      outcome: {
+        queued: ['feature_a', 'feature_b'],
+        skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+      },
+    });
+    expect(typeof listed.data.updated_at).toBe('string');
+  });
+
+  it('updates progress for pending requests and refuses terminal or missing requests', async () => {
+    const service = makeService();
+    const submitted = await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:progress',
+    });
+
+    const updated = await service.updateExecutionRequestProgress(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      {
+        detected_at: '2026-03-15T00:00:00.000Z',
+        last_evaluated_at: '2026-03-15T00:01:00.000Z',
+        queued: ['feature_b', 'feature_a', 'feature_a'],
+        skipped: [
+          { feature_id: 'feature_skip', reason: 'capacity_full' },
+          { feature_id: 'bad', reason: 123 as never },
+        ],
+        deferred: [{ feature_id: 'feature_deferred', reason: 'planner_busy' }],
+      },
+    );
+
+    expect(updated.data).toEqual({
+      updated: true,
+      progress: {
+        detected_at: '2026-03-15T00:00:00.000Z',
+        last_evaluated_at: '2026-03-15T00:01:00.000Z',
+        queued: ['feature_a', 'feature_b'],
+        skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+        deferred: [{ feature_id: 'feature_deferred', reason: 'planner_busy' }],
+      },
+    });
+
+    await service.markExecutionRequestProcessed(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      'rejected',
+      {
+        code: 'capacity_full',
+        message: 'No enrollment slots were available',
+      },
+    );
+
+    const terminal = await service.updateExecutionRequestProgress(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      { queued: ['feature_c'] },
+    );
+    expect(terminal.data).toMatchObject({
+      updated: false,
+      progress: null,
+    });
+
+    const missing = await service.updateExecutionRequestProgress(
+      'run:test',
+      'owner:test',
+      'missing_request',
+      { queued: ['feature_c'] },
+    );
+    expect(missing.data).toEqual({
+      updated: false,
+      progress: null,
+    });
+  });
+
+  it('merges partial progress patches into existing request progress', async () => {
+    const service = makeService();
+    const submitted = await service.submitExecutionRequest({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      request_type: 'add_features',
+      features: [{ feature_id: 'feature_a', spec_path: '.aop/features/feature_a/spec.md' }],
+      operation_id: 'op:progress-merge',
+      requested_by: 'cli:test',
+    });
+
+    const firstUpdate = await service.updateExecutionRequestProgress(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      {
+        detected_at: '2026-03-15T00:00:00.000Z',
+        skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+      },
+    );
+    expect(firstUpdate.data.progress).toEqual({
+      detected_at: '2026-03-15T00:00:00.000Z',
+      last_evaluated_at: null,
+      queued: [],
+      skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+      deferred: [],
+    });
+
+    const secondUpdate = await service.updateExecutionRequestProgress(
+      'run:test',
+      'owner:test',
+      submitted.data.request_id,
+      {
+        queued: ['feature_c', 'feature_b', 'feature_b'],
+        deferred: [{ feature_id: 'feature_deferred', reason: 'planner_busy' }],
+      },
+    );
+
+    expect(secondUpdate.data).toEqual({
+      updated: true,
+      progress: {
+        detected_at: '2026-03-15T00:00:00.000Z',
+        last_evaluated_at: null,
+        queued: ['feature_b', 'feature_c'],
+        skipped: [{ feature_id: 'feature_skip', reason: 'capacity_full' }],
+        deferred: [{ feature_id: 'feature_deferred', reason: 'planner_busy' }],
+      },
+    });
+
+    const listed = await service.listExecutionRequests();
+    expect(listed.data.items[0]).toMatchObject({
+      requested_by: 'cli:test',
+      progress: {
+        queued: ['feature_b', 'feature_c'],
+      },
+    });
+  });
+
+  it('returns false when processing a missing request and rejects mismatched run targets', async () => {
+    const service = makeService();
+
+    const missing = await service.markExecutionRequestProcessed(
+      'run:test',
+      'owner:test',
+      'missing_request',
+      'applied',
+      {
+        queued: ['feature_a'],
+        skipped: [],
+      },
+    );
+    expect(missing.data.updated).toBe(false);
+
+    await expect(
+      service.drainPendingExecutionRequests('run:other', 'owner:other'),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.EXECUTION_REQUEST_TARGET_MISMATCH,
+        },
+      },
+    });
+  });
+
+  it('surfaces schema validation failures for persisted execution-control snapshots', async () => {
+    await writeSnapshot({
+      run_id: 'run:test',
+      owner_instance_id: 'owner:test',
+      updated_at: '2026-03-15T00:00:00.000Z',
+      items: [],
+    });
+
+    const service = new ExecutionControlService({
+      instanceId: 'default',
+      executionControlPath: (instanceId: string) =>
+        path.join(tempRoot, '.aop', 'runtime', instanceId, 'execution-control.json'),
+      withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+      readRunLease: async () => runLease,
+      normalizeRuntimeSessions: (value: unknown) => value as RuntimeSessionsSnapshot,
+      isRunLeaseFresh: (runtimeSessions: RuntimeSessionsSnapshot) =>
+        new Date(runtimeSessions.lease_expires_at).getTime() > Date.now(),
+      validateSchema: async () => ({
+        valid: false,
+        errors: [{ message: 'schema mismatch' }],
+      }),
+    });
+
+    await expect(service.listExecutionRequests()).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INTERNAL_ERROR,
+        },
+      },
+    });
+  });
+
+  it('rejects invalid submissions before touching disk', async () => {
+    const service = makeService();
+
+    await expect(
+      service.submitExecutionRequest({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        request_type: 'add_features',
+        features: [],
+        operation_id: '',
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.INVALID_ARGUMENT,
+        },
+      },
+    });
+  });
+});