agentic-orchestrator 0.1.28 → 0.2.0

package/packages/web-dashboard/test/api/launch/submit.route.spec.ts

@@ -0,0 +1,382 @@
+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';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const prepareLaunchDraftSpecsMock = vi.hoisted(() => vi.fn());
+const submitLaunchEnrollmentMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@/lib/aop-client.js', () => ({
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/orchestrator-tools.js', () => ({
+  prepareLaunchDraftSpecs: prepareLaunchDraftSpecsMock,
+  submitLaunchEnrollment: submitLaunchEnrollmentMock,
+}));
+
+import { POST } from '@/app/api/launch/submit/route.js';
+
+async function writeRunLease(
+  repoRoot: string,
+  instanceId: string,
+  values: Partial<{
+    run_id: string;
+    owner_instance_id: string;
+    lease_expires_at: string;
+    last_heartbeat_at: string;
+  }> = {},
+): Promise<void> {
+  const leasePath = path.join(repoRoot, '.aop', 'runtime', instanceId, 'run-lease.json');
+  await fs.mkdir(path.dirname(leasePath), { recursive: true });
+  await fs.writeFile(
+    leasePath,
+    JSON.stringify(
+      {
+        run_id: 'run:active',
+        owner_instance_id: 'owner:active',
+        provider: 'codex',
+        model: 'gpt-5.4',
+        started_at: '2026-03-17T12:00:00.000Z',
+        last_heartbeat_at: '2026-03-17T12:05:00.000Z',
+        lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
+        ...values,
+      },
+      null,
+      2,
+    ),
+    'utf8',
+  );
+}
+
+describe('POST /api/launch/submit', () => {
+  let repoRoot: string;
+
+  beforeEach(async () => {
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-launch-submit-'));
+    resolveProjectRootMock.mockReset();
+    prepareLaunchDraftSpecsMock.mockReset();
+    submitLaunchEnrollmentMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue(repoRoot);
+    await writeRunLease(repoRoot, 'instance-active');
+    prepareLaunchDraftSpecsMock.mockImplementation(
+      async (
+        inputs: Array<{
+          sourceLabel?: string | null;
+        }>,
+      ) =>
+        inputs.map((input) => {
+          const featureId = String(input.sourceLabel ?? 'draft')
+            .toLowerCase()
+            .replace(/\s+/g, '_');
+          return {
+            feature_id: featureId,
+            source_path: 'draft.md',
+            canonical_spec_path: `.aop/features/${featureId}/spec.md`,
+            source_hash: `hash-${featureId}`,
+            content: '# Draft',
+            write_required: true,
+          };
+        }),
+    );
+    submitLaunchEnrollmentMock.mockResolvedValue({
+      ok: true,
+      data: {
+        command: 'launch.submit',
+        mode: 'active_run_enrollment',
+        run_id: 'run:active',
+        request_id: 'exec_req_001',
+        request_status: 'pending',
+        requested_features: [],
+      },
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('starts a new dashboard-owned execution when there is no active run lease', async () => {
+    await fs.rm(path.join(repoRoot, '.aop', 'runtime'), { recursive: true, force: true });
+    submitLaunchEnrollmentMock.mockResolvedValueOnce({
+      ok: true,
+      data: {
+        command: 'launch.submit',
+        mode: 'runtime_start',
+        run_id: 'run:dashboard-launch:1',
+        request_status: 'started',
+        requested_features: [],
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/launch/submit', {
+        method: 'POST',
+        body: JSON.stringify({
+          drafts: [
+            {
+              draft_id: 'draft-1',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Draft 1',
+              markdown: '# Draft 1',
+            },
+          ],
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        run_id?: string | null;
+        outcomes: Array<{ status: string; request_status?: string | null }>;
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.run_id).toBe('run:dashboard-launch:1');
+    expect(body.data?.outcomes).toEqual([
+      expect.objectContaining({
+        status: 'submitted',
+        request_status: 'started',
+      }),
+    ]);
+    expect(submitLaunchEnrollmentMock).toHaveBeenCalledWith(
+      [
+        {
+          feature_id: 'draft_1',
+          spec_path: '.aop/features/draft_1/spec.md',
+        },
+      ],
+      repoRoot,
+    );
+  });
+
+  it('reads the active run from an instance-scoped run lease when index runtime sessions are stale', async () => {
+    await fs.rm(path.join(repoRoot, '.aop', 'runtime'), { recursive: true, force: true });
+    await writeRunLease(repoRoot, 'orchestrator-42', {
+      run_id: 'run:lease-only',
+      owner_instance_id: 'owner:lease-only',
+      last_heartbeat_at: '2026-03-17T12:06:00.000Z',
+    });
+    const legacyIndexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
+    await fs.mkdir(path.dirname(legacyIndexPath), { recursive: true });
+    await fs.writeFile(
+      legacyIndexPath,
+      JSON.stringify({
+        active: [],
+        blocked: [],
+        merged: [],
+        blocked_queue: [],
+        runtime_sessions: {
+          run_id: 'none',
+          owner_instance_id: 'none',
+        },
+      }),
+      'utf8',
+    );
+
+    const response = await POST(
+      new Request('http://localhost/api/launch/submit', {
+        method: 'POST',
+        body: JSON.stringify({
+          drafts: [
+            {
+              draft_id: 'good-draft',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Good Draft',
+              markdown: '# Good Draft\n\nShip it.',
+            },
+          ],
+        }),
+      }),
+    );
+    const body = (await response.json()) as { ok: boolean };
+
+    expect(body.ok).toBe(true);
+    expect(submitLaunchEnrollmentMock).toHaveBeenCalledWith(
+      [
+        {
+          feature_id: 'good_draft',
+          spec_path: '.aop/features/good_draft/spec.md',
+        },
+      ],
+      repoRoot,
+    );
+  });
+
+  it('supports partial validity and writes canonical specs before submission', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/launch/submit', {
+        method: 'POST',
+        body: JSON.stringify({
+          drafts: [
+            {
+              draft_id: 'bad-upload',
+              draft_order: 1,
+              source_type: 'upload',
+              name: 'bad-upload.txt',
+              markdown: '# Invalid Upload',
+            },
+            {
+              draft_id: 'good-draft',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Good Draft',
+              markdown: '# Good Draft\n\nShip it.',
+            },
+          ],
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        outcomes: Array<{
+          draft_id: string;
+          status: string;
+          request_id?: string | null;
+          errors: string[];
+        }>;
+      };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.outcomes).toHaveLength(2);
+    expect(body.data?.outcomes[0]).toMatchObject({
+      draft_id: 'bad-upload',
+      status: 'invalid',
+    });
+    expect(body.data?.outcomes[1]).toMatchObject({
+      draft_id: 'good-draft',
+      status: 'submitted',
+      request_id: 'exec_req_001',
+    });
+    await expect(
+      fs.readFile(path.join(repoRoot, '.aop', 'features', 'good_draft', 'spec.md'), 'utf8'),
+    ).resolves.toContain('Ship it.');
+  });
+
+  it('rejects duplicate slugs before writing specs or submitting enrollment requests', async () => {
+    prepareLaunchDraftSpecsMock.mockResolvedValue([
+      {
+        feature_id: 'duplicate_slug',
+        source_path: 'draft-a.md',
+        canonical_spec_path: '.aop/features/duplicate_slug/spec.md',
+        source_hash: 'hash-a',
+        content: '# Draft A',
+        write_required: true,
+      },
+    ]);
+
+    const response = await POST(
+      new Request('http://localhost/api/launch/submit', {
+        method: 'POST',
+        body: JSON.stringify({
+          drafts: [
+            {
+              draft_id: 'draft-a',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Draft A',
+              markdown: '# Draft A',
+            },
+            {
+              draft_id: 'draft-b',
+              draft_order: 1,
+              source_type: 'paste',
+              name: 'Draft B',
+              markdown: '# Draft B',
+            },
+          ],
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        outcomes: Array<{ draft_id: string; status: string; errors: string[] }>;
+      };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.outcomes).toEqual([
+      {
+        draft_id: 'draft-a',
+        feature_id: 'duplicate_slug',
+        canonical_spec_path: '.aop/features/duplicate_slug/spec.md',
+        status: 'invalid',
+        warnings: [],
+        errors: ['Duplicate feature_id detected: duplicate_slug'],
+      },
+      {
+        draft_id: 'draft-b',
+        feature_id: 'duplicate_slug',
+        canonical_spec_path: '.aop/features/duplicate_slug/spec.md',
+        status: 'invalid',
+        warnings: [],
+        errors: ['Duplicate feature_id detected: duplicate_slug'],
+      },
+    ]);
+    expect(submitLaunchEnrollmentMock).not.toHaveBeenCalled();
+    await expect(
+      fs.access(path.join(repoRoot, '.aop', 'features', 'duplicate_slug', 'spec.md')),
+    ).rejects.toThrow();
+  });
+
+  it('submits drafts deterministically by draft_order then feature_id', async () => {
+    submitLaunchEnrollmentMock.mockResolvedValue({
+      ok: true,
+      data: {
+        command: 'launch.submit',
+        mode: 'active_run_enrollment',
+        run_id: 'run:active',
+        request_id: 'exec_req_002',
+        request_status: 'pending',
+        requested_features: [],
+      },
+    });
+
+    await POST(
+      new Request('http://localhost/api/launch/submit', {
+        method: 'POST',
+        body: JSON.stringify({
+          drafts: [
+            {
+              draft_id: 'draft-b',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Beta Draft',
+              markdown: '# Beta Draft',
+            },
+            {
+              draft_id: 'draft-a',
+              draft_order: 0,
+              source_type: 'paste',
+              name: 'Alpha Draft',
+              markdown: '# Alpha Draft',
+            },
+          ],
+        }),
+      }),
+    );
+
+    expect(submitLaunchEnrollmentMock).toHaveBeenCalledWith(
+      [
+        {
+          feature_id: 'alpha_draft',
+          spec_path: '.aop/features/alpha_draft/spec.md',
+        },
+        {
+          feature_id: 'beta_draft',
+          spec_path: '.aop/features/beta_draft/spec.md',
+        },
+      ],
+      repoRoot,
+    );
+  });
+});

package/packages/web-dashboard/test/api/runtime/events/route.spec.ts

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { GET } from '@/app/api/runtime/events/route.js';
+
+const FEATURE_ID = 'feature_runtime_events';
+const RUN_ID = 'run:bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb';
+
+async function makeRepoRoot(): Promise<string> {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-runtime-events-'));
+  await fs.mkdir(path.join(root, '.aop', 'features', FEATURE_ID), { recursive: true });
+  await fs.mkdir(path.join(root, '.aop', 'runtime', 'worker-events'), { recursive: true });
+  await fs.writeFile(
+    path.join(root, '.aop', 'features', 'index.json'),
+    JSON.stringify({ active: [FEATURE_ID], blocked: [], merged: [] }, null, 2),
+  );
+  return root;
+}
+
+async function writeState(root: string, runId = RUN_ID) {
+  const state = `---\nfeature_id: ${FEATURE_ID}\nversion: 1\nstatus: planning\nrun_history:\n  - run_id: '${runId}'\n    started_at: '2026-03-05T22:24:39.635Z'\n    ended_at: null\n    status: active\n---\n`;
+  await fs.writeFile(path.join(root, '.aop', 'features', FEATURE_ID, 'state.md'), state, 'utf8');
+}
+
+async function writeEvents(root: string, runId: string, lines: string[]) {
+  await fs.writeFile(
+    path.join(root, '.aop', 'runtime', 'worker-events', `${runId}.jsonl`),
+    `${lines.join('\n')}\n`,
+    'utf8',
+  );
+}
+
+describe('GET /api/runtime/events', () => {
+  let repoRoot: string;
+  let originalRoot: string | undefined;
+
+  beforeEach(async () => {
+    originalRoot = process.env.AOP_ROOT;
+    repoRoot = await makeRepoRoot();
+    process.env.AOP_ROOT = repoRoot;
+  });
+
+  afterEach(async () => {
+    process.env.AOP_ROOT = originalRoot;
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('returns events for latest run', async () => {
+    await writeState(repoRoot);
+    await writeEvents(repoRoot, RUN_ID, [
+      JSON.stringify({
+        ts: '2026-03-05T22:24:39.635Z',
+        run_id: RUN_ID,
+        feature_id: FEATURE_ID,
+        role: 'planner',
+        phase: 'execution',
+        event_type: 'worker_started',
+        output_types: [],
+        patch_count: 0,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 0,
+        valid: true,
+      }),
+      JSON.stringify({
+        ts: '2026-03-05T22:25:39.635Z',
+        run_id: RUN_ID,
+        feature_id: FEATURE_ID,
+        role: 'builder',
+        phase: 'execution',
+        event_type: 'worker_completed',
+        output_types: ['PATCH'],
+        patch_count: 1,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 0,
+        valid: true,
+      }),
+    ]);
+
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/events?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { events: Array<{ role: string }> };
+    };
+    expect(body.ok).toBe(true);
+    expect(body.data?.events).toHaveLength(2);
+  });
+
+  it('filters events by role and event type', async () => {
+    await writeState(repoRoot);
+    await writeEvents(repoRoot, RUN_ID, [
+      JSON.stringify({
+        ts: '2026-03-05T22:24:39.635Z',
+        run_id: RUN_ID,
+        feature_id: FEATURE_ID,
+        role: 'planner',
+        phase: 'execution',
+        event_type: 'worker_started',
+        output_types: [],
+        patch_count: 0,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 0,
+        valid: true,
+      }),
+      JSON.stringify({
+        ts: '2026-03-05T22:25:39.635Z',
+        run_id: RUN_ID,
+        feature_id: FEATURE_ID,
+        role: 'builder',
+        phase: 'execution',
+        event_type: 'worker_completed',
+        output_types: [],
+        patch_count: 1,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 0,
+        valid: true,
+      }),
+    ]);
+
+    const response = await GET(
+      new Request(
+        `http://localhost/api/runtime/events?feature_id=${FEATURE_ID}&role=builder&event_type=worker_completed`,
+      ),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { events: Array<{ role: string; event_type: string }> };
+    };
+    expect(body.ok).toBe(true);
+    expect(body.data?.events).toHaveLength(1);
+    expect(body.data?.events?.[0]?.role).toBe('builder');
+  });
+
+  it('returns events_not_found when events file missing', async () => {
+    await writeState(repoRoot);
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/events?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as { ok: boolean; error?: { code?: string } };
+    expect(response.status).toBe(404);
+    expect(body.error?.code).toBe('events_not_found');
+  });
+
+  it('returns parse error on invalid JSONL', async () => {
+    await writeState(repoRoot);
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'runtime', 'worker-events', `${RUN_ID}.jsonl`),
+      'bad-json',
+      'utf8',
+    );
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/events?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as { ok: boolean; error?: { code?: string } };
+    expect(body.ok).toBe(false);
+    expect(body.error?.code).toBe('events_parse_error');
+  });
+});

package/packages/web-dashboard/test/api/runtime/operations/route.spec.ts

@@ -0,0 +1,156 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { GET } from '@/app/api/runtime/operations/route.js';
+
+const FEATURE_ID = 'feature_runtime_ops';
+const RUN_ID = 'run:aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa';
+
+async function makeRepoRoot(): Promise<string> {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-runtime-ops-'));
+  await fs.mkdir(path.join(root, '.aop', 'features', FEATURE_ID), { recursive: true });
+  await fs.mkdir(path.join(root, '.aop', 'runtime', 'operation-ledger'), { recursive: true });
+  await fs.writeFile(
+    path.join(root, '.aop', 'features', 'index.json'),
+    JSON.stringify({ active: [FEATURE_ID], blocked: [], merged: [] }, null, 2),
+  );
+  return root;
+}
+
+async function writeState(root: string, runId = RUN_ID) {
+  const state = `---\nfeature_id: ${FEATURE_ID}\nversion: 1\nstatus: planning\nrun_history:\n  - run_id: '${runId}'\n    started_at: '2026-03-05T22:24:39.635Z'\n    ended_at: null\n    status: active\n---\n`;
+  await fs.writeFile(path.join(root, '.aop', 'features', FEATURE_ID, 'state.md'), state, 'utf8');
+}
+
+async function writeLedger(root: string, runId = RUN_ID, ledger: Record<string, unknown>) {
+  await fs.writeFile(
+    path.join(root, '.aop', 'runtime', 'operation-ledger', `${runId}.json`),
+    JSON.stringify(ledger, null, 2),
+    'utf8',
+  );
+}
+
+describe('GET /api/runtime/operations', () => {
+  let repoRoot: string;
+  let originalRoot: string | undefined;
+
+  beforeEach(async () => {
+    originalRoot = process.env.AOP_ROOT;
+    repoRoot = await makeRepoRoot();
+    process.env.AOP_ROOT = repoRoot;
+  });
+
+  afterEach(async () => {
+    process.env.AOP_ROOT = originalRoot;
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('returns operations for latest run', async () => {
+    await writeState(repoRoot);
+    await writeLedger(repoRoot, RUN_ID, {
+      run_id: RUN_ID,
+      updated_at: '2026-03-05T22:30:00.000Z',
+      operations: {
+        [`feature_init__${FEATURE_ID}__1111`]: {
+          operation_id: `feature_init__${FEATURE_ID}__1111`,
+          tool_name: 'feature.init',
+          request_hash: 'hash-a',
+          response: { ok: true, data: { initialized: true } },
+          created_at: '2026-03-05T22:25:00.000Z',
+          updated_at: '2026-03-05T22:25:00.000Z',
+        },
+        [`plan_submit__${FEATURE_ID}__2222`]: {
+          operation_id: `plan_submit__${FEATURE_ID}__2222`,
+          tool_name: 'plan.submit',
+          request_hash: 'hash-b',
+          response: { ok: false, error: { code: 'plan_invalid', message: 'bad' } },
+          created_at: '2026-03-05T22:26:00.000Z',
+          updated_at: '2026-03-05T22:26:00.000Z',
+        },
+        other_feature__3333: {
+          operation_id: 'other_feature__3333',
+          tool_name: 'feature.init',
+          request_hash: 'hash-c',
+          response: { ok: true },
+          created_at: '2026-03-05T22:27:00.000Z',
+          updated_at: '2026-03-05T22:27:00.000Z',
+        },
+      },
+    });
+
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/operations?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { operations: Array<{ tool_name: string }> };
+    };
+    expect(body.ok).toBe(true);
+    expect(body.data?.operations).toHaveLength(2);
+  });
+
+  it('filters operations by tool_name', async () => {
+    await writeState(repoRoot);
+    await writeLedger(repoRoot, RUN_ID, {
+      run_id: RUN_ID,
+      updated_at: '2026-03-05T22:30:00.000Z',
+      operations: {
+        [`feature_init__${FEATURE_ID}__1111`]: {
+          operation_id: `feature_init__${FEATURE_ID}__1111`,
+          tool_name: 'feature.init',
+          request_hash: 'hash-a',
+          response: { ok: true },
+          created_at: '2026-03-05T22:25:00.000Z',
+          updated_at: '2026-03-05T22:25:00.000Z',
+        },
+        [`plan_submit__${FEATURE_ID}__2222`]: {
+          operation_id: `plan_submit__${FEATURE_ID}__2222`,
+          tool_name: 'plan.submit',
+          request_hash: 'hash-b',
+          response: { ok: true },
+          created_at: '2026-03-05T22:26:00.000Z',
+          updated_at: '2026-03-05T22:26:00.000Z',
+        },
+      },
+    });
+
+    const response = await GET(
+      new Request(
+        `http://localhost/api/runtime/operations?feature_id=${FEATURE_ID}&tool_name=plan.submit`,
+      ),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { operations: Array<{ tool_name: string }> };
+    };
+    expect(body.ok).toBe(true);
+    expect(body.data?.operations).toHaveLength(1);
+    expect(body.data?.operations?.[0]?.tool_name).toBe('plan.submit');
+  });
+
+  it('returns ledger_not_found when ledger missing', async () => {
+    await writeState(repoRoot);
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/operations?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as { ok: boolean; error?: { code?: string } };
+    expect(response.status).toBe(404);
+    expect(body.error?.code).toBe('ledger_not_found');
+  });
+
+  it('returns parse error for invalid ledger JSON', async () => {
+    await writeState(repoRoot);
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'runtime', 'operation-ledger', `${RUN_ID}.json`),
+      '{bad json',
+      'utf8',
+    );
+    const response = await GET(
+      new Request(`http://localhost/api/runtime/operations?feature_id=${FEATURE_ID}`),
+    );
+    const body = (await response.json()) as { ok: boolean; error?: { code?: string } };
+    expect(body.ok).toBe(false);
+    expect(body.error?.code).toBe('ledger_parse_error');
+  });
+});