agentic-orchestrator 0.1.27 → 0.2.0

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

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const readLiveFeatureDiffMock = vi.hoisted(() => vi.fn(async () => ''));
+
+vi.mock('@/lib/aop-client.js', () => ({
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/worktree-diff.js', () => ({
+  readLiveFeatureDiff: readLiveFeatureDiffMock,
+}));
+
+import { GET } from '@/app/api/features/[id]/diff/route.js';
+
+describe('GET /api/features/[id]/diff', () => {
+  beforeEach(() => {
+    resolveProjectRootMock.mockReset();
+    readLiveFeatureDiffMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    readLiveFeatureDiffMock.mockResolvedValue('diff --git a/src/a.ts b/src/a.ts\n');
+  });
+
+  it('returns the current live worktree diff as plain text', async () => {
+    const response = await GET(
+      new Request('http://localhost/api/features/feature_live/diff?project=demo'),
+      { params: Promise.resolve({ id: 'feature_live' }) },
+    );
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toBe('text/plain');
+    expect(await response.text()).toContain('diff --git a/src/a.ts b/src/a.ts');
+    expect(readLiveFeatureDiffMock).toHaveBeenCalledWith('feature_live', '/repo');
+  });
+
+  it('returns 404 when the feature cannot be resolved', async () => {
+    readLiveFeatureDiffMock.mockResolvedValue(null);
+
+    const response = await GET(new Request('http://localhost/api/features/missing/diff'), {
+      params: Promise.resolve({ id: 'missing' }),
+    });
+
+    expect(response.status).toBe(404);
+    expect(await response.text()).toContain('Feature missing not found');
+  });
+
+  it('returns 400 for an invalid feature id', async () => {
+    const response = await GET(new Request('http://localhost/api/features/Bad!/diff'), {
+      params: Promise.resolve({ id: 'Bad!' }),
+    });
+
+    expect(response.status).toBe(400);
+    expect(await response.text()).toContain('Invalid feature id');
+    expect(readLiveFeatureDiffMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const authorizeDashboardActionMock = vi.hoisted(() => vi.fn(async () => ({ allowed: true })));
+const readFeatureDetailMock = vi.hoisted(() => vi.fn());
+const readFeaturesIndexMock = vi.hoisted(() => vi.fn());
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const isDashboardRuntimeAvailableMock = vi.hoisted(() => vi.fn(async () => false));
+
+vi.mock('@/lib/authz-adapter.js', () => ({
+  authorizeDashboardAction: authorizeDashboardActionMock,
+}));
+
+vi.mock('@/lib/aop-client.js', () => ({
+  readFeatureDetail: readFeatureDetailMock,
+  readFeaturesIndex: readFeaturesIndexMock,
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/dashboard-runtime-client.js', () => ({
+  isDashboardRuntimeAvailable: isDashboardRuntimeAvailableMock,
+}));
+
+import { GET } from '@/app/api/features/[id]/route.js';
+
+describe('GET /api/features/[id]', () => {
+  beforeEach(() => {
+    authorizeDashboardActionMock.mockReset();
+    readFeatureDetailMock.mockReset();
+    readFeaturesIndexMock.mockReset();
+    resolveProjectRootMock.mockReset();
+    isDashboardRuntimeAvailableMock.mockReset();
+
+    authorizeDashboardActionMock.mockResolvedValue({ allowed: true });
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    isDashboardRuntimeAvailableMock.mockResolvedValue(false);
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_building'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: {
+        run_id: 'run:active',
+        owner_instance_id: 'owner:active',
+      },
+    });
+    readFeatureDetailMock.mockResolvedValue({
+      feature: {
+        id: 'feature_building',
+        feature_id: 'feature_building',
+        status: 'building',
+        phase: 'building',
+        activity_state: 'unknown',
+      },
+      plan: null,
+      diff: '',
+      evidence: [],
+    });
+  });
+
+  it('returns action states with resume enabled for focus detail', async () => {
+    const response = await GET(new Request('http://localhost/api/features/feature_building'), {
+      params: Promise.resolve({ id: 'feature_building' }),
+    });
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { actions?: { resume?: { enabled: boolean; reason: string | null } } };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.actions?.resume?.enabled).toBe(true);
+    expect(body.data?.actions?.resume?.reason).toBeNull();
+  });
+
+  it('allows focus detail to surface resume when only the dashboard runtime is available', async () => {
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_building'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: {
+        run_id: 'none',
+        owner_instance_id: 'none',
+      },
+    });
+    isDashboardRuntimeAvailableMock.mockResolvedValue(true);
+
+    const response = await GET(new Request('http://localhost/api/features/feature_building'), {
+      params: Promise.resolve({ id: 'feature_building' }),
+    });
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { actions?: { resume?: { enabled: boolean; reason: string | null } } };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.actions?.resume?.enabled).toBe(true);
+    expect(body.data?.actions?.resume?.reason).toBeNull();
+  });
+});

package/packages/web-dashboard/test/api/features/live-output.route.spec.ts

@@ -0,0 +1,123 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const readFeatureStateMock = vi.hoisted(() => vi.fn(async () => ({ status: 'building' })));
+const readLiveAgentOutputSnapshotsMock = vi.hoisted(() => vi.fn(async () => []));
+const readPolicyYamlMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    observability: { raw_agent_logs_enabled: true },
+  })),
+);
+
+vi.mock('@/lib/aop-client.js', () => ({
+  DEFAULT_LIVE_AGENT_OUTPUT_LINE_LIMIT: 500,
+  resolveProjectRoot: resolveProjectRootMock,
+  readFeatureState: readFeatureStateMock,
+  readLiveAgentOutputSnapshots: readLiveAgentOutputSnapshotsMock,
+}));
+
+vi.mock('@/lib/policy-reader.js', () => ({
+  readPolicyYaml: readPolicyYamlMock,
+}));
+
+import { GET } from '@/app/api/features/[id]/live-output/route.js';
+
+describe('GET /api/features/[id]/live-output', () => {
+  beforeEach(() => {
+    resolveProjectRootMock.mockReset();
+    readFeatureStateMock.mockReset();
+    readLiveAgentOutputSnapshotsMock.mockReset();
+    readPolicyYamlMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    readFeatureStateMock.mockResolvedValue({ status: 'building' });
+    readLiveAgentOutputSnapshotsMock.mockResolvedValue([
+      {
+        role: 'builder',
+        session_id: 'session-builder',
+        provider: 'codex',
+        model: 'gpt-5.4',
+        execution_mode: 'interactive',
+        status: 'running',
+        started_at: '2026-03-18T18:00:00.000Z',
+        ended_at: null,
+        updated_at: '2026-03-18T18:00:05.000Z',
+        size_bytes: 42,
+        content: 'building...\n',
+      },
+    ]);
+    readPolicyYamlMock.mockResolvedValue({
+      observability: { raw_agent_logs_enabled: true },
+    });
+  });
+
+  it('returns live output snapshots when observability is enabled', async () => {
+    const response = await GET(
+      new Request('http://localhost/api/features/feature_live/live-output?project=demo'),
+      { params: Promise.resolve({ id: 'feature_live' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        enabled: boolean;
+        line_limit: number;
+        snapshots: Array<{ role: string; content: string }>;
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.enabled).toBe(true);
+    expect(body.data?.line_limit).toBe(500);
+    expect(body.data?.snapshots).toEqual([
+      expect.objectContaining({
+        role: 'builder',
+        content: 'building...\n',
+      }),
+    ]);
+    expect(readLiveAgentOutputSnapshotsMock).toHaveBeenCalledWith('feature_live', '/repo', {
+      tailLines: 500,
+    });
+  });
+
+  it('honors an explicit line limit override', async () => {
+    const response = await GET(
+      new Request('http://localhost/api/features/feature_live/live-output?line_limit=1200'),
+      {
+        params: Promise.resolve({ id: 'feature_live' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { line_limit: number };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.line_limit).toBe(1200);
+    expect(readLiveAgentOutputSnapshotsMock).toHaveBeenCalledWith('feature_live', '/repo', {
+      tailLines: 1200,
+    });
+  });
+
+  it('returns a disabled payload when observability is turned off', async () => {
+    readPolicyYamlMock.mockResolvedValue({
+      observability: { raw_agent_logs_enabled: false },
+    });
+
+    const response = await GET(
+      new Request('http://localhost/api/features/feature_live/live-output'),
+      {
+        params: Promise.resolve({ id: 'feature_live' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { enabled: boolean; line_limit: number; snapshots: unknown[] };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data).toEqual({ enabled: false, line_limit: 500, snapshots: [] });
+  });
+});

package/packages/web-dashboard/test/api/features/plan-amend.route.spec.ts

@@ -0,0 +1,95 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const amendFeaturePlanMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@/lib/aop-client.js', () => ({
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/orchestrator-tools.js', () => ({
+  amendFeaturePlan: amendFeaturePlanMock,
+}));
+
+import { POST } from '@/app/api/features/[id]/plan/amend/route.js';
+
+describe('POST /api/features/[id]/plan/amend', () => {
+  beforeEach(() => {
+    resolveProjectRootMock.mockReset();
+    amendFeaturePlanMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    amendFeaturePlanMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 3,
+        plan_json: {
+          feature_id: 'feature_a',
+          plan_version: 3,
+          revision_of: 2,
+        },
+      },
+    });
+  });
+
+  it('amends the live accepted plan through the shared orchestrator helper', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/features/feature_a/plan/amend?project=demo', {
+        method: 'POST',
+        body: JSON.stringify({
+          plan_json: '{\"feature_id\":\"feature_a\",\"summary\":\"edited\"}',
+          revision_reason: 'Repair invalid plan trace',
+        }),
+      }),
+      {
+        params: Promise.resolve({ id: 'feature_a' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { plan_version?: number };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.plan_version).toBe(3);
+    expect(amendFeaturePlanMock).toHaveBeenCalledWith(
+      'feature_a',
+      '{"feature_id":"feature_a","summary":"edited"}',
+      'Repair invalid plan trace',
+      '/repo',
+    );
+  });
+
+  it('returns a conflict when the underlying amendment fails', async () => {
+    amendFeaturePlanMock.mockResolvedValue({
+      ok: false,
+      error: {
+        code: 'plan_trace_invalid',
+        message: 'plan trace does not match the verified manifest contract',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/features/feature_a/plan/amend', {
+        method: 'POST',
+        body: JSON.stringify({
+          plan_json: '{\"feature_id\":\"feature_a\"}',
+        }),
+      }),
+      {
+        params: Promise.resolve({ id: 'feature_a' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error?: { code?: string };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error?.code).toBe('plan_trace_invalid');
+  });
+});

package/packages/web-dashboard/test/api/features/planner-workspaces.route.spec.ts

@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const readPlannerLifecycleMock = vi.hoisted(() => vi.fn());
+const readFeatureIntakeWorkspaceMock = vi.hoisted(() => vi.fn());
+const readFeaturePlanningWorkspaceMock = vi.hoisted(() => vi.fn());
+const readPlannerArtifactRawMock = vi.hoisted(() => vi.fn());
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+
+vi.mock('@/lib/aop-client.js', () => ({
+  readPlannerLifecycle: readPlannerLifecycleMock,
+  readFeatureIntakeWorkspace: readFeatureIntakeWorkspaceMock,
+  readFeaturePlanningWorkspace: readFeaturePlanningWorkspaceMock,
+  readPlannerArtifactRaw: readPlannerArtifactRawMock,
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+import { GET as getIntakeWorkspace } from '@/app/api/features/[id]/intake-workspace/route.js';
+import { GET as getPlannerArtifact } from '@/app/api/features/[id]/planner-artifacts/[artifact]/route.js';
+import { GET as getPlannerLifecycle } from '@/app/api/features/[id]/planner-lifecycle/route.js';
+import { GET as getPlanningWorkspace } from '@/app/api/features/[id]/planning-workspace/route.js';
+
+describe('planner workspace routes', () => {
+  beforeEach(() => {
+    readPlannerLifecycleMock.mockReset();
+    readFeatureIntakeWorkspaceMock.mockReset();
+    readFeaturePlanningWorkspaceMock.mockReset();
+    readPlannerArtifactRawMock.mockReset();
+    resolveProjectRootMock.mockReset();
+    resolveProjectRootMock.mockResolvedValue('/repo');
+  });
+
+  it('returns planner lifecycle data', async () => {
+    readPlannerLifecycleMock.mockResolvedValue({
+      current_subphase: 'intake',
+      current_owner: 'operator',
+      last_updated_at: null,
+      banner_state: 'waiting_on_intake_clarification',
+      lifecycle_steps: [],
+      next_action: 'Answer the intake question.',
+      primary_detail: 'Blocked on intake clarification.',
+    });
+
+    const response = await getPlannerLifecycle(
+      new Request('http://localhost/api/features/feature_focus/planner-lifecycle'),
+      {
+        params: Promise.resolve({ id: 'feature_focus' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { banner_state?: string };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.banner_state).toBe('waiting_on_intake_clarification');
+  });
+
+  it('returns intake workspace data and preserves partial artifacts', async () => {
+    readFeatureIntakeWorkspaceMock.mockResolvedValue({
+      lifecycle: {
+        current_subphase: 'intake',
+        current_owner: 'operator',
+        last_updated_at: null,
+        banner_state: 'waiting_on_intake_clarification',
+        lifecycle_steps: [],
+        next_action: 'Answer the intake question.',
+        primary_detail: 'Blocked on intake clarification.',
+      },
+      summary: null,
+      review: null,
+      bootstrap_manifest: null,
+      verified_manifest: null,
+      open_ambiguities: [],
+      resolved_ambiguities: [],
+      promotion_readiness: {
+        ready: false,
+        blocker_reasons: ['Verified manifest has not been promoted yet.'],
+        verified_manifest_exists: false,
+        open_questions_remaining: false,
+        unresolved_ambiguities_remaining: false,
+      },
+      manifest_delta: {
+        ambiguities_resolved: 0,
+        ambiguities_open: 0,
+        obligations_added: 0,
+        obligations_removed: 0,
+        confidence_upgrades: 0,
+        confidence_downgrades: 0,
+      },
+      open_questions: [],
+      general_questions: [],
+      artifacts: [
+        {
+          id: 'verified_manifest',
+          label: 'Verified Manifest',
+          format: 'json',
+          path: '.aop/features/feature_focus/spec.manifest.verified.json',
+          version: null,
+          updated_at: null,
+          raw_content: null,
+          primary: false,
+          authority_label: 'Pending verification',
+          empty_state: 'Verified manifest has not been promoted yet.',
+        },
+      ],
+    });
+
+    const response = await getIntakeWorkspace(
+      new Request('http://localhost/api/features/feature_focus/intake-workspace'),
+      {
+        params: Promise.resolve({ id: 'feature_focus' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { artifacts?: Array<{ id: string; raw_content: string | null }> };
+    };
+
+    expect(body.ok).toBe(true);
+    expect(body.data?.artifacts?.[0]).toMatchObject({
+      id: 'verified_manifest',
+      raw_content: null,
+    });
+  });
+
+  it('returns 404 when the planning workspace is missing', async () => {
+    readFeaturePlanningWorkspaceMock.mockResolvedValue(null);
+
+    const response = await getPlanningWorkspace(
+      new Request('http://localhost/api/features/missing/planning-workspace'),
+      {
+        params: Promise.resolve({ id: 'missing' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error?: { code?: string };
+    };
+
+    expect(response.status).toBe(404);
+    expect(body.ok).toBe(false);
+    expect(body.error?.code).toBe('feature_not_found');
+  });
+
+  it('streams planner artifacts as raw content', async () => {
+    readPlannerArtifactRawMock.mockResolvedValue({
+      content: '# Plan Markdown',
+      path: '/repo/.aop/features/feature_focus/plan.md',
+    });
+
+    const response = await getPlannerArtifact(
+      new Request('http://localhost/api/features/feature_focus/planner-artifacts/plan_markdown'),
+      {
+        params: Promise.resolve({ id: 'feature_focus', artifact: 'plan_markdown' }),
+      },
+    );
+
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe('# Plan Markdown');
+    expect(response.headers.get('Content-Type')).toContain('text/plain');
+  });
+});

package/packages/web-dashboard/test/api/features/question-answer.route.spec.ts

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/repo'));
+const answerFeatureQuestionMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@/lib/aop-client.js', () => ({
+  resolveProjectRoot: resolveProjectRootMock,
+}));
+
+vi.mock('@/lib/orchestrator-tools.js', () => ({
+  answerFeatureQuestion: answerFeatureQuestionMock,
+}));
+
+import { POST } from '@/app/api/features/[id]/questions/[questionId]/answer/route.js';
+
+describe('POST /api/features/[id]/questions/[questionId]/answer', () => {
+  beforeEach(() => {
+    resolveProjectRootMock.mockReset();
+    answerFeatureQuestionMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue('/repo');
+    answerFeatureQuestionMock.mockResolvedValue({
+      ok: true,
+      data: {
+        feature_id: 'feature_a',
+        question_id: 'q_123',
+        question_status: 'answered',
+        feature_status: 'planning',
+        resumed: true,
+      },
+    });
+  });
+
+  it('answers feature questions through the shared orchestrator tool route', async () => {
+    const response = await POST(
+      new Request('http://localhost/api/features/feature_a/questions/q_123/answer?project=demo', {
+        method: 'POST',
+        body: JSON.stringify({
+          answer: 'ship it',
+          answered_by: 'dashboard-user',
+        }),
+      }),
+      {
+        params: Promise.resolve({ id: 'feature_a', questionId: 'q_123' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { resumed?: boolean };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(answerFeatureQuestionMock).toHaveBeenCalledWith(
+      'feature_a',
+      'q_123',
+      'ship it',
+      'dashboard-user',
+      '/repo',
+    );
+  });
+
+  it('returns a conflict response when the underlying tool call fails', async () => {
+    answerFeatureQuestionMock.mockResolvedValue({
+      ok: false,
+      error: {
+        code: 'forbidden_tool_for_role',
+        message: 'Tool feature.question_answer is not allowed for role orchestrator',
+      },
+    });
+
+    const response = await POST(
+      new Request('http://localhost/api/features/feature_a/questions/q_123/answer', {
+        method: 'POST',
+        body: JSON.stringify({
+          answer: { choice: 'approve' },
+        }),
+      }),
+      {
+        params: Promise.resolve({ id: 'feature_a', questionId: 'q_123' }),
+      },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error?: { code?: string };
+    };
+
+    expect(response.status).toBe(409);
+    expect(body.ok).toBe(false);
+    expect(body.error?.code).toBe('forbidden_tool_for_role');
+    expect(answerFeatureQuestionMock).toHaveBeenCalledWith(
+      'feature_a',
+      'q_123',
+      { choice: 'approve' },
+      'dashboard',
+      '/repo',
+    );
+  });
+});