agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/core-utils.spec.ts

@@ -27,6 +27,13 @@ describe('core utility branches', () => {
     const serialized = buildFrontMatter({ feature_id: 'abc', version: 2 }, '\nBody');
     expect(serialized).toContain('feature_id: abc');
     expect(serialized).toContain('\n---\nBody');
+
+    expect(parseFrontMatter('---\n\n---\nBody')).toEqual({
+      frontMatter: {},
+      body: 'Body',
+    });
+    expect(buildFrontMatter({ feature_id: 'xyz' })).toBe('---\nfeature_id: xyz\n---\n');
+    expect(buildFrontMatter({ feature_id: 'xyz' }, 'Body')).toBe('---\nfeature_id: xyz\n---\nBody');
   });
 
   it('covers path normalization and matching modes', async () => {
@@ -43,6 +50,12 @@ describe('core utility branches', () => {
 
     expect(areaMatches('src/a.ts', 'src')).toBe(true);
     expect(areaMatches('src/a.ts', 'src/*.ts', 'glob')).toBe(true);
+    expect(
+      areaMatches(
+        'packages/web-dashboard/src/lib/launch-contracts.ts',
+        'packages/web-dashboard/src/lib/launch-*.ts',
+      ),
+    ).toBe(true);
     expect(anyAreaMatch('src/a.ts', ['docs', 'src'])).toBe(true);
     expect(anyAreaMatch('src/a.ts', ['docs', 'tests'])).toBe(false);
 
@@ -295,4 +308,52 @@ describe('core-utils additional branch coverage', () => {
     expect(result.valid).toBe(true);
     await fs.rm(repoRoot, { recursive: true, force: true });
   });
+
+  it('GIVEN_schema_with_local_refs_WHEN_validating_THEN_resolves_bootstrap_manifest_defs', async () => {
+    const { SchemaRegistry } = await import('../src/core/schemas.js');
+    const registry = new SchemaRegistry(process.cwd());
+
+    const obligation = {
+      obligation_id: 'OBL-001',
+      kind: 'behavior',
+      name: 'Token telemetry',
+      description: 'Track token usage across roles.',
+      source_refs: [{ line_start: 1, line_end: 2, heading: 'Telemetry' }],
+      verification_hint: 'required',
+      confidence: 'high',
+    };
+
+    const verifiedManifest = await registry.validate('spec.manifest.verified.schema.json' as any, {
+      feature_id: 'feature_schema_ref',
+      manifest_version: 1,
+      artifact_type: 'verified',
+      verification_basis: 'questions_resolved',
+      verified_at: '2026-03-17T12:00:00.000Z',
+      source_bootstrap_version: 1,
+      obligations: [obligation],
+    });
+    const intakeReview = await registry.validate('intake.review.schema.json' as any, {
+      feature_id: 'feature_schema_ref',
+      version: 1,
+      status: 'verified',
+      questions_open: 0,
+      questions_resolved: 1,
+      clarification_answers: [],
+      ambiguities: [
+        {
+          id: 'AMB-001',
+          summary: 'Clarify token units',
+          status: 'resolved',
+          obligation_ids: ['OBL-001'],
+        },
+      ],
+      bootstrap_manifest_version: 1,
+      verified_manifest_version: 1,
+      promotion_basis: 'questions_resolved',
+      last_updated_at: '2026-03-17T12:00:00.000Z',
+    });
+
+    expect(verifiedManifest).toMatchObject({ valid: true, errors: [] });
+    expect(intakeReview).toMatchObject({ valid: true, errors: [] });
+  });
 });

package/apps/control-plane/test/cost-tracking.spec.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 import { AopKernel } from '../src/index.js';
 import { CostTrackingService } from '../src/application/services/cost-tracking-service.js';
+import { reportedUsage, unavailableUsage, estimatedUsage } from '../src/application/usage-types.js';
 import { makeTempRepo, writeFeatureSpec } from './helpers.js';
 
 let repoRoot: string;
@@ -156,4 +157,227 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
       });
     });
   });
+
+  describe('recordRoleUsage', () => {
+    it('GIVEN_reported_usage_WHEN_recordRoleUsage_THEN_stores_by_role_breakdown', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-1');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-1' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      const usage = reportedUsage('claude', 'claude-3', 'planner', 1000, 500, 0.03);
+      const result = await service.recordRoleUsage('feat-role-1', usage);
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].role).toBe('planner');
+      expect(result.by_role[0].provider).toBe('claude');
+      expect(result.by_role[0].status).toBe('reported');
+      expect(result.by_role[0].total_tokens).toBe(1500);
+      expect(result.by_role[0].invocation_count).toBe(1);
+      expect(result.tokens_used).toBe(1500);
+      expect(result.aggregate_status).toBe('reported');
+    });
+
+    it('GIVEN_unavailable_usage_WHEN_recordRoleUsage_THEN_never_records_as_zero', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-2');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-2' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      const usage = unavailableUsage('codex', 'codex-default', 'builder');
+      const result = await service.recordRoleUsage('feat-role-2', usage);
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].status).toBe('unavailable');
+      expect(result.by_role[0].total_tokens).toBeNull();
+      expect(result.tokens_used).toBe(0);
+      expect(result.aggregate_status).toBe('unavailable');
+    });
+
+    it('GIVEN_multiple_roles_WHEN_recordRoleUsage_THEN_accumulates_per_role', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-3');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-3' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-3',
+        reportedUsage('claude', 'claude-3', 'planner', 1000, 500, 0.03),
+      );
+      await service.recordRoleUsage(
+        'feat-role-3',
+        reportedUsage('codex', 'codex-large', 'builder', 2000, 1000, 0.05),
+      );
+      const result = await service.recordRoleUsage(
+        'feat-role-3',
+        reportedUsage('claude', 'claude-3', 'qa', 500, 200, 0.01),
+      );
+
+      expect(result.by_role).toHaveLength(3);
+      expect(result.tokens_used).toBe(1500 + 3000 + 700);
+      expect(result.aggregate_status).toBe('reported');
+    });
+
+    it('GIVEN_existing_recordCost_WHEN_recordRoleUsage_added_THEN_recordCost_still_works', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-4');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-4' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      const costResult = await service.recordCost('feat-role-4', 1000, 0.02);
+      expect(costResult.tokens_used).toBe(1000);
+      expect(costResult.estimated_cost_usd).toBeCloseTo(0.02);
+    });
+
+    it('GIVEN_same_role_invoked_twice_WHEN_recordRoleUsage_THEN_accumulates_tokens', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-5');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-5' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-5',
+        reportedUsage('claude', 'claude-3', 'builder', 1000, 500, 0.03),
+      );
+      const result = await service.recordRoleUsage(
+        'feat-role-5',
+        reportedUsage('claude', 'claude-3', 'builder', 800, 400, 0.02),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].invocation_count).toBe(2);
+      expect(result.by_role[0].total_tokens).toBe(2700);
+    });
+
+    it('GIVEN_existing_reported_role_WHEN_unavailable_update_THEN_skips_token_accumulation_and_degrades_status', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-6');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-6' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-6',
+        reportedUsage('claude', 'claude-3', 'builder', 1000, 500, 0.03),
+      );
+      const result = await service.recordRoleUsage(
+        'feat-role-6',
+        unavailableUsage('claude', 'claude-3', 'builder'),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      // Invocation count still incremented
+      expect(result.by_role[0].invocation_count).toBe(2);
+      // Tokens NOT accumulated (unavailable skips accumulation)
+      expect(result.by_role[0].total_tokens).toBe(1500);
+      expect(result.by_role[0].input_tokens).toBe(1000);
+      expect(result.by_role[0].output_tokens).toBe(500);
+      // Status degraded from reported to unavailable
+      expect(result.by_role[0].status).toBe('unavailable');
+    });
+
+    it('GIVEN_existing_estimated_role_WHEN_unavailable_update_THEN_status_not_degraded', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-7');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-7' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-7',
+        estimatedUsage('codex', 'codex-default', 'qa', 200, 100, 0.01),
+      );
+      const result = await service.recordRoleUsage(
+        'feat-role-7',
+        unavailableUsage('codex', 'codex-default', 'qa'),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].invocation_count).toBe(2);
+      // Status NOT degraded: only reported→unavailable triggers degradation
+      expect(result.by_role[0].status).toBe('estimated');
+      // Tokens unchanged
+      expect(result.by_role[0].total_tokens).toBe(300);
+    });
+
+    it('GIVEN_existing_unavailable_role_WHEN_reported_update_THEN_null_defaults_to_zero_and_accumulates', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-null');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-null' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      // First invocation: unavailable → tokens are null in the stored entry
+      await service.recordRoleUsage(
+        'feat-role-null',
+        unavailableUsage('claude', 'claude-3', 'builder'),
+      );
+      // Second invocation: reported → accumulates with null existing fields hitting ?? 0 fallback
+      const result = await service.recordRoleUsage(
+        'feat-role-null',
+        reportedUsage('claude', 'claude-3', 'builder', 400, 200, 0.01),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].invocation_count).toBe(2);
+      // Null existing entry defaults to 0 via ?? 0, so result equals the reported record's values
+      expect(result.by_role[0].input_tokens).toBe(400);
+      expect(result.by_role[0].output_tokens).toBe(200);
+      expect(result.by_role[0].total_tokens).toBe(600);
+      expect(result.by_role[0].estimated_cost_usd).toBeCloseTo(0.01);
+    });
+
+    it('GIVEN_existing_reported_role_WHEN_reported_with_null_cost_THEN_cost_defaults_to_zero', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-null-cost');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-null-cost' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-null-cost',
+        reportedUsage('claude', 'claude-3', 'qa', 100, 50),
+      );
+      // Second invocation: reported usage without cost (null estimated_cost_usd via omitted param)
+      const result = await service.recordRoleUsage(
+        'feat-role-null-cost',
+        reportedUsage('claude', 'claude-3', 'qa', 200, 100),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].input_tokens).toBe(300);
+      expect(result.by_role[0].output_tokens).toBe(150);
+      expect(result.by_role[0].total_tokens).toBe(450);
+      // Both calls had null cost → 0 + 0 = 0
+      expect(result.by_role[0].estimated_cost_usd).toBe(0);
+    });
+
+    it('GIVEN_existing_role_with_non_null_tokens_WHEN_reported_update_THEN_accumulates_correctly', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-role-8');
+      await kernel.invoke('feature.init', { feature_id: 'feat-role-8' }, ORCH_CTX);
+
+      const service = new CostTrackingService(kernel);
+      await service.recordRoleUsage(
+        'feat-role-8',
+        reportedUsage('claude', 'claude-3', 'planner', 500, 250, 0.01),
+      );
+      const result = await service.recordRoleUsage(
+        'feat-role-8',
+        reportedUsage('claude', 'claude-3', 'planner', 300, 150, 0.005),
+      );
+
+      expect(result.by_role).toHaveLength(1);
+      expect(result.by_role[0].input_tokens).toBe(800);
+      expect(result.by_role[0].output_tokens).toBe(400);
+      expect(result.by_role[0].total_tokens).toBe(1200);
+      expect(result.by_role[0].estimated_cost_usd).toBeCloseTo(0.015);
+    });
+  });
 });

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

@@ -11,6 +11,7 @@ const readDashboardStatusMock = vi.hoisted(() =>
   })),
 );
 const readFeatureStateMock = vi.hoisted(() => vi.fn(async () => null));
+const readFeatureTriageMock = vi.hoisted(() => vi.fn(async () => null));
 const readFeatureDiffMock = vi.hoisted(() => vi.fn(async () => ''));
 const readFeatureCheckpointsMock = vi.hoisted(() =>
   vi.fn(async () => ({
@@ -120,6 +121,7 @@ vi.mock('../../../packages/web-dashboard/src/lib/aop-client.js', () => ({
   resolveProjectRoot: resolveProjectRootMock,
   readDashboardStatus: readDashboardStatusMock,
   readFeatureState: readFeatureStateMock,
+  readFeatureTriage: readFeatureTriageMock,
   readFeatureDiff: readFeatureDiffMock,
   readFeatureCheckpoints: readFeatureCheckpointsMock,
   readFeatureCheckpointDiff: readFeatureCheckpointDiffMock,
@@ -134,10 +136,18 @@ vi.mock('../../../packages/web-dashboard/src/lib/aop-client.js', () => ({
   readRawLogFile: readRawLogFileMock,
   readWorkerTimelineEntries: readWorkerTimelineEntriesMock,
   getAopRoot: getAopRootMock,
+  readOrganizerStatus: vi.fn(async () => ({
+    available: false,
+    generated_at: null,
+    ready_set: [],
+    deferred_set: [],
+    blocked_set: [],
+  })),
 }));
 
 vi.mock('../../../packages/web-dashboard/src/lib/orchestrator-tools.js', () => ({
   approveFeatureReview: approveFeatureReviewMock,
+  approveFeatureReviewAsync: approveFeatureReviewMock,
   denyFeatureReview: denyFeatureReviewMock,
   requestFeatureChanges: requestFeatureChangesMock,
   sendFeatureMessage: sendFeatureMessageMock,
@@ -160,6 +170,7 @@ vi.mock('node:child_process', () => ({
 }));
 
 import { POST as actionsPost } from '../../../packages/web-dashboard/src/app/api/actions/route.js';
+import { setDashboardAuthorizationAdapter } from '../../../packages/web-dashboard/src/lib/authz-adapter.js';
 import { POST as checkoutPost } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkout/route.js';
 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';
@@ -171,9 +182,11 @@ import { GET as checkpointStreamGet } from '../../../packages/web-dashboard/src/
 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 triageGet } from '../../../packages/web-dashboard/src/app/api/features/[id]/triage/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 budgetGet } from '../../../packages/web-dashboard/src/app/api/policy/budget/route.js';
 import { GET as projectsGet } from '../../../packages/web-dashboard/src/app/api/projects/route.js';
 import {
   GET as runGet,
@@ -192,6 +205,7 @@ describe('dashboard api integration', () => {
     resolveProjectRootMock.mockReset();
     readDashboardStatusMock.mockReset();
     readFeatureStateMock.mockReset();
+    readFeatureTriageMock.mockReset();
     readFeatureDiffMock.mockReset();
     readFeatureCheckpointsMock.mockReset();
     readFeatureCheckpointDiffMock.mockReset();
@@ -216,11 +230,15 @@ describe('dashboard api integration', () => {
 
     resolveProjectRootMock.mockResolvedValue(repoRoot);
     getAopRootMock.mockReturnValue(repoRoot);
+    setDashboardAuthorizationAdapter({
+      authorize: async () => ({ allowed: true }),
+    });
     readFeatureStateMock.mockResolvedValue({
       id: 'feature_checkout',
       feature_id: 'feature_checkout',
       status: 'ready_to_merge',
       phase: 'ready_to_merge',
+      gates: { merge: 'pass' },
       branch: 'feature/feature_checkout',
       worktree_path: path.join(repoRoot, '.worktrees', 'feature_checkout'),
       cluster: {
@@ -231,6 +249,28 @@ describe('dashboard api integration', () => {
       },
       pr: null,
     });
+    readFeatureTriageMock.mockResolvedValue({
+      feature: {
+        id: 'feature_checkout',
+        feature_id: 'feature_checkout',
+        status: 'ready_to_merge',
+        phase: 'ready_to_merge',
+        client_status_label: 'Ready',
+        attention_reasons: ['Ready'],
+      },
+      why_attention: ['Ready'],
+      blocker_summary: null,
+      dependency_summary: [],
+      review_snapshot: {
+        ci_status: 'success',
+        review_decision: 'approved',
+        merge_ready: true,
+      },
+      usage: {
+        tokens_used: 120,
+        budget_limit_tokens: 250000,
+      },
+    });
     readDashboardStatusMock.mockResolvedValue({
       index: { active: ['feature_checkout'], blocked: [], merged: [], blocked_queue: [] },
       features: [
@@ -239,6 +279,7 @@ describe('dashboard api integration', () => {
           feature_id: 'feature_checkout',
           status: 'ready_to_merge',
           phase: 'ready_to_merge',
+          gates: { merge: 'pass' },
           branch: 'feature/feature_checkout',
           worktree_path: path.join(repoRoot, '.worktrees', 'feature_checkout'),
           pr: null,
@@ -327,6 +368,9 @@ describe('dashboard api integration', () => {
   });
 
   afterEach(async () => {
+    setDashboardAuthorizationAdapter({
+      authorize: async () => ({ allowed: true }),
+    });
     await fs.rm(repoRoot, { recursive: true, force: true });
   });
 
@@ -342,7 +386,7 @@ describe('dashboard api integration', () => {
       }),
     );
 
-    expect(response.status).toBe(200);
+    expect(response.status).toBe(202);
     expect(approveFeatureReviewMock).toHaveBeenCalledWith(
       'feature_checkout',
       'approved',
@@ -352,6 +396,71 @@ describe('dashboard api integration', () => {
     );
   });
 
+  it('GIVEN_unauthorized_review_action_WHEN_posted_THEN_blocks_server_side', async () => {
+    setDashboardAuthorizationAdapter({
+      authorize: async () => ({ allowed: false, message: 'forbidden by policy' }),
+    });
+
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.approve',
+          feature_id: 'feature_checkout',
+          approval_token: 'approved',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string };
+      action_state: { enabled: boolean; authorized: boolean; reason: string };
+    };
+
+    expect(response.status).toBe(403);
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('unauthorized_action');
+    expect(body.action_state.authorized).toBe(false);
+    expect(approveFeatureReviewMock).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_review_approve_for_non_ready_feature_WHEN_posted_THEN_returns_disabled_state', 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',
+      },
+    });
+
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.approve',
+          feature_id: 'feature_checkout',
+          approval_token: 'approved',
+        }),
+      }),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      error: { code: string };
+      action_state: { enabled: boolean; authorized: boolean; reason: string };
+    };
+
+    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(approveFeatureReviewMock).not.toHaveBeenCalled();
+  });
+
   it('GIVEN_review_request_changes_WHEN_posted_THEN_routes_to_feature_send_message_flow', async () => {
     const response = await actionsPost(
       new Request('http://localhost/api/actions', {
@@ -1043,11 +1152,20 @@ describe('dashboard api integration', () => {
       path.join(repoRoot, 'config', 'agentic', 'orchestrator', 'multi-project.yaml'),
       [
         'version: "1.0"',
+        'defaults:',
+        '  default_project: beta',
         'projects:',
         `  - name: alpha`,
+        `    label: Alpha Client`,
+        `    environment: staging`,
         `    path: ${projectAlpha}`,
         `  - name: beta`,
+        `    pinned: true`,
+        `    owner: Platform`,
         `    path: ${projectBeta}`,
+        `  - name: hidden`,
+        `    hidden: true`,
+        `    path: ${path.join(repoRoot, 'hidden')}`,
       ].join('\n'),
       'utf8',
     );
@@ -1055,13 +1173,18 @@ describe('dashboard api integration', () => {
     const response = await projectsGet();
     const body = (await response.json()) as {
       ok: boolean;
-      data: { projects: Array<{ name: string; path: string }> };
+      data: {
+        defaults: { default_project: string };
+        projects: Array<{ name: string; label?: string | null; owner?: string | null }>;
+      };
     };
 
     expect(response.status).toBe(200);
     expect(body.ok).toBe(true);
-    expect(body.data.projects.map((project) => project.name)).toEqual(['alpha', 'beta']);
-    expect(body.data.projects.map((project) => project.path)).toEqual([projectAlpha, projectBeta]);
+    expect(body.data.defaults.default_project).toBe('beta');
+    expect(body.data.projects.map((project) => project.name)).toEqual(['beta', 'alpha']);
+    expect(body.data.projects[0].owner).toBe('Platform');
+    expect(body.data.projects[1].label).toBe('Alpha Client');
   });
 
   it('GIVEN_quick_launch_disabled_policy_WHEN_run_get_called_THEN_returns_unavailable_state', async () => {
@@ -1081,15 +1204,72 @@ describe('dashboard api integration', () => {
 
     expect(response.status).toBe(200);
     expect(body.ok).toBe(true);
-    expect(body.data).toEqual({
+    expect(body.data).toMatchObject({
       available: false,
       enabled: false,
       authorized: false,
       reason:
         'Quick launch is disabled by policy. Enable dashboard.quick_launch or AOP_DASHBOARD_QUICK_LAUNCH=true.',
+      action_state: {
+        enabled: false,
+        authorized: false,
+      },
     });
   });
 
+  it('GIVEN_token_budget_policy_WHEN_budget_route_called_THEN_returns_token_first_contract', async () => {
+    const policyPath = path.join(repoRoot, 'config', 'agentic', 'orchestrator');
+    await fs.mkdir(policyPath, { recursive: true });
+    await fs.writeFile(
+      path.join(policyPath, 'policy.yaml'),
+      [
+        'budget:',
+        '  per_feature_limit_tokens: 250000',
+        '  alert_threshold: 0.8',
+        '  token_cost_conversion:',
+        '    usd_per_1k_tokens: 0.35',
+      ].join('\n'),
+      'utf8',
+    );
+
+    const response = await budgetGet(
+      new Request('http://localhost/api/policy/budget?project=alpha'),
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        per_feature_limit_tokens: number;
+        token_cost_conversion: { usd_per_1k_tokens: number };
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.per_feature_limit_tokens).toBe(250000);
+    expect(body.data?.token_cost_conversion.usd_per_1k_tokens).toBe(0.35);
+  });
+
+  it('GIVEN_feature_triage_route_WHEN_requested_THEN_returns_lightweight_payload_with_action_states', async () => {
+    const response = await triageGet(
+      new Request('http://localhost/api/features/feature_checkout/triage?project=alpha'),
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
+    );
+    const body = (await response.json()) as {
+      ok: boolean;
+      data?: {
+        why_attention: string[];
+        usage: { budget_limit_tokens: number };
+        actions: { approve: { enabled: boolean; authorized: boolean } };
+      };
+    };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(body.data?.why_attention).toEqual(['Ready']);
+    expect(body.data?.usage.budget_limit_tokens).toBe(250000);
+    expect(body.data?.actions.approve).toMatchObject({ enabled: true, authorized: true });
+  });
+
   it('GIVEN_quick_launch_enabled_WHEN_run_post_called_THEN_calls_feature_init_tool', async () => {
     const policyPath = path.join(repoRoot, 'config', 'agentic', 'orchestrator');
     await fs.mkdir(policyPath, { recursive: true });