agentic-orchestrator 0.1.28 → 0.2.0

package/apps/control-plane/test/services.spec.ts

@@ -8,6 +8,7 @@ import { RunLeaseService } from '../src/application/services/run-lease-service.j
 import { stableHash } from '../src/core/fs.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { STATUS } from '../src/core/constants.js';
+import { createCollisionFingerprint } from '../src/core/collisions.js';
 import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
 
 type AnyRecord = Record<string, any>;
@@ -21,6 +22,7 @@ function makeRuntimeSessions(overrides: AnyRecord = {}): AnyRecord {
   return {
     run_id: 'none',
     orchestrator_session_id: 'unknown',
+    reconciler_session_id: 'unknown',
     provider: 'unknown',
     model: 'unknown',
     provider_config_ref_hash: stableHash('none'),
@@ -258,9 +260,19 @@ async function makeReportingHarness() {
         },
       },
     }),
+    executionRequestList: async () => ({
+      data: {
+        version: 1,
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        updated_at: new Date(0).toISOString(),
+        items: [],
+      },
+    }),
   });
 
   return {
+    tmpDir,
     service,
     plans,
     setIndex: (nextIndex: AnyRecord) => {
@@ -315,6 +327,7 @@ describe('RunLeaseService', () => {
       run_id: 'run:stale',
       owner_instance_id: 'owner:stale',
       orchestrator_session_id: 'orch:old',
+      reconciler_session_id: 'reconciler:old',
       feature_sessions: {
         feature_x: { planner_session_id: 'p', builder_session_id: 'b', qa_session_id: 'q' },
       },
@@ -351,11 +364,35 @@ describe('RunLeaseService', () => {
 
     expect(takeover.data.took_over_stale).toBe(true);
     expect(takeover.data.reused_existing_owner).toBe(false);
-    expect(takeover.data.runtime_sessions.orchestrator_session_id).toBe('unknown');
+    expect(takeover.data.runtime_sessions.orchestrator_session_id).toBe('orch:old');
+    expect(takeover.data.runtime_sessions.reconciler_session_id).toBe('reconciler:old');
     expect(takeover.data.runtime_sessions.feature_sessions).toEqual({});
     expect(takeover.data.runtime_sessions.provider_config_ref_hash).toBe(stableHash('none'));
   });
 
+  it('allows stale lease reuse for the same owner instance without explicit takeover', async () => {
+    const staleLease = makeRuntimeSessions({
+      run_id: 'run:stale',
+      owner_instance_id: 'owner:same',
+      lease_expires_at: new Date(Date.now() - 60_000).toISOString(),
+    });
+    const harness = makeRunLeaseHarness(makeIndex({ runtime_sessions: staleLease }));
+
+    const result = await harness.service.acquireRunLease({
+      run_id: 'run:new',
+      owner_instance_id: 'owner:same',
+      provider: 'provider',
+      model: 'model',
+      provider_config_ref_hash: '',
+      takeover_stale_run: false,
+    });
+
+    expect(result.data.took_over_stale).toBe(false);
+    expect(result.data.reused_existing_owner).toBe(false);
+    expect(result.data.runtime_sessions.run_id).toBe('run:new');
+    expect(result.data.runtime_sessions.owner_instance_id).toBe('owner:same');
+  });
+
   it('renews, updates, prunes, and releases when owner matches', async () => {
     const initial = makeRuntimeSessions({
       run_id: 'run:owner',
@@ -380,6 +417,12 @@ describe('RunLeaseService', () => {
       increment_epoch: true,
     });
 
+    await harness.service.updateReconcilerSession({
+      run_id: 'run:owner',
+      owner_instance_id: 'owner:owner',
+      reconciler_session_id: 'reconciler:new',
+    });
+
     await harness.service.updateFeatureSessionAssignment({
       run_id: 'run:owner',
       owner_instance_id: 'owner:owner',
@@ -398,7 +441,9 @@ describe('RunLeaseService', () => {
 
     const released = await harness.service.releaseRunLease('run:owner', 'owner:owner');
     expect(released.data.released).toBe(true);
-    expect(harness.getRunLease().run_id).toBe('none');
+    expect(harness.getRunLease().run_id).toBe('run:owner');
+    expect(harness.getRunLease().reconciler_session_id).toBe('reconciler:new');
+    expect(new Date(harness.getRunLease().lease_expires_at).getTime()).toBeLessThanOrEqual(1);
   });
 
   it('reuses existing owner metadata and rejects not-owned lease operations', async () => {
@@ -463,6 +508,16 @@ describe('RunLeaseService', () => {
     ).rejects.toMatchObject({
       normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } },
     });
+
+    await expect(
+      harness.service.updateReconcilerSession({
+        run_id: 'run:other',
+        owner_instance_id: 'owner:other',
+        reconciler_session_id: 'reconciler:other',
+      }),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } },
+    });
   });
 });
 
@@ -662,6 +717,38 @@ describe('ReportingService', () => {
         contracts: { openapi: 'none', events: 'none', db: 'none' },
       },
     );
+    harness.setIndex(
+      makeIndex({
+        active: ['feature_a'],
+        blocked: ['feature_b'],
+        merged: [],
+        locks: {
+          openapi: 'feature_lock',
+          db_migrations: null,
+        },
+        collision_overrides: [
+          {
+            override_id: 'colovr_1',
+            feature_ids: ['feature_a', 'feature_b'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'intentional overlap',
+            approved_collision_fingerprint: createCollisionFingerprint('feature_a', {
+              files: [{ with_feature_id: 'feature_b', paths: ['src/shared.ts'] }],
+              areas: [
+                { with_feature_id: 'feature_b', overlaps: [['libs/core', 'libs/core/module']] },
+              ],
+              contracts: [],
+            }),
+            approved_paths: ['src/shared.ts'],
+            approved_with_feature_ids: ['feature_b'],
+            status: 'active',
+            source_collision_id: 'colrec_1',
+          },
+        ],
+        collision_records: [],
+      }),
+    );
 
     await harness.ensureState('feature_a', {
       status: STATUS.BUILDING,
@@ -682,12 +769,14 @@ describe('ReportingService', () => {
     expect(collisions.data.collisions).toHaveLength(1);
     expect(collisions.data.collisions[0].feature_id).toBe('feature_a');
     expect(typeof collisions.data.collisions[0].fingerprint).toBe('string');
+    expect(collisions.data.collisions[0].approval_status).toBe('approved_active');
 
     const dashboard = await harness.service.reportDashboard();
     expect(dashboard.data.features.map((item: AnyRecord) => item.feature_id)).toEqual([
       'feature_a',
       'feature_lock',
     ]);
+    expect(dashboard.data.collision_summary.active_approved).toBe(1);
   });
 
   it('aggregates feature summary from state, diff bundle, and qa index', async () => {
@@ -712,6 +801,387 @@ describe('ReportingService', () => {
     expect(summary.data.touched_files).toEqual(['src/example.ts']);
     expect(summary.data.qa_summary.pending_required).toBe(0);
   });
+
+  it('GIVEN_cost_json_with_by_role_and_aggregate_status_WHEN_reportDashboard_THEN_includes_full_cost_data', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    const featureId = 'feature_cost_full';
+    await harness.ensureState(featureId, {
+      status: STATUS.QA,
+      gates: { full: 'pass' },
+      locks: { held: [] },
+    });
+    harness.setIndex(
+      makeIndex({
+        active: [featureId],
+        blocked: [],
+        merged: [],
+      }),
+    );
+    await fs.writeFile(
+      path.join(harness.tmpDir, featureId, 'cost.json'),
+      JSON.stringify({
+        estimated_cost_usd: 0.15,
+        tokens_used: 5000,
+        by_role: [
+          {
+            role: 'planner',
+            input_tokens: 1000,
+            output_tokens: 500,
+            total_tokens: 1500,
+            status: 'reported',
+          },
+        ],
+        aggregate_status: 'reported',
+      }),
+      'utf8',
+    );
+
+    const dashboard = await harness.service.reportDashboard();
+    const feature = dashboard.data.features.find((f: AnyRecord) => f.feature_id === featureId);
+    expect(feature.cost).toEqual({
+      estimated_cost_usd: 0.15,
+      tokens_used: 5000,
+      by_role: [
+        {
+          role: 'planner',
+          input_tokens: 1000,
+          output_tokens: 500,
+          total_tokens: 1500,
+          status: 'reported',
+        },
+      ],
+      aggregate_status: 'reported',
+    });
+  });
+
+  it('GIVEN_cost_json_without_by_role_or_aggregate_status_WHEN_reportDashboard_THEN_defaults_applied', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    const featureId = 'feature_cost_partial';
+    await harness.ensureState(featureId, {
+      status: STATUS.QA,
+      gates: { full: 'pass' },
+      locks: { held: [] },
+    });
+    harness.setIndex(
+      makeIndex({
+        active: [featureId],
+        blocked: [],
+        merged: [],
+      }),
+    );
+    await fs.writeFile(
+      path.join(harness.tmpDir, featureId, 'cost.json'),
+      JSON.stringify({
+        estimated_cost_usd: 0.05,
+        tokens_used: 2000,
+      }),
+      'utf8',
+    );
+
+    const dashboard = await harness.service.reportDashboard();
+    const feature = dashboard.data.features.find((f: AnyRecord) => f.feature_id === featureId);
+    expect(feature.cost).toEqual({
+      estimated_cost_usd: 0.05,
+      tokens_used: 2000,
+      by_role: [],
+      aggregate_status: null,
+    });
+  });
+
+  it('surfaces stale and revoked overrides plus branch fallback metadata on the dashboard', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    harness.plans.push(
+      {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        files: { create: [], modify: ['src/shared.ts'], delete: [] },
+        allowed_areas: ['src'],
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      },
+      {
+        feature_id: 'feature_b',
+        plan_version: 1,
+        files: { create: [], modify: ['src/shared.ts'], delete: [] },
+        allowed_areas: ['src'],
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      },
+    );
+    harness.setIndex(
+      makeIndex({
+        active: ['feature_a', 'feature_b'],
+        blocked: [],
+        merged: [],
+        locks: {
+          openapi: null,
+          db_migrations: null,
+        },
+        collision_overrides: [
+          {
+            override_id: 'colovr_active',
+            feature_ids: ['feature_a', 'feature_b'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'approved overlap',
+            approved_collision_fingerprint: createCollisionFingerprint('feature_a', {
+              files: [{ with_feature_id: 'feature_b', paths: ['src/shared.ts'] }],
+              areas: [],
+              contracts: [],
+            }),
+            approved_paths: ['src/shared.ts'],
+            approved_with_feature_ids: ['feature_b'],
+            status: 'applied',
+            applied_at: '2026-03-15T00:05:00.000Z',
+            source_collision_id: 'colrec_1',
+          },
+          {
+            override_id: 'colovr_stale',
+            feature_ids: ['feature_a', 'feature_c'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'stale overlap',
+            approved_collision_fingerprint: 'fp_stale',
+            approved_paths: ['src/old.ts'],
+            approved_with_feature_ids: ['feature_c'],
+            status: 'stale',
+            source_collision_id: 'colrec_2',
+          },
+          {
+            override_id: 'colovr_revoked',
+            feature_ids: ['feature_b', 'feature_d'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'revoked overlap',
+            approved_collision_fingerprint: 'fp_revoked',
+            approved_paths: ['src/revoked.ts'],
+            approved_with_feature_ids: ['feature_d'],
+            status: 'revoked',
+            source_collision_id: 'colrec_3',
+          },
+        ],
+      }),
+    );
+
+    await harness.ensureState('feature_a', {
+      status: STATUS.BUILDING,
+      branch: 'feature/fallback-branch',
+      locks: { held: [] },
+      gate_profile: 'default',
+      gates: { plan: 'pass' },
+      last_updated: '2026-01-01T00:00:00.000Z',
+    });
+    await harness.ensureState('feature_b', {
+      status: STATUS.PLANNING,
+      locks: { held: [] },
+      gate_profile: 'default',
+      gates: { plan: 'pending' },
+      last_updated: '2026-01-01T00:00:00.000Z',
+    });
+
+    const collisions = await harness.service.collisionsScan();
+    expect(collisions.data.stale_overrides).toHaveLength(1);
+    expect(collisions.data.revoked_overrides).toHaveLength(1);
+
+    const dashboard = await harness.service.reportDashboard();
+    const featureA = dashboard.data.features.find(
+      (item: AnyRecord) => item.feature_id === 'feature_a',
+    );
+    const featureB = dashboard.data.features.find(
+      (item: AnyRecord) => item.feature_id === 'feature_b',
+    );
+
+    expect(featureA?.branch).toBe('feature/fallback-branch');
+    expect(featureA?.collision_overrides[0]).toMatchObject({
+      counterpart_feature_id: 'feature_b',
+      applied_at: '2026-03-15T00:05:00.000Z',
+    });
+    expect(featureB?.branch).toBeNull();
+    expect(dashboard.data.collision_summary).toMatchObject({
+      active_approved: 1,
+      active_unapproved: 0,
+      stale_overrides: 1,
+      revoked_overrides: 1,
+    });
+  });
+
+  it('includes active collision override and latest collision status in feature summary', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    await harness.ensureState('feature_summary', {
+      status: STATUS.QA,
+      gates: { full: 'pass' },
+      locks: { held: [] },
+    });
+    harness.setIndex(
+      makeIndex({
+        active: ['feature_summary'],
+        blocked: [],
+        merged: [],
+        collision_overrides: [
+          {
+            override_id: 'colovr_summary',
+            feature_ids: ['feature_other', 'feature_summary'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'summary overlap',
+            approved_collision_fingerprint: 'fp_summary',
+            approved_paths: ['src/summary.ts'],
+            approved_with_feature_ids: ['feature_other'],
+            status: 'active',
+            last_seen_at: '2026-03-15T00:03:00.000Z',
+            source_collision_id: 'colrec_summary_2',
+          },
+        ],
+        collision_records: [
+          {
+            collision_id: 'colrec_summary_1',
+            feature_id: 'feature_summary',
+            with_feature_ids: ['feature_other'],
+            detected_at: '2026-03-15T00:01:00.000Z',
+            collision_fingerprint: 'fp_old',
+            collisions: { files: [], areas: [], contracts: [] },
+            resolution: 'rejected',
+          },
+          {
+            collision_id: 'colrec_summary_2',
+            feature_id: 'feature_other',
+            with_feature_ids: ['feature_summary'],
+            detected_at: '2026-03-15T00:02:00.000Z',
+            collision_fingerprint: 'fp_summary',
+            collisions: { files: [], areas: [], contracts: [] },
+            resolution: 'override_applied',
+            resolution_details: {
+              override_id: 'colovr_summary',
+              resolved_at: '2026-03-15T00:03:00.000Z',
+            },
+          },
+        ],
+      }),
+    );
+
+    const summary = await harness.service.reportFeatureSummary('feature_summary');
+
+    expect(summary.data.active_collision_overrides).toEqual([
+      {
+        override_id: 'colovr_summary',
+        status: 'active',
+        counterpart_feature_id: 'feature_other',
+        rationale: 'summary overlap',
+        approved_paths: ['src/summary.ts'],
+        approved_collision_fingerprint: 'fp_summary',
+        last_seen_at: '2026-03-15T00:03:00.000Z',
+        applied_at: null,
+      },
+    ]);
+    expect(summary.data.recent_collision_records).toHaveLength(2);
+    expect(summary.data.latest_collision_status).toEqual({
+      collision_id: 'colrec_summary_2',
+      resolution: 'override_applied',
+      resolved_at: '2026-03-15T00:03:00.000Z',
+      override_id: 'colovr_summary',
+    });
+  });
+
+  it('reports unapproved collisions and skips dashboard entries with no state file', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    harness.plans.push(
+      {
+        feature_id: 'feature_a',
+        plan_version: 1,
+        files: { create: [], modify: ['src/shared.ts'], delete: [] },
+        allowed_areas: ['src'],
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      },
+      {
+        feature_id: 'feature_b',
+        plan_version: 1,
+        files: { create: [], modify: ['src/shared.ts'], delete: [] },
+        allowed_areas: ['src'],
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      },
+    );
+    harness.setIndex(
+      makeIndex({
+        active: ['feature_a', 'feature_b', 'feature_missing'],
+        blocked: [],
+        merged: [],
+        locks: {
+          openapi: null,
+          db_migrations: null,
+        },
+        collision_overrides: [],
+      }),
+    );
+
+    await harness.ensureState('feature_a', {
+      status: STATUS.BUILDING,
+      locks: { held: [] },
+      gate_profile: 'default',
+      gates: { plan: 'pass' },
+      pr: { number: 42 },
+      last_updated: '2026-01-01T00:00:00.000Z',
+    });
+    await harness.ensureState('feature_b', {
+      status: STATUS.PLANNING,
+      locks: { held: [] },
+      gate_profile: 'default',
+      gates: { plan: 'pending' },
+      last_updated: '2026-01-01T00:00:00.000Z',
+    });
+
+    const collisions = await harness.service.collisionsScan();
+    expect(collisions.data.collisions[0]).toMatchObject({
+      approval_status: 'unapproved_active',
+      override: null,
+    });
+
+    const dashboard = await harness.service.reportDashboard();
+    expect(dashboard.data.features.map((item: AnyRecord) => item.feature_id)).toEqual([
+      'feature_a',
+      'feature_b',
+    ]);
+    expect(dashboard.data.features[0].pr).toEqual({ number: 42 });
+    expect(dashboard.data.collision_summary.active_unapproved).toBe(1);
+  });
+
+  it('returns null latest collision status when no collision records exist for a summary', async () => {
+    const harness = await makeReportingHarness();
+    cleanups.push(harness.cleanup);
+    await harness.ensureState('feature_summary_empty', {
+      status: STATUS.PLANNING,
+      gates: { plan: 'pending' },
+      locks: { held: [] },
+    });
+    harness.setIndex(
+      makeIndex({
+        active: ['feature_summary_empty'],
+        blocked: [],
+        merged: [],
+        collision_overrides: [
+          {
+            override_id: 'colovr_summary_empty',
+            feature_ids: ['feature_summary_empty', 'feature_other'],
+            created_at: '2026-03-15T00:00:00.000Z',
+            created_by: 'run:test',
+            rationale: 'summary overlap',
+            approved_collision_fingerprint: 'fp_summary_empty',
+            approved_paths: ['src/summary.ts'],
+            approved_with_feature_ids: ['feature_other'],
+            status: 'active',
+            source_collision_id: 'missing_record',
+          },
+        ],
+        collision_records: [],
+      }),
+    );
+
+    const summary = await harness.service.reportFeatureSummary('feature_summary_empty');
+    expect(summary.data.active_collision_overrides[0].counterpart_feature_id).toBe('feature_other');
+    expect(summary.data.latest_collision_status).toBeNull();
+  });
 });
 
 describe('ReportingService worktree_branch coverage', () => {