agentic-orchestrator 0.1.26 → 0.1.28

package/apps/control-plane/test/dashboard-api.integration.spec.ts

@@ -11,12 +11,33 @@ const readDashboardStatusMock = vi.hoisted(() =>
   })),
 );
 const readFeatureStateMock = vi.hoisted(() => vi.fn(async () => null));
+const readFeatureDiffMock = vi.hoisted(() => vi.fn(async () => ''));
+const readFeatureCheckpointsMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    execution_mode: 'interactive',
+    checkpoints: [],
+  })),
+);
+const readFeatureCheckpointDiffMock = vi.hoisted(() => vi.fn(async () => null));
+const compareFeatureCheckpointsMock = vi.hoisted(() => vi.fn(async () => null));
 const readFeatureLogMock = vi.hoisted(() =>
   vi.fn(async () => ({
     entries: [{ timestamp: '2026-03-05T00:00:00Z', message: 'log message', type: 'log' }],
     total: 1,
   })),
 );
+const readFeaturesIndexMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    active: ['feature_checkout'],
+    blocked: [],
+    merged: [],
+    blocked_queue: [],
+    runtime_sessions: { run_id: 'run:1' },
+  })),
+);
+const listRawLogFilesMock = vi.hoisted(() => vi.fn(async () => []));
+const readRawLogFileMock = vi.hoisted(() => vi.fn(async () => null));
+const readWorkerTimelineEntriesMock = vi.hoisted(() => vi.fn(async () => []));
 const readFeatureCostMock = vi.hoisted(() =>
   vi.fn(async () => ({
     feature_id: 'feature_checkout',
@@ -49,6 +70,31 @@ const readFeatureReviewBriefMock = vi.hoisted(() =>
     generated_at: '2026-03-05T00:00:00Z',
   })),
 );
+const readInteractivePerformanceMetricsMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    updated_at: '2026-03-06T00:00:00.000Z',
+    checkpoint_count: 0,
+    valid_count: 0,
+    invalid_count: 0,
+    skipped_count: 0,
+    avg_files_changed: null,
+    avg_checkpoint_latency_ms: null,
+    p95_checkpoint_latency_ms: null,
+    avg_validation_latency_ms: null,
+    p95_validation_latency_ms: null,
+    avg_diff_capture_latency_ms: null,
+    latest: null,
+    execution_modes: {
+      interactive_iterations: 0,
+      deterministic_iterations: 0,
+      interactive_avg_elapsed_ms: null,
+      deterministic_avg_elapsed_ms: null,
+      interactive_avg_request_count: null,
+      deterministic_avg_request_count: null,
+      context_request_reduction_ratio: null,
+    },
+  })),
+);
 const getAopRootMock = vi.hoisted(() => vi.fn(() => process.cwd()));
 const approveFeatureReviewMock = vi.hoisted(() =>
   vi.fn(async () => ({ ok: true, data: { merged: true } })),
@@ -74,10 +120,19 @@ vi.mock('../../../packages/web-dashboard/src/lib/aop-client.js', () => ({
   resolveProjectRoot: resolveProjectRootMock,
   readDashboardStatus: readDashboardStatusMock,
   readFeatureState: readFeatureStateMock,
+  readFeatureDiff: readFeatureDiffMock,
+  readFeatureCheckpoints: readFeatureCheckpointsMock,
+  readFeatureCheckpointDiff: readFeatureCheckpointDiffMock,
+  compareFeatureCheckpoints: compareFeatureCheckpointsMock,
   readFeatureLog: readFeatureLogMock,
+  readFeaturesIndex: readFeaturesIndexMock,
   readFeatureCost: readFeatureCostMock,
   readFeatureQaTestIndex: readFeatureQaTestIndexMock,
   readFeatureReviewBrief: readFeatureReviewBriefMock,
+  readInteractivePerformanceMetrics: readInteractivePerformanceMetricsMock,
+  listRawLogFiles: listRawLogFilesMock,
+  readRawLogFile: readRawLogFileMock,
+  readWorkerTimelineEntries: readWorkerTimelineEntriesMock,
   getAopRoot: getAopRootMock,
 }));
 
@@ -109,9 +164,16 @@ import { POST as checkoutPost } from '../../../packages/web-dashboard/src/app/ap
 import { GET as collisionsGet } from '../../../packages/web-dashboard/src/app/api/collisions/route.js';
 import { GET as costGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/cost/route.js';
 import { GET as logGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/log/route.js';
+import { GET as fileDiffGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/file-diff/route.js';
+import { GET as checkpointDiffGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkpoints/[checkpointId]/diff/route.js';
+import { GET as checkpointCompareGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkpoints/compare/route.js';
+import { GET as checkpointStreamGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkpoints/stream/route.js';
+import { GET as rawLogsGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/raw-logs/route.js';
+import { GET as rawLogFileGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/raw-logs/[filename]/route.js';
 import { GET as reviewBriefGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/review-brief/route.js';
 import { GET as statusGet } from '../../../packages/web-dashboard/src/app/api/status/route.js';
 import { GET as testIndexGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/test-index/route.js';
+import { GET as timelineGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/timeline/route.js';
 import { GET as projectsGet } from '../../../packages/web-dashboard/src/app/api/projects/route.js';
 import {
   GET as runGet,
@@ -130,10 +192,19 @@ describe('dashboard api integration', () => {
     resolveProjectRootMock.mockReset();
     readDashboardStatusMock.mockReset();
     readFeatureStateMock.mockReset();
+    readFeatureDiffMock.mockReset();
+    readFeatureCheckpointsMock.mockReset();
+    readFeatureCheckpointDiffMock.mockReset();
+    compareFeatureCheckpointsMock.mockReset();
     readFeatureLogMock.mockReset();
+    readFeaturesIndexMock.mockReset();
     readFeatureCostMock.mockReset();
     readFeatureQaTestIndexMock.mockReset();
     readFeatureReviewBriefMock.mockReset();
+    readInteractivePerformanceMetricsMock.mockReset();
+    listRawLogFilesMock.mockReset();
+    readRawLogFileMock.mockReset();
+    readWorkerTimelineEntriesMock.mockReset();
     getAopRootMock.mockReset();
     approveFeatureReviewMock.mockReset();
     denyFeatureReviewMock.mockReset();
@@ -145,6 +216,21 @@ describe('dashboard api integration', () => {
 
     resolveProjectRootMock.mockResolvedValue(repoRoot);
     getAopRootMock.mockReturnValue(repoRoot);
+    readFeatureStateMock.mockResolvedValue({
+      id: 'feature_checkout',
+      feature_id: 'feature_checkout',
+      status: 'ready_to_merge',
+      phase: 'ready_to_merge',
+      branch: 'feature/feature_checkout',
+      worktree_path: path.join(repoRoot, '.worktrees', 'feature_checkout'),
+      cluster: {
+        orchestrator_session_id: 'orch-session',
+        planner_session_id: 'planner-session',
+        builder_session_id: 'builder-session',
+        qa_session_id: 'qa-session',
+      },
+      pr: null,
+    });
     readDashboardStatusMock.mockResolvedValue({
       index: { active: ['feature_checkout'], blocked: [], merged: [], blocked_queue: [] },
       features: [
@@ -163,6 +249,24 @@ describe('dashboard api integration', () => {
       entries: [{ timestamp: '2026-03-05T00:00:00Z', message: 'log message', type: 'log' }],
       total: 1,
     });
+    readFeatureDiffMock.mockResolvedValue(
+      [
+        'diff --git a/src/a.ts b/src/a.ts',
+        'index 111..222 100644',
+        '--- a/src/a.ts',
+        '+++ b/src/a.ts',
+        '@@ -1 +1 @@',
+        '-const oldValue = 1;',
+        '+const newValue = 2;',
+      ].join('\n'),
+    );
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_checkout'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: { run_id: 'run:1' },
+    });
     readFeatureCostMock.mockResolvedValue({
       feature_id: 'feature_checkout',
       tokens_used: 120,
@@ -183,6 +287,38 @@ describe('dashboard api integration', () => {
       evidence_refs: [],
       generated_at: '2026-03-05T00:00:00Z',
     });
+    listRawLogFilesMock.mockResolvedValue([]);
+    readRawLogFileMock.mockResolvedValue(null);
+    readWorkerTimelineEntriesMock.mockResolvedValue([]);
+    readFeatureCheckpointsMock.mockResolvedValue({
+      execution_mode: 'interactive',
+      checkpoints: [],
+    });
+    readFeatureCheckpointDiffMock.mockResolvedValue(null);
+    compareFeatureCheckpointsMock.mockResolvedValue(null);
+    readInteractivePerformanceMetricsMock.mockResolvedValue({
+      updated_at: '2026-03-06T00:00:00.000Z',
+      checkpoint_count: 0,
+      valid_count: 0,
+      invalid_count: 0,
+      skipped_count: 0,
+      avg_files_changed: null,
+      avg_checkpoint_latency_ms: null,
+      p95_checkpoint_latency_ms: null,
+      avg_validation_latency_ms: null,
+      p95_validation_latency_ms: null,
+      avg_diff_capture_latency_ms: null,
+      latest: null,
+      execution_modes: {
+        interactive_iterations: 0,
+        deterministic_iterations: 0,
+        interactive_avg_elapsed_ms: null,
+        deterministic_avg_elapsed_ms: null,
+        interactive_avg_request_count: null,
+        deterministic_avg_request_count: null,
+        context_request_reduction_ratio: null,
+      },
+    });
     callOrchestratorToolMock.mockResolvedValue({
       ok: true,
       data: { feature_id: 'feature_checkout' } as Record<string, unknown>,
@@ -290,6 +426,118 @@ describe('dashboard api integration', () => {
     );
   });
 
+  it('GIVEN_feature_send_message_for_terminal_feature_WHEN_posted_THEN_returns_session_inactive', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      id: 'feature_checkout',
+      feature_id: 'feature_checkout',
+      status: 'merged',
+      phase: 'merged',
+      cluster: {
+        orchestrator_session_id: 'orch-session',
+        planner_session_id: 'planner-session',
+        builder_session_id: 'builder-session',
+        qa_session_id: 'qa-session',
+      },
+    });
+
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_checkout',
+          message: 'Need clarification',
+        }),
+      }),
+    );
+    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('session_inactive');
+    expect(sendFeatureMessageMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_feature_send_message_without_active_runtime_WHEN_posted_THEN_returns_session_inactive', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      id: 'feature_checkout',
+      feature_id: 'feature_checkout',
+      status: 'qa',
+      phase: 'qa',
+      cluster: {
+        orchestrator_session_id: 'orch-session',
+        planner_session_id: 'planner-session',
+        builder_session_id: 'builder-session',
+        qa_session_id: 'qa-session',
+      },
+    });
+    readFeaturesIndexMock.mockResolvedValue({
+      active: ['feature_checkout'],
+      blocked: [],
+      merged: [],
+      blocked_queue: [],
+      runtime_sessions: { run_id: 'unknown' },
+    });
+
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_checkout',
+          message: 'Need clarification',
+        }),
+      }),
+    );
+    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('session_inactive');
+    expect(sendFeatureMessageMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_feature_send_message_called_twice_quickly_WHEN_posted_THEN_second_call_is_rate_limited', async () => {
+    readFeatureStateMock.mockResolvedValue({
+      id: 'feature_rate',
+      feature_id: 'feature_rate',
+      status: 'qa',
+      phase: 'qa',
+      cluster: {
+        orchestrator_session_id: 'orch-session',
+        planner_session_id: 'planner-session',
+        builder_session_id: 'builder-session',
+        qa_session_id: 'qa-session',
+      },
+    });
+    const first = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_rate',
+          message: 'Need clarification',
+        }),
+      }),
+    );
+    const second = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'feature.send_message',
+          feature_id: 'feature_rate',
+          message: 'Second message',
+        }),
+      }),
+    );
+    const body = (await second.json()) as { ok: boolean; error: { code: string } };
+
+    expect(first.status).toBe(200);
+    expect(second.status).toBe(429);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('invalid_input');
+  });
+
   it('GIVEN_feature_retry_WHEN_posted_THEN_routes_to_retry_tool', async () => {
     const response = await actionsPost(
       new Request('http://localhost/api/actions', {
@@ -482,6 +730,295 @@ describe('dashboard api integration', () => {
     expect(body.meta?.source).toBe('artifact');
   });
 
+  it('GIVEN_file_diff_route_WHEN_path_is_in_scope_THEN_returns_monaco_payload_envelope', async () => {
+    execFileMock.mockResolvedValue({
+      stdout: 'const value = 1;\n',
+      stderr: '',
+    });
+
+    const response = await fileDiffGet(
+      new Request('http://localhost/api/features/feature_checkout/file-diff?path=src%2Fa.ts'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { path: string; language: string; change_type: string };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data).toMatchObject({
+      path: 'src/a.ts',
+      language: 'typescript',
+      change_type: 'modified',
+    });
+  });
+
+  it('GIVEN_raw_logs_route_with_policy_disabled_WHEN_requested_THEN_returns_disabled_state', async () => {
+    const response = await rawLogsGet(
+      new Request('http://localhost/api/features/feature_checkout/raw-logs'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { enabled: boolean; files: unknown[] };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data).toEqual({ enabled: false, files: [] });
+  });
+
+  it('GIVEN_raw_logs_route_with_policy_enabled_WHEN_requested_THEN_returns_filtered_files', async () => {
+    const policyPath = path.join(repoRoot, 'config', 'agentic', 'orchestrator');
+    await fs.mkdir(policyPath, { recursive: true });
+    await fs.writeFile(
+      path.join(policyPath, 'policy.yaml'),
+      [
+        'observability:',
+        '  raw_agent_logs_enabled: true',
+        '  raw_agent_logs_retention_days: 60',
+      ].join('\n'),
+      'utf8',
+    );
+    listRawLogFilesMock.mockResolvedValue([
+      {
+        filename: 'builder-1760000000000.txt',
+        role: 'builder',
+        timestamp: '2026-03-05T00:00:00.000Z',
+        size_bytes: 128,
+      },
+    ]);
+    readRawLogFileMock.mockResolvedValue('raw output');
+
+    const listResponse = await rawLogsGet(
+      new Request('http://localhost/api/features/feature_checkout/raw-logs?role=builder'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const listBody = (await listResponse.json()) as {
+      ok: boolean;
+      data?: { enabled: boolean; files: Array<{ filename: string }> };
+    };
+
+    const fileResponse = await rawLogFileGet(
+      new Request(
+        'http://localhost/api/features/feature_checkout/raw-logs/builder-1760000000000.txt',
+      ),
+      {
+        params: Promise.resolve({ id: 'feature_checkout', filename: 'builder-1760000000000.txt' }),
+      },
+    );
+    const fileBody = (await fileResponse.json()) as {
+      ok: boolean;
+      data?: { filename: string; content: string };
+    };
+
+    expect(listResponse.status).toBe(200);
+    expect(listBody.ok).toBe(true);
+    expect(listBody.data?.enabled).toBe(true);
+    expect(listBody.data?.files[0].filename).toBe('builder-1760000000000.txt');
+
+    expect(fileResponse.status).toBe(200);
+    expect(fileBody.ok).toBe(true);
+    expect(fileBody.data?.content).toBe('raw output');
+  });
+
+  it('GIVEN_raw_log_filename_with_traversal_WHEN_requested_THEN_returns_invalid_input', async () => {
+    const policyPath = path.join(repoRoot, 'config', 'agentic', 'orchestrator');
+    await fs.mkdir(policyPath, { recursive: true });
+    await fs.writeFile(
+      path.join(policyPath, 'policy.yaml'),
+      ['observability:', '  raw_agent_logs_enabled: true'].join('\n'),
+      'utf8',
+    );
+
+    const response = await rawLogFileGet(
+      new Request('http://localhost/api/features/feature_checkout/raw-logs/..%2Fsecrets.txt'),
+      { params: Promise.resolve({ id: 'feature_checkout', filename: '../secrets.txt' }) },
+    );
+    const body = (await response.json()) as { ok: boolean; error: { code: string } };
+
+    expect(response.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('invalid_input');
+    expect(readRawLogFileMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_raw_log_panel_failure_WHEN_timeline_requested_THEN_other_review_panels_remain_available', async () => {
+    const policyPath = path.join(repoRoot, 'config', 'agentic', 'orchestrator');
+    await fs.mkdir(policyPath, { recursive: true });
+    await fs.writeFile(
+      path.join(policyPath, 'policy.yaml'),
+      ['observability:', '  raw_agent_logs_enabled: true'].join('\n'),
+      'utf8',
+    );
+    readRawLogFileMock.mockResolvedValue(null);
+    readWorkerTimelineEntriesMock.mockResolvedValue([
+      {
+        ts: '2026-03-05T00:00:00.000Z',
+        role: 'builder',
+        output_types: ['PATCH'],
+        patch_count: 1,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 1,
+        valid: true,
+        error_code: null,
+        provider: 'codex',
+        model: 'gpt-5',
+      },
+    ]);
+
+    const rawLogResponse = await rawLogFileGet(
+      new Request(
+        'http://localhost/api/features/feature_checkout/raw-logs/builder-1760000000000.txt',
+      ),
+      {
+        params: Promise.resolve({ id: 'feature_checkout', filename: 'builder-1760000000000.txt' }),
+      },
+    );
+    const rawLogBody = (await rawLogResponse.json()) as { ok: boolean; error: { code: string } };
+
+    const timelineResponse = await timelineGet(
+      new Request('http://localhost/api/features/feature_checkout/timeline?role=builder'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const timelineBody = (await timelineResponse.json()) as {
+      ok: boolean;
+      data?: { entries: unknown[] };
+    };
+
+    expect(rawLogResponse.status).toBe(404);
+    expect(rawLogBody.ok).toBe(false);
+    expect(rawLogBody.error.code).toBe('artifact_missing');
+
+    expect(timelineResponse.status).toBe(200);
+    expect(timelineBody.ok).toBe(true);
+    expect(timelineBody.data?.entries).toHaveLength(1);
+  });
+
+  it('GIVEN_timeline_route_WHEN_requested_with_filters_THEN_returns_entries_and_summary', async () => {
+    readWorkerTimelineEntriesMock.mockResolvedValue([
+      {
+        ts: '2026-03-05T00:00:00.000Z',
+        role: 'builder',
+        output_types: ['PATCH'],
+        patch_count: 1,
+        plan_submission_count: 0,
+        request_count: 0,
+        note_count: 1,
+        valid: true,
+        error_code: null,
+        provider: 'codex',
+        model: 'gpt-5',
+      },
+    ]);
+
+    const response = await timelineGet(
+      new Request(
+        'http://localhost/api/features/feature_checkout/timeline?role=builder&valid=valid',
+      ),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { entries: unknown[]; summary: { total: number; valid: number } };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.entries).toHaveLength(1);
+    expect(body.data?.summary.total).toBe(1);
+    expect(body.data?.summary.valid).toBe(1);
+  });
+
+  it('GIVEN_checkpoint_diff_route_WHEN_checkpoint_exists_THEN_returns_snapshot_diff_payload', async () => {
+    readFeatureCheckpointDiffMock.mockResolvedValue({
+      checkpoint: {
+        checkpoint_id: 'checkpoint-001',
+        timestamp: '2026-03-06T00:00:00.000Z',
+        files_changed: ['src/a.ts'],
+        validation_status: 'valid',
+        violations: [],
+        diff_snapshot: '.aop/features/feature_checkout/checkpoints/checkpoint-001.diff',
+      },
+      diff: 'diff --git a/src/a.ts b/src/a.ts\\n',
+    });
+
+    const response = await checkpointDiffGet(
+      new Request('http://localhost/api/features/feature_checkout/checkpoints/checkpoint-001/diff'),
+      { params: Promise.resolve({ id: 'feature_checkout', checkpointId: 'checkpoint-001' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { checkpoint: { checkpoint_id: string }; diff: string };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.checkpoint.checkpoint_id).toBe('checkpoint-001');
+    expect(body.data?.diff).toContain('diff --git');
+  });
+
+  it('GIVEN_checkpoint_compare_route_without_required_params_WHEN_called_THEN_returns_invalid_input', async () => {
+    const response = await checkpointCompareGet(
+      new Request('http://localhost/api/features/feature_checkout/checkpoints/compare'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as { ok: boolean; error: { code: string } };
+
+    expect(response.status).toBe(400);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('invalid_input');
+  });
+
+  it('GIVEN_checkpoint_compare_route_WHEN_checkpoints_exist_THEN_returns_comparison_payload', async () => {
+    compareFeatureCheckpointsMock.mockResolvedValue({
+      from_checkpoint_id: 'checkpoint-001',
+      to_checkpoint_id: 'checkpoint-002',
+      from_timestamp: '2026-03-06T00:00:00.000Z',
+      to_timestamp: '2026-03-06T00:01:00.000Z',
+      summary: { added: 1, removed: 0, changed: 1, unchanged: 0 },
+      files: [
+        { path: 'src/a.ts', status: 'changed' },
+        { path: 'src/b.ts', status: 'added' },
+      ],
+      from_diff: 'diff --git a/src/a.ts b/src/a.ts\\n',
+      to_diff: 'diff --git a/src/a.ts b/src/a.ts\\n',
+    });
+
+    const response = await checkpointCompareGet(
+      new Request(
+        'http://localhost/api/features/feature_checkout/checkpoints/compare?from=checkpoint-001&to=checkpoint-002',
+      ),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: { summary: { changed: number; added: number }; files: Array<{ path: string }> };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.summary.changed).toBe(1);
+    expect(body.data?.summary.added).toBe(1);
+    expect(body.data?.files[0].path).toBe('src/a.ts');
+  });
+
+  it('GIVEN_checkpoint_stream_route_WHEN_feature_missing_THEN_returns_feature_not_found', async () => {
+    readFeatureStateMock.mockResolvedValueOnce(null);
+
+    const response = await checkpointStreamGet(
+      new Request('http://localhost/api/features/feature_checkout/checkpoints/stream'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    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('GIVEN_multi_project_config_WHEN_projects_endpoint_called_THEN_returns_switchable_projects', async () => {
     const projectAlpha = path.join(repoRoot, 'project-alpha');
     const projectBeta = path.join(repoRoot, 'project-beta');