agentic-orchestrator 0.1.28 → 0.2.0

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

@@ -0,0 +1,675 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const authorizeDashboardActionMock = vi.hoisted(() => vi.fn(async () => ({ allowed: true })));
+const readFeaturesIndexMock = vi.hoisted(() => vi.fn());
+const readFeatureStateMock = vi.hoisted(() => vi.fn());
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const readActiveRunLeaseMock = vi.hoisted(() => vi.fn(async () => null));
+const isDashboardRuntimeAvailableMock = vi.hoisted(() => vi.fn(async () => false));
+const retryFeatureMock = vi.hoisted(() =>
+  vi.fn(async () => ({ ok: true, data: { mode: 'full' } })),
+);
+const resumeFeatureExecutionMock = vi.hoisted(() =>
+  vi.fn(async () => ({ ok: true, data: { command: 'resume', resumed: true } })),
+);
+const submitFeatureEnrollmentMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    ok: true,
+    data: { request_id: 'exec_req_123', request_status: 'pending' },
+  })),
+);
+const approveFeatureReviewMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    ok: true,
+    data: {
+      feature_id: 'feature_ready',
+      merge_sha: 'merge-sha',
+      merge_strategy: 'merge_commit',
+      status: 'merged',
+    },
+  })),
+);
+const runFeatureMergeGateMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    ok: true,
+    data: {
+      feature_id: 'feature_ready',
+      merge_gate_run: true,
+      merge_gate_overall: 'pass',
+      reconciliation_status: 'up_to_date',
+    },
+  })),
+);
+const requestFeatureChangesMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    ok: true,
+    data: {
+      feature_id: 'feature_ready',
+      rerouted_to_qa: true,
+      merge_repair_attempt: 1,
+      merge_repair_max_attempts: 5,
+    },
+  })),
+);
+
+vi.mock('@/lib/authz-adapter.js', () => ({
+  authorizeDashboardAction: authorizeDashboardActionMock,
+}));
+
+vi.mock('@/lib/aop-client.js', () => ({
+  readFeaturesIndex: readFeaturesIndexMock,
+  readFeatureState: readFeatureStateMock,
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/dashboard-runtime-client.js', () => ({
+  isDashboardRuntimeAvailable: isDashboardRuntimeAvailableMock,
+}));
+
+vi.mock('@/lib/runtime-files.js', () => ({
+  readActiveRunLease: readActiveRunLeaseMock,
+}));
+
+vi.mock('@/lib/orchestrator-tools.js', () => ({
+  approveFeatureReview: approveFeatureReviewMock,
+  approveFeatureReviewAsync: approveFeatureReviewMock,
+  denyFeatureReview: vi.fn(),
+  resumeFeatureExecution: resumeFeatureExecutionMock,
+  requestFeatureChanges: requestFeatureChangesMock,
+  retryFeature: retryFeatureMock,
+  runFeatureMergeGate: runFeatureMergeGateMock,
+  sendFeatureMessage: vi.fn(),
+  submitFeatureEnrollment: submitFeatureEnrollmentMock,
+}));
+
+import { POST } from '@/app/api/actions/route.js';
+
+describe('POST /api/actions', () => {
+  beforeEach(() => {
+    authorizeDashboardActionMock.mockReset();
+    readFeaturesIndexMock.mockReset();
+    readFeatureStateMock.mockReset();
+    resolveProjectRootMock.mockReset();
+    readActiveRunLeaseMock.mockReset();
+    isDashboardRuntimeAvailableMock.mockReset();
+    retryFeatureMock.mockReset();
+    resumeFeatureExecutionMock.mockReset();
+    submitFeatureEnrollmentMock.mockReset();
+    approveFeatureReviewMock.mockReset();
+    runFeatureMergeGateMock.mockReset();
+    requestFeatureChangesMock.mockReset();
+
+    authorizeDashboardActionMock.mockResolvedValue({ allowed: true });
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    readActiveRunLeaseMock.mockResolvedValue(null);
+    isDashboardRuntimeAvailableMock.mockResolvedValue(false);
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_a'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: {
+        run_id: 'run:active',
+        owner_instance_id: 'owner:active',
+      },
+    });
+    retryFeatureMock.mockResolvedValue({ ok: true, data: { mode: 'full' } });
+    resumeFeatureExecutionMock.mockResolvedValue({
+      ok: true,
+      data: { command: 'resume', resumed: true },
+    });
+    submitFeatureEnrollmentMock.mockResolvedValue({
+      ok: true,
+      data: { request_id: 'exec_req_123', request_status: 'pending' },
+    });
+    approveFeatureReviewMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_ready',
+        merge_sha: 'merge-sha',
+        merge_strategy: 'merge_commit',
+        status: 'merged',
+      },
+    });
+    runFeatureMergeGateMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_ready',
+        merge_gate_run: true,
+        merge_gate_overall: 'pass',
+        reconciliation_status: 'up_to_date',
+      },
+    });
+    requestFeatureChangesMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_ready',
+        rerouted_to_qa: true,
+        merge_repair_attempt: 1,
+        merge_repair_max_attempts: 5,
+      },
+    });
+  });
+
+  it('routes blocked features to retry instead of resume', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_blocked',
+      status: 'blocked',
+      phase: 'blocked',
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_blocked',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: {
+        retry: Record<string, unknown>;
+        auto_resume: { attempted: boolean; skipped_reason: string };
+      };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.action_state.enabled).toBe(true);
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_blocked', '/repo');
+    expect(body.data.auto_resume.attempted).toBe(false);
+    expect(body.data.auto_resume.skipped_reason).toBe('no_resume_required');
+    expect(resumeFeatureExecutionMock).not.toHaveBeenCalled();
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('routes blocked mainline-conflict features straight into reconciliation resume without rerouting state', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_blocked',
+      status: 'blocked',
+      phase: 'blocked',
+      status_reason: 'Mainline divergence assigned to the shared reconciler lane',
+    });
+    retryFeatureMock.mockResolvedValue({
+      ok: true,
+      data: { retry_mode: 'reconciler', reroute_status: 'blocked' },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_blocked',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: {
+        retry: { retry_mode: string; reroute_status: string };
+        auto_resume: Record<string, unknown>;
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data.retry.retry_mode).toBe('reconciler');
+    expect(body.data.retry.reroute_status).toBe('blocked');
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_blocked', '/repo');
+    expect(resumeFeatureExecutionMock).toHaveBeenCalledWith('feature_blocked', '/repo');
+  });
+
+  it('re-enrolls blocked retry into the active run when a fresh lease exists', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_blocked',
+      status: 'blocked',
+      phase: 'blocked',
+    });
+    readActiveRunLeaseMock.mockResolvedValue({
+      run_id: 'run:lease',
+      owner_instance_id: 'owner:lease',
+      assigned_feature_ids: [],
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_blocked',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: {
+        retry: Record<string, unknown>;
+        auto_resume: { attempted: boolean; skipped_reason: string };
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_blocked', '/repo');
+    expect(body.data.auto_resume.attempted).toBe(false);
+    expect(body.data.auto_resume.skipped_reason).toBe('no_resume_required');
+    expect(resumeFeatureExecutionMock).not.toHaveBeenCalled();
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('falls back to resume when the active lease already owns the feature session', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_blocked',
+      status: 'blocked',
+      phase: 'blocked',
+    });
+    readActiveRunLeaseMock.mockResolvedValue({
+      run_id: 'run:lease',
+      owner_instance_id: 'owner:lease',
+      assigned_feature_ids: ['feature_blocked'],
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_blocked',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: {
+        retry: Record<string, unknown>;
+        auto_resume: { attempted: boolean; skipped_reason: string };
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_blocked', '/repo');
+    expect(body.data.auto_resume.attempted).toBe(false);
+    expect(body.data.auto_resume.skipped_reason).toBe('no_resume_required');
+    expect(resumeFeatureExecutionMock).not.toHaveBeenCalled();
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('allows feature.resume through the dashboard runtime when no active run lease exists', async () => {
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_waiting'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: {
+        run_id: 'none',
+        owner_instance_id: 'none',
+      },
+    });
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_waiting',
+      status: 'building',
+      phase: 'building',
+    });
+    isDashboardRuntimeAvailableMock.mockResolvedValue(true);
+    resumeFeatureExecutionMock.mockResolvedValue({
+      ok: true,
+      data: {
+        command: 'resume',
+        handoff_started: true,
+        handoff_target: 'runtime',
+        started: true,
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.resume',
+          feature_id: 'feature_waiting',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: { command: string; handoff_started: boolean };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data.command).toBe('resume');
+    expect(body.data.handoff_started).toBe(true);
+    expect(body.action_state.enabled).toBe(true);
+    expect(resumeFeatureExecutionMock).toHaveBeenCalledWith('feature_waiting', '/repo');
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('surfaces retry recovery failures after the gate rerun succeeds', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_blocked',
+      status: 'blocked',
+      phase: 'blocked',
+    });
+    retryFeatureMock.mockResolvedValue({
+      ok: true,
+      data: { reroute_status: 'building' },
+    });
+    resumeFeatureExecutionMock.mockResolvedValue({
+      ok: false,
+      error: {
+        code: 'runtime_unavailable',
+        message: 'resume failed',
+        details: { reason: 'kernel offline' },
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_blocked',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string; message: string };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('runtime_unavailable');
+    expect(body.error.message).toBe('resume failed');
+  });
+
+  it('routes resumable non-terminal features through the dashboard runtime', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_building',
+      status: 'building',
+      phase: 'building',
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.resume',
+          feature_id: 'feature_building',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.action_state.enabled).toBe(true);
+    expect(resumeFeatureExecutionMock).toHaveBeenCalledWith('feature_building', '/repo');
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('preserves direct retry compatibility for non-terminal features', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_ready',
+      status: 'ready_to_merge',
+      phase: 'ready_to_merge',
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_ready',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.action_state.enabled).toBe(true);
+    expect(retryFeatureMock).toHaveBeenCalledWith('feature_ready', '/repo');
+  });
+
+  it('disables approval until the merge gate has passed', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_ready',
+      status: 'ready_to_merge',
+      phase: 'ready_to_merge',
+      gates: {
+        full: 'pass',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.approve',
+          feature_id: 'feature_ready',
+          approval_token: 'approve_me',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string; message: string };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('action_disabled');
+    expect(body.action_state.enabled).toBe(false);
+    expect(body.action_state.reason).toContain('merge gate');
+  });
+
+  it('runs the merge gate from the review action endpoint', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_ready',
+      status: 'ready_to_merge',
+      phase: 'ready_to_merge',
+      gates: {
+        merge: 'fail',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.run_merge_gate',
+          feature_id: 'feature_ready',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: { merge_gate_overall: string };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data.merge_gate_overall).toBe('pass');
+    expect(body.action_state.enabled).toBe(true);
+    expect(runFeatureMergeGateMock).toHaveBeenCalledWith('feature_ready', '/repo', { force: true });
+  });
+
+  it('forwards the review message as the merge commit message for dashboard approval', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_ready',
+      status: 'ready_to_merge',
+      phase: 'ready_to_merge',
+      gates: {
+        merge: 'pass',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.approve',
+          feature_id: 'feature_ready',
+          approval_token: 'approve_me',
+          merge_strategy: 'merge_commit',
+          message:
+            'Created a separation between the intake and planning tabs with clearer defined behaviors.',
+        }),
+      }),
+    );
+
+    expect(response.status).toBe(202);
+    expect(approveFeatureReviewMock).toHaveBeenCalledWith(
+      'feature_ready',
+      'approve_me',
+      'merge_commit',
+      'Created a separation between the intake and planning tabs with clearer defined behaviors.',
+      '/repo',
+    );
+  });
+
+  it('routes blocked merge failures back to QA when request changes is submitted', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_ready',
+      status: 'blocked',
+      phase: 'blocked',
+      gates: {
+        merge: 'fail',
+      },
+      merge_repair: {
+        attempts: 1,
+        max_attempts: 5,
+        active: true,
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.request_changes',
+          feature_id: 'feature_ready',
+          message: 'Please repair the merge gate',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: { rerouted_to_qa: boolean; merge_repair_attempt: number };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data.rerouted_to_qa).toBe(true);
+    expect(body.data.merge_repair_attempt).toBe(1);
+    expect(requestFeatureChangesMock).toHaveBeenCalledWith(
+      'feature_ready',
+      'Please repair the merge gate',
+      '/repo',
+    );
+  });
+
+  it('does not use retry compatibility mode for awaiting-input features', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_waiting',
+      status: 'awaiting_input',
+      phase: 'awaiting_input',
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.retry',
+          feature_id: 'feature_waiting',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('action_disabled');
+    expect(body.action_state.enabled).toBe(false);
+    expect(body.action_state.reason).toContain('Only blocked features can be retried');
+    expect(retryFeatureMock).not.toHaveBeenCalled();
+  });
+
+  it('allows resume for awaiting-input features so the runtime can wait for answers', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_waiting',
+      status: 'awaiting_input',
+      phase: 'awaiting_input',
+      open_question_count: 1,
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.resume',
+          feature_id: 'feature_waiting',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.action_state.enabled).toBe(true);
+    expect(resumeFeatureExecutionMock).toHaveBeenCalledWith('feature_waiting', '/repo');
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+
+  it('disables resume for terminal features with an explicit reason', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      feature_id: 'feature_merged',
+      status: 'merged',
+      phase: 'merged',
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.resume',
+          feature_id: 'feature_merged',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string };
+      action_state: { enabled: boolean; reason: string | null };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('action_disabled');
+    expect(body.action_state.reason).toContain('terminal');
+    expect(submitFeatureEnrollmentMock).not.toHaveBeenCalled();
+  });
+});