agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/collision-queue.spec.ts

@@ -1,9 +1,11 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { AopKernel } from '../src/index.js';
 import { CollisionQueueService } from '../src/application/services/collision-queue-service.js';
-import { makeTempRepo } from './helpers.js';
+import { makeTempRepo, verifyFeatureIntake, writeFeatureSpec } from './helpers.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import os from 'node:os';
+import { detectPlanCollisions } from '../src/core/collisions.js';
 
 describe('Collision Queue Re-Drive Service', () => {
   let tempDir: string;
@@ -71,6 +73,66 @@ describe('Collision Queue Re-Drive Service', () => {
     const result = await collisionQueueService.reDriveBlockedQueue();
 
     expect(result.data.processed).toBe(2);
+  }, 10_000);
+
+  it('should ignore merged features when re-driving collision queue', async () => {
+    await writeFeatureSpec(tempDir, 'feature-merged');
+    await writeFeatureSpec(tempDir, 'feature-blocked');
+    await kernel.featureInit('feature-merged');
+    await kernel.featureInit('feature-blocked');
+    await verifyFeatureIntake(kernel, 'feature-merged');
+    await verifyFeatureIntake(kernel, 'feature-blocked');
+
+    const mergedPlan = {
+      feature_id: 'feature-merged',
+      plan_version: 1,
+      summary: 'Merged plan',
+      allowed_areas: ['src'],
+      forbidden_areas: [],
+      base_ref: 'main',
+      files: { create: [], modify: ['src/shared.txt'], delete: [] },
+      contracts: { openapi: 'none', events: 'none', db: 'none' },
+      acceptance_criteria: ['ok'],
+      gate_profile: 'default',
+    };
+
+    const blockedPlan = {
+      feature_id: 'feature-blocked',
+      plan_version: 1,
+      summary: 'Blocked plan',
+      allowed_areas: ['src'],
+      forbidden_areas: [],
+      base_ref: 'main',
+      files: { create: [], modify: ['src/shared.txt'], delete: [] },
+      contracts: { openapi: 'none', events: 'none', db: 'none' },
+      acceptance_criteria: ['ok'],
+      gate_profile: 'default',
+    };
+
+    await fs.writeFile(
+      path.join(tempDir, '.aop', 'features', 'feature-merged', 'plan.json'),
+      JSON.stringify(mergedPlan, null, 2),
+    );
+    const index = await kernel.readIndex();
+    index.merged = ['feature-merged'];
+    index.blocked_queue = [
+      {
+        feature_id: 'feature-blocked',
+        plan_version: 1,
+        detected_at: '2026-02-28T12:00:00Z',
+        collision_fingerprint: 'hash-blocked',
+        required_resources: [],
+        plan_snapshot: blockedPlan,
+      },
+    ];
+    await kernel.writeIndex(index);
+
+    const result = await collisionQueueService.reDriveBlockedQueue();
+
+    expect(result.data.retried).toBe(1);
+    expect(result.data.still_blocked).toBe(0);
+    const updatedIndex = await kernel.readIndex();
+    expect(updatedIndex.blocked_queue).toHaveLength(0);
   });
 
   it('should keep entry in queue if plan is missing', async () => {
@@ -181,6 +243,7 @@ describe('CollisionQueueService additional branches', () => {
 
   it('GIVEN_plan_resolved_from_snapshot_WHEN_persisted_plan_version_mismatch_THEN_uses_snapshot', async () => {
     await kernel.featureInit('feature-snap');
+    await verifyFeatureIntake(kernel, 'feature-snap');
     const featureDir = path.join(tempDir, '.aop', 'features', 'feature-snap');
     await fs.mkdir(featureDir, { recursive: true });
 
@@ -233,6 +296,7 @@ describe('CollisionQueueService additional branches', () => {
 
   it('GIVEN_plan_revision_of_not_integer_WHEN_processSingleQueueEntry_THEN_planSubmit_called_with_null_expected_version', async () => {
     await kernel.featureInit('feature-revof');
+    await verifyFeatureIntake(kernel, 'feature-revof');
     const featureDir = path.join(tempDir, '.aop', 'features', 'feature-revof');
     await fs.mkdir(featureDir, { recursive: true });
 
@@ -268,3 +332,367 @@ describe('CollisionQueueService additional branches', () => {
     expect(result.data.processed).toBe(1);
   });
 });
+
+describe('CollisionQueueService focused unit branches', () => {
+  async function makeUnitHarness() {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-collision-queue-unit-'));
+    const featureAPlan = {
+      feature_id: 'feature_a',
+      plan_version: 1,
+      revision_of: 3,
+      files: { create: [], modify: ['src/shared.ts'], delete: [] },
+      allowed_areas: ['src'],
+      contracts: { openapi: 'none', events: 'none', db: 'none' },
+    };
+    const featureBPlan = {
+      feature_id: 'feature_b',
+      plan_version: 1,
+      files: { create: [], modify: ['src/shared.ts'], delete: [] },
+      allowed_areas: ['src'],
+      contracts: { openapi: 'none', events: 'none', db: 'none' },
+    };
+    const writePlan = async (plan: Record<string, unknown>) => {
+      const featureDir = path.join(repoRoot, String(plan.feature_id));
+      await fs.mkdir(featureDir, { recursive: true });
+      await fs.writeFile(path.join(featureDir, 'plan.json'), JSON.stringify(plan, null, 2), 'utf8');
+    };
+    await writePlan(featureAPlan);
+    await writePlan(featureBPlan);
+
+    const collision = detectPlanCollisions(featureAPlan, [featureBPlan], {});
+    let index: Record<string, unknown> = {
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [],
+    };
+    let heldLocks: string[] = [];
+    let currentPlan = JSON.parse(JSON.stringify(featureAPlan)) as Record<string, unknown>;
+    const planSubmit = vi.fn(async () => ({
+      data: {
+        feature_id: 'feature_a',
+        accepted: true,
+        plan_version: 1,
+      },
+    }));
+    const planGet = vi.fn(async () => ({
+      data: {
+        feature_id: 'feature_a',
+        plan: JSON.parse(JSON.stringify(currentPlan)) as Record<string, unknown>,
+      },
+    }));
+    const planUpdate = vi.fn(
+      async (
+        _featureId: string,
+        _expectedPlanVersion: number | null,
+        nextPlan: Record<string, unknown>,
+      ) => {
+        currentPlan = JSON.parse(JSON.stringify(nextPlan)) as Record<string, unknown>;
+        return {
+          data: {
+            feature_id: 'feature_a',
+            accepted: true,
+            plan_version: Number(nextPlan.plan_version),
+          },
+        };
+      },
+    );
+
+    const service = new CollisionQueueService({
+      getPolicySnapshot: () => ({
+        collision_policy: 'block',
+        locks: {
+          contract_to_resource: {
+            openapi: 'openapi',
+            events: 'events',
+            db: 'db_migrations',
+          },
+        },
+      }),
+      planPath: (featureId: string) => path.join(repoRoot, featureId, 'plan.json'),
+      statePath: (featureId: string) => path.join(repoRoot, featureId, 'state.md'),
+      featureDiscoverSpecs: async () => ({
+        data: {
+          specs: [{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }],
+        },
+      }),
+      readState: async () => ({
+        frontMatter: {
+          locks: { held: heldLocks },
+        },
+      }),
+      withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) =>
+        await operation(),
+      withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+      readIndex: async () => JSON.parse(JSON.stringify(index)) as Record<string, unknown>,
+      writeIndex: async (nextIndex: Record<string, unknown>) => {
+        index = JSON.parse(JSON.stringify(nextIndex)) as Record<string, unknown>;
+      },
+      updateState: async () => ({}),
+      planSubmit,
+      planGet,
+      planUpdate,
+    });
+
+    return {
+      service,
+      featureAPlan,
+      featureBPlan,
+      collision,
+      planSubmit,
+      planGet,
+      planUpdate,
+      writePlan,
+      setHeldLocks: (nextHeldLocks: string[]) => {
+        heldLocks = [...nextHeldLocks];
+      },
+      setIndex: (nextIndex: Record<string, unknown>) => {
+        index = JSON.parse(JSON.stringify(nextIndex)) as Record<string, unknown>;
+      },
+      setCurrentPlan: (nextPlan: Record<string, unknown>) => {
+        currentPlan = JSON.parse(JSON.stringify(nextPlan)) as Record<string, unknown>;
+      },
+      cleanup: async () => await fs.rm(repoRoot, { recursive: true, force: true }),
+    };
+  }
+
+  it('maps required contract mutations to deterministic resources and checks held locks', async () => {
+    const harness = await makeUnitHarness();
+
+    const resources = harness.service.requiredResourcesForPlan({
+      contracts: {
+        openapi: 'modify',
+        events: 'modify',
+        db: 'migration',
+      },
+    });
+    expect(resources).toEqual(['db_migrations', 'events', 'openapi']);
+
+    harness.setHeldLocks(['db_migrations', 'events', 'openapi']);
+    await expect(
+      harness.service.assertPlanLocksHeld('feature_a', {
+        contracts: {
+          openapi: 'modify',
+          events: 'modify',
+          db: 'migration',
+        },
+      }),
+    ).resolves.toBe(true);
+
+    harness.setHeldLocks(['openapi']);
+    await expect(
+      harness.service.assertPlanLocksHeld('feature_a', {
+        contracts: {
+          openapi: 'modify',
+          events: 'modify',
+          db: 'migration',
+        },
+      }),
+    ).resolves.toBe(false);
+
+    await harness.cleanup();
+  });
+
+  it('marks live collisions approved only when a matching active override exists', async () => {
+    const harness = await makeUnitHarness();
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_1',
+          feature_ids: ['feature_a', 'feature_b'],
+          status: 'active',
+          approved_collision_fingerprint: harness.collision.fingerprint,
+        },
+      ],
+    });
+
+    await expect(
+      harness.service.checkPlanCollision('feature_a', harness.featureAPlan),
+    ).resolves.toMatchObject({
+      hasCollisions: true,
+      approved: true,
+    });
+
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_2',
+          feature_ids: ['feature_a', 'feature_b'],
+          status: 'revoked',
+          approved_collision_fingerprint: harness.collision.fingerprint,
+        },
+      ],
+    });
+
+    await expect(
+      harness.service.checkPlanCollision('feature_a', harness.featureAPlan),
+    ).resolves.toMatchObject({
+      hasCollisions: true,
+      approved: false,
+    });
+
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_3',
+          feature_ids: ['feature_a', 'feature_b'],
+        },
+      ],
+    });
+
+    await expect(
+      harness.service.checkPlanCollision('feature_a', harness.featureAPlan),
+    ).resolves.toMatchObject({
+      hasCollisions: true,
+      approved: false,
+    });
+
+    await harness.cleanup();
+  });
+
+  it('never auto-approves contract collisions from overrides', async () => {
+    const harness = await makeUnitHarness();
+    const featureAPlanWithContract = {
+      ...harness.featureAPlan,
+      contracts: {
+        openapi: 'modify',
+        events: 'none',
+        db: 'none',
+      },
+    };
+    const featureBPlanWithContract = {
+      ...harness.featureBPlan,
+      contracts: {
+        openapi: 'modify',
+        events: 'none',
+        db: 'none',
+      },
+    };
+    await harness.writePlan(featureBPlanWithContract);
+
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_contract',
+          feature_ids: ['feature_a', 'feature_b'],
+          status: 'active',
+          approved_collision_fingerprint: 'any',
+        },
+      ],
+    });
+
+    await expect(
+      harness.service.checkPlanCollision('feature_a', featureAPlanWithContract),
+    ).resolves.toMatchObject({
+      hasCollisions: true,
+      approved: false,
+    });
+
+    await harness.cleanup();
+  });
+
+  it('retries approved collisions and reports plan submission failures', async () => {
+    const harness = await makeUnitHarness();
+    harness.setHeldLocks([]);
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_1',
+          feature_ids: ['feature_a', 'feature_b'],
+          status: 'applied',
+          approved_collision_fingerprint: harness.collision.fingerprint,
+        },
+      ],
+    });
+
+    const approvedRetry = await harness.service.processSingleQueueEntry({
+      feature_id: 'feature_a',
+      plan_version: 1,
+      detected_at: '2026-03-15T00:00:00.000Z',
+      collision_fingerprint: harness.collision.fingerprint,
+      required_resources: [],
+    });
+    expect(approvedRetry).toEqual({ retried: true });
+    expect(harness.planSubmit).toHaveBeenCalledWith('feature_a', harness.featureAPlan, 3);
+
+    harness.planSubmit.mockRejectedValueOnce(new Error('submit failed'));
+    const failedRetry = await harness.service.processSingleQueueEntry({
+      feature_id: 'feature_a',
+      plan_version: 1,
+      detected_at: '2026-03-15T00:00:00.000Z',
+      collision_fingerprint: harness.collision.fingerprint,
+      required_resources: [],
+    });
+    expect(failedRetry).toEqual({ retried: false, reason: 'plan_submit_failed' });
+
+    await harness.cleanup();
+  });
+
+  it('recovers replayed plan submissions by promoting stale submit attempts to plan.update', async () => {
+    const harness = await makeUnitHarness();
+    harness.setHeldLocks([]);
+    harness.setIndex({
+      version: 1,
+      merged: [],
+      blocked_queue: [],
+      collision_overrides: [
+        {
+          override_id: 'colovr_1',
+          feature_ids: ['feature_a', 'feature_b'],
+          status: 'applied',
+          approved_collision_fingerprint: harness.collision.fingerprint,
+        },
+      ],
+    });
+    harness.setCurrentPlan({
+      feature_id: 'feature_a',
+      plan_version: 1,
+      summary: 'Current accepted plan',
+      files: { create: [], modify: ['src/current.ts'], delete: [] },
+    });
+    harness.planSubmit.mockRejectedValueOnce({
+      normalizedResponse: {
+        error: {
+          code: 'version_conflict',
+        },
+      },
+    });
+
+    const result = await harness.service.processSingleQueueEntry({
+      feature_id: 'feature_a',
+      plan_version: 1,
+      detected_at: '2026-03-15T00:00:00.000Z',
+      collision_fingerprint: harness.collision.fingerprint,
+      required_resources: [],
+    });
+
+    expect(result).toEqual({ retried: true });
+    expect(harness.planGet).toHaveBeenCalledWith('feature_a');
+    expect(harness.planUpdate).toHaveBeenCalledWith(
+      'feature_a',
+      1,
+      expect.objectContaining({
+        feature_id: 'feature_a',
+        plan_version: 2,
+        revision_of: 1,
+      }),
+    );
+
+    await harness.cleanup();
+  });
+});

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

@@ -1,5 +1,17 @@
 import { describe, expect, it } from 'vitest';
-import { detectPlanCollisions } from '../src/core/collisions.js';
+import {
+  collectApprovedPaths,
+  collectCollisionFeatureIds,
+  collisionSubsetForFeature,
+  createCollisionFingerprint,
+  detectPlanCollisions,
+  emptyPlanCollisions,
+  hasContractCollisions,
+  hasPlanCollisions,
+  normalizePlanCollisions,
+  splitPlanCollisionsByFeature,
+  type PlanCollisionsShape,
+} from '../src/core/collisions.js';
 
 describe('detectPlanCollisions', () => {
   it('GIVEN_disjoint_plans_WHEN_detecting_THEN_reports_no_collisions', () => {
@@ -135,4 +147,200 @@ describe('detectPlanCollisions', () => {
     expect(result.hasCollisions).toBe(false);
     expect(result.fingerprint).toBeNull();
   });
+
+  it('GIVEN_multi_feature_collisions_WHEN_splitting_by_feature_THEN_creates_pairwise_fingerprints', () => {
+    const result = detectPlanCollisions(
+      {
+        feature_id: 'feature_a',
+        files: { modify: ['src/shared.ts'] },
+        allowed_areas: ['libs/core/module_a'],
+        contracts: { openapi: 'modify', events: 'none', db: 'none' },
+      },
+      [
+        {
+          feature_id: 'feature_b',
+          files: { modify: ['src/shared.ts'] },
+          allowed_areas: ['libs/core'],
+          contracts: { openapi: 'none', events: 'none', db: 'none' },
+        },
+        {
+          feature_id: 'feature_c',
+          contracts: { openapi: 'modify', events: 'none', db: 'none' },
+        },
+      ],
+      {
+        exclusive_areas: ['libs/core'],
+      },
+    );
+
+    const pairs = splitPlanCollisionsByFeature('feature_a', result.collisions);
+    expect(pairs).toEqual([
+      {
+        with_feature_id: 'feature_b',
+        collisions: {
+          files: [{ with_feature_id: 'feature_b', paths: ['src/shared.ts'] }],
+          areas: [
+            { with_feature_id: 'feature_b', overlaps: [['libs/core/module_a', 'libs/core']] },
+          ],
+          contracts: [],
+        },
+        fingerprint: expect.any(String),
+        approved_paths: ['src/shared.ts'],
+      },
+      {
+        with_feature_id: 'feature_c',
+        collisions: {
+          files: [],
+          areas: [],
+          contracts: [
+            {
+              with_feature_id: 'feature_c',
+              contract: 'openapi',
+              candidate_mode: 'modify',
+              other_mode: 'modify',
+            },
+          ],
+        },
+        fingerprint: expect.any(String),
+        approved_paths: [],
+      },
+    ]);
+
+    expect(collisionSubsetForFeature(result.collisions, 'feature_b')).toEqual(pairs[0].collisions);
+  });
+
+  it('GIVEN_unsorted_collision_shapes_WHEN_normalizing_THEN_sorts_entries_paths_and_overlap_tiebreakers', () => {
+    const normalized = normalizePlanCollisions({
+      files: [
+        { with_feature_id: 'feature_b', paths: ['src/z.ts', 'src/a.ts', 'src/a.ts'] },
+        { with_feature_id: 'feature_a', paths: ['src/m.ts'] },
+      ],
+      areas: [
+        {
+          with_feature_id: 'feature_b',
+          overlaps: [
+            ['libs/a', 'libs/b'],
+            ['libs/z', 'libs/a'],
+            ['libs/a', 'libs/z'],
+          ],
+        },
+        {
+          with_feature_id: 'feature_a',
+          overlaps: [['libs/x', 'libs/y']],
+        },
+      ],
+      contracts: [
+        {
+          with_feature_id: 'feature_b',
+          contract: 'events',
+          candidate_mode: 'modify',
+          other_mode: 'add',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'events',
+          candidate_mode: 'modify',
+          other_mode: 'patch',
+        },
+        {
+          with_feature_id: 'feature_a',
+          contract: 'openapi',
+          candidate_mode: 'modify',
+          other_mode: 'modify',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'db',
+          candidate_mode: 'modify',
+          other_mode: 'modify',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'db',
+          candidate_mode: 'add',
+          other_mode: 'modify',
+        },
+      ],
+    });
+
+    expect(normalized).toEqual({
+      files: [
+        { with_feature_id: 'feature_a', paths: ['src/m.ts'] },
+        { with_feature_id: 'feature_b', paths: ['src/a.ts', 'src/z.ts'] },
+      ],
+      areas: [
+        { with_feature_id: 'feature_a', overlaps: [['libs/x', 'libs/y']] },
+        {
+          with_feature_id: 'feature_b',
+          overlaps: [
+            ['libs/a', 'libs/b'],
+            ['libs/a', 'libs/z'],
+            ['libs/z', 'libs/a'],
+          ],
+        },
+      ],
+      contracts: [
+        {
+          with_feature_id: 'feature_a',
+          contract: 'openapi',
+          candidate_mode: 'modify',
+          other_mode: 'modify',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'db',
+          candidate_mode: 'add',
+          other_mode: 'modify',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'db',
+          candidate_mode: 'modify',
+          other_mode: 'modify',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'events',
+          candidate_mode: 'modify',
+          other_mode: 'add',
+        },
+        {
+          with_feature_id: 'feature_b',
+          contract: 'events',
+          candidate_mode: 'modify',
+          other_mode: 'patch',
+        },
+      ],
+    });
+  });
+
+  it('GIVEN_collision_helpers_WHEN_called_THEN_report_expected_sets_flags_and_fingerprints', () => {
+    const empty = emptyPlanCollisions();
+    expect(hasPlanCollisions(empty)).toBe(false);
+    expect(hasContractCollisions(empty)).toBe(false);
+
+    const collisions: PlanCollisionsShape = {
+      files: [
+        { with_feature_id: 'feature_b', paths: ['src/shared.ts', 'src/shared.ts'] },
+        { with_feature_id: 'feature_c', paths: ['src/other.ts'] },
+      ],
+      areas: [{ with_feature_id: 'feature_c', overlaps: [['libs/core', 'libs/core/subdir']] }],
+      contracts: [
+        {
+          with_feature_id: 'feature_b',
+          contract: 'openapi',
+          candidate_mode: 'modify',
+          other_mode: 'add',
+        },
+      ],
+    };
+
+    expect(collectCollisionFeatureIds(collisions)).toEqual(['feature_b', 'feature_c']);
+    expect(collectApprovedPaths(collisions)).toEqual(['src/other.ts', 'src/shared.ts']);
+    expect(hasPlanCollisions(collisions)).toBe(true);
+    expect(hasContractCollisions(collisions)).toBe(true);
+    expect(createCollisionFingerprint('feature_a', collisions)).toBe(
+      createCollisionFingerprint('feature_a', normalizePlanCollisions(collisions)),
+    );
+  });
 });