agentic-orchestrator 0.1.0

package/apps/control-plane/test/kernel-collision-replay.spec.ts

@@ -0,0 +1,222 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AopKernel } from '../src/index.js';
+import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+
+const ORCHESTRATOR_CONTEXT = { actor_type: 'orchestrator', actor_id: 'test' };
+
+let repoRoot: string;
+
+beforeEach(async () => {
+  repoRoot = await makeTempRepo(process.cwd());
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'shared.txt'), 'shared\n', 'utf8');
+  await fs.writeFile(path.join(repoRoot, 'src', 'leader.txt'), 'leader\n', 'utf8');
+  await fs.writeFile(path.join(repoRoot, 'src', 'unique-b.txt'), 'b\n', 'utf8');
+});
+
+function buildPlan(featureId: string, planVersion: number, modifyPath: string, revisionOf: number | null = null) {
+  const plan = {
+    feature_id: featureId,
+    plan_version: planVersion,
+    summary: `Plan ${featureId} v${planVersion}`,
+    allowed_areas: ['src'],
+    forbidden_areas: [],
+    base_ref: 'HEAD',
+    files: {
+      create: [],
+      modify: [modifyPath],
+      delete: []
+    },
+    contracts: {
+      openapi: 'none',
+      events: 'none',
+      db: 'none'
+    },
+    acceptance_criteria: ['Deterministic plan is accepted'],
+    gate_profile: 'default'
+  };
+
+  if (revisionOf != null) {
+    (plan as any).revision_of = revisionOf;
+  }
+
+  return plan;
+}
+
+async function initFeature(kernel: AopKernel, featureId: string) {
+  await writeFeatureSpec(repoRoot, featureId);
+  const init = await kernel.invoke('feature.init', { feature_id: featureId }, ORCHESTRATOR_CONTEXT);
+  expect(init.ok).toBe(true);
+}
+
+describe('AopKernel collision queue replay integration', () => {
+  it('persists blocked queue entries with required collision fields under collision_policy=block', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    kernel.policy.collision_policy = 'block';
+
+    await initFeature(kernel, 'feature_a');
+    await initFeature(kernel, 'feature_b');
+
+    const accepted = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_a',
+        plan_json: buildPlan('feature_a', 1, 'src/shared.txt')
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(accepted.ok).toBe(true);
+
+    const queued = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_b',
+        plan_json: buildPlan('feature_b', 1, 'src/shared.txt')
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(queued.ok).toBe(false);
+    expect(queued.error.code).toBe('blocked_by_collision_policy');
+
+    const index = await kernel.readIndex();
+    expect(index.blocked_queue).toHaveLength(1);
+    expect(index.blocked_queue[0]).toMatchObject({
+      feature_id: 'feature_b',
+      plan_version: 1,
+      collision_fingerprint: expect.any(String),
+      detected_at: expect.any(String),
+      required_resources: expect.any(Array)
+    });
+  });
+
+  it('replays blocked queue deterministically when lock release triggers collision re-drive', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    kernel.policy.collision_policy = 'block';
+
+    for (const featureId of ['feature_a', 'feature_b', 'feature_c']) {
+      await initFeature(kernel, featureId);
+    }
+
+    const lockAcquire = await kernel.invoke(
+      'locks.acquire',
+      { resource: 'openapi', feature_id: 'feature_a' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(lockAcquire.ok).toBe(true);
+
+    const acceptedA1 = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_a',
+        plan_json: buildPlan('feature_a', 1, 'src/shared.txt')
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(acceptedA1.ok).toBe(true);
+
+    const queuedB = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_b',
+        plan_json: buildPlan('feature_b', 1, 'src/shared.txt')
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(queuedB.ok).toBe(false);
+    expect(queuedB.error.code).toBe('blocked_by_collision_policy');
+
+    const queuedC = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_c',
+        plan_json: buildPlan('feature_c', 1, 'src/shared.txt')
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(queuedC.ok).toBe(false);
+    expect(queuedC.error.code).toBe('blocked_by_collision_policy');
+
+    const acceptedA2 = await kernel.invoke(
+      'plan.update',
+      {
+        feature_id: 'feature_a',
+        expected_plan_version: 1,
+        plan_json: buildPlan('feature_a', 2, 'src/leader.txt', 1)
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(acceptedA2.ok).toBe(true);
+
+    const queueSeedIndex = await kernel.readIndex();
+    expect(queueSeedIndex.blocked_queue).toHaveLength(2);
+    const seeded = {
+      ...queueSeedIndex,
+      blocked_queue: queueSeedIndex.blocked_queue.map((entry: any) => ({
+        ...entry,
+        detected_at: '2026-02-28T12:00:00Z'
+      }))
+    };
+    await kernel.writeIndex(seeded);
+
+    const beforeFirstReplayVersion = (await kernel.readIndex()).version;
+
+    const firstReplayTrigger = await kernel.invoke(
+      'locks.release',
+      { resource: 'openapi', feature_id: 'feature_a' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(firstReplayTrigger.ok).toBe(true);
+
+    const afterFirstReplay = await kernel.readIndex();
+    expect(afterFirstReplay.version).toBeGreaterThan(beforeFirstReplayVersion);
+    expect(afterFirstReplay.blocked_queue).toHaveLength(1);
+    expect(afterFirstReplay.blocked_queue[0].feature_id).toBe('feature_c');
+
+    const planB = await kernel.invoke('plan.get', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
+    expect(planB.ok).toBe(true);
+    expect(planB.data.plan.plan_version).toBe(1);
+
+    const acceptedB2 = await kernel.invoke(
+      'plan.update',
+      {
+        feature_id: 'feature_b',
+        expected_plan_version: 1,
+        plan_json: buildPlan('feature_b', 2, 'src/unique-b.txt', 1)
+      },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(acceptedB2.ok).toBe(true);
+
+    const secondAcquire = await kernel.invoke(
+      'locks.acquire',
+      { resource: 'openapi', feature_id: 'feature_a' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(secondAcquire.ok).toBe(true);
+
+    const secondReplayTrigger = await kernel.invoke(
+      'locks.release',
+      { resource: 'openapi', feature_id: 'feature_a' },
+      ORCHESTRATOR_CONTEXT
+    );
+    expect(secondReplayTrigger.ok).toBe(true);
+
+    const afterSecondReplay = await kernel.readIndex();
+    expect(afterSecondReplay.blocked_queue).toHaveLength(0);
+
+    const planC = await kernel.invoke('plan.get', { feature_id: 'feature_c' }, ORCHESTRATOR_CONTEXT);
+    expect(planC.ok).toBe(true);
+    expect(planC.data.plan.plan_version).toBe(1);
+
+    const stateB = await kernel.invoke('feature.state_get', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
+    const stateC = await kernel.invoke('feature.state_get', { feature_id: 'feature_c' }, ORCHESTRATOR_CONTEXT);
+    expect(stateB.ok).toBe(true);
+    expect(stateC.ok).toBe(true);
+    expect(stateB.data.front_matter.version).toBeGreaterThan(1);
+    expect(stateC.data.front_matter.version).toBeGreaterThan(1);
+  });
+});

package/apps/control-plane/test/kernel.branches.spec.ts

@@ -0,0 +1,321 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AopKernel } from '../src/index.js';
+import { runGit } from '../src/core/git.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { STATUS } from '../src/core/constants.js';
+import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+
+const ORCH = { actor_type: 'orchestrator', actor_id: 'orch:test' };
+const BUILDER = { actor_type: 'builder', actor_id: 'builder:test' };
+
+let repoRoot: string;
+
+async function writeBranchGates(root: string): Promise<void> {
+  const gatesPath = path.join(root, 'agentic', 'orchestrator', 'gates.yaml');
+  await fs.writeFile(
+    gatesPath,
+    [
+      'version: 1',
+      'profiles:',
+      '  default:',
+      '    modes:',
+      '      fast:',
+      '        - name: fast_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '      full:',
+      '        - name: full_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '      merge:',
+      '        - name: merge_pass',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '    parsers:',
+      '      coverage:',
+      '        type: none',
+      '  failing:',
+      '    modes:',
+      '      fast:',
+      '        - name: fast_fail',
+      '          cmd: ["node", "-e", "process.exit(1)"]',
+      '    parsers:',
+      '      coverage:',
+      '        type: none',
+      '  coverage_low:',
+      '    modes:',
+      '      full:',
+      '        - name: tests',
+      '          cmd: ["node", "-e", "process.exit(0)"]',
+      '    parsers:',
+      '      coverage:',
+      '        type: lcov',
+      '        path: coverage/lcov.info',
+      'capabilities:',
+      '  - none',
+      '  - lcov'
+    ].join('\n'),
+    'utf8'
+  );
+}
+
+function validPlan(featureId: string) {
+  return {
+    feature_id: featureId,
+    plan_version: 1,
+    summary: 'Valid plan',
+    allowed_areas: ['src'],
+    forbidden_areas: [],
+    base_ref: 'HEAD',
+    files: { create: [], modify: ['src/sample.txt'], delete: [] },
+    contracts: { openapi: 'none', events: 'none', db: 'none' },
+    acceptance_criteria: ['works'],
+    gate_profile: 'default'
+  };
+}
+
+beforeEach(async () => {
+  repoRoot = await makeTempRepo(process.cwd());
+  await writeBranchGates(repoRoot);
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'sample.txt'), 'hello\n', 'utf8');
+  await runGit(repoRoot, ['add', '.']);
+  await runGit(repoRoot, ['commit', '-m', 'fixture']);
+});
+
+describe('AopKernel branch behavior', () => {
+  it('covers authorization, plan validation, revision conflicts, and reject collisions', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+
+    const forbiddenUnknownActor = await kernel.invoke('feature.init', { feature_id: 'x' }, { actor_type: 'unknown', actor_id: 'x' });
+    expect(forbiddenUnknownActor.ok).toBe(false);
+    expect(forbiddenUnknownActor.error.code).toBe(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE);
+
+    const forbiddenRoleTool = await kernel.invoke(
+      'repo.status',
+      { feature_id: 'x' },
+      { actor_type: 'planner', actor_id: 'planner:test' }
+    );
+    expect(forbiddenRoleTool.ok).toBe(false);
+    expect(forbiddenRoleTool.error.code).toBe(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE);
+
+    const missingFeatureId = await kernel.invoke('feature.init', {}, ORCH);
+    expect(missingFeatureId.ok).toBe(false);
+    expect(missingFeatureId.error.code).toBe(ERROR_CODES.INVALID_ARGUMENT);
+
+    await writeFeatureSpec(repoRoot, 'feature_a');
+    await writeFeatureSpec(repoRoot, 'feature_b');
+    await kernel.invoke('feature.init', { feature_id: 'feature_a' }, ORCH);
+    await kernel.invoke('feature.init', { feature_id: 'feature_b' }, ORCH);
+
+    const invalidSchema = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_a', plan_json: { feature_id: 'feature_a' } },
+      ORCH
+    );
+    expect(invalidSchema.ok).toBe(false);
+    expect(invalidSchema.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
+
+    const invalidInitialVersion = await kernel.invoke(
+      'plan.submit',
+      {
+        feature_id: 'feature_a',
+        plan_json: {
+          ...validPlan('feature_a'),
+          plan_version: 2
+        }
+      },
+      ORCH
+    );
+    expect(invalidInitialVersion.ok).toBe(false);
+    expect(invalidInitialVersion.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
+
+    const accepted = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_a', plan_json: validPlan('feature_a') },
+      ORCH
+    );
+    expect(accepted.ok).toBe(true);
+
+    const versionConflict = await kernel.invoke(
+      'plan.update',
+      {
+        feature_id: 'feature_a',
+        expected_plan_version: 2,
+        plan_json: {
+          ...validPlan('feature_a'),
+          plan_version: 3,
+          revision_of: 2
+        }
+      },
+      ORCH
+    );
+    expect(versionConflict.ok).toBe(false);
+    expect(versionConflict.error.code).toBe(ERROR_CODES.VERSION_CONFLICT);
+
+    const invalidRevisionMetadata = await kernel.invoke(
+      'plan.update',
+      {
+        feature_id: 'feature_a',
+        expected_plan_version: 1,
+        plan_json: {
+          ...validPlan('feature_a'),
+          plan_version: 3,
+          revision_of: 1
+        }
+      },
+      ORCH
+    );
+    expect(invalidRevisionMetadata.ok).toBe(false);
+    expect(invalidRevisionMetadata.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
+
+    const collisionRejected = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_b', plan_json: validPlan('feature_b') },
+      ORCH
+    );
+    expect(collisionRejected.ok).toBe(false);
+    expect(collisionRejected.error.code).toBe(ERROR_CODES.COLLISION_DETECTED);
+  });
+
+  it('covers repo, QA index, evidence, and gate failure branches', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+
+    await writeFeatureSpec(repoRoot, 'feature_c');
+    await writeFeatureSpec(repoRoot, 'feature_uninit');
+    await kernel.invoke('feature.init', { feature_id: 'feature_c' }, ORCH);
+
+    const noPlanPatch = await kernel.invoke(
+      'repo.apply_patch',
+      { feature_id: 'feature_c', unified_diff: 'diff --git a/x b/x' },
+      BUILDER
+    );
+    expect(noPlanPatch.ok).toBe(false);
+    expect(noPlanPatch.error.code).toBe(ERROR_CODES.PLAN_REQUIRED);
+
+    await kernel.invoke('plan.submit', { feature_id: 'feature_c', plan_json: validPlan('feature_c') }, ORCH);
+
+    const badPatch = await kernel.invoke(
+      'repo.apply_patch',
+      { feature_id: 'feature_c', unified_diff: 'not a patch' },
+      BUILDER
+    );
+    expect(badPatch.ok).toBe(false);
+    expect(badPatch.error.code).toBe(ERROR_CODES.GIT_FAILURE);
+
+    const evidenceMissing = await kernel.invoke('evidence.latest', { feature_id: 'feature_uninit' }, ORCH);
+    expect(evidenceMissing.ok).toBe(true);
+    expect(evidenceMissing.data.latest).toBeNull();
+
+    const qaPath = path.join(repoRoot, '.aop', 'features', 'feature_c', 'qa_test_index.json');
+    await fs.writeFile(qaPath, '{}\n', 'utf8');
+    const invalidQaIndex = await kernel.invoke('qa.test_index_get', { feature_id: 'feature_c' }, ORCH);
+    expect(invalidQaIndex.ok).toBe(false);
+    expect(invalidQaIndex.error.code).toBe(ERROR_CODES.INTERNAL_ERROR);
+
+    await fs.rm(qaPath, { force: true });
+    const missingQaIndex = await kernel.invoke(
+      'qa.test_index_update',
+      { feature_id: 'feature_c', expected_version: 1, updates: [] },
+      { actor_type: 'qa', actor_id: 'qa:test' }
+    );
+    expect(missingQaIndex.ok).toBe(false);
+    expect(missingQaIndex.error.code).toBe(ERROR_CODES.FILE_NOT_FOUND);
+
+    const coverageDir = path.join(repoRoot, '.worktrees', 'feature_c', 'coverage');
+    await fs.mkdir(coverageDir, { recursive: true });
+    await fs.writeFile(
+      path.join(coverageDir, 'lcov.info'),
+      ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:10', 'BRF:10', 'BRH:2', 'end_of_record', ''].join('\n'),
+      'utf8'
+    );
+
+    const coverageFail = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_c', profile: 'coverage_low', mode: 'full' },
+      BUILDER
+    );
+    expect(coverageFail.ok).toBe(false);
+    expect(coverageFail.error.code).toBe(ERROR_CODES.COVERAGE_BELOW_MINIMUM);
+
+    const gateFail = await kernel.invoke(
+      'gates.run',
+      { feature_id: 'feature_c', profile: 'failing', mode: 'fast' },
+      BUILDER
+    );
+    expect(gateFail.ok).toBe(true);
+    expect(gateFail.data.overall).toBe('fail');
+
+    const blockedState = await kernel.invoke('feature.state_get', { feature_id: 'feature_c' }, ORCH);
+    expect(blockedState.ok).toBe(true);
+    expect(blockedState.data.front_matter.status).toBe(STATUS.BLOCKED);
+  });
+
+  it('covers merge precondition branches for status and required gate modes', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+    await writeFeatureSpec(repoRoot, 'feature_merge');
+    await kernel.invoke('feature.init', { feature_id: 'feature_merge' }, ORCH);
+    await kernel.invoke('plan.submit', { feature_id: 'feature_merge', plan_json: validPlan('feature_merge') }, ORCH);
+
+    const notReady = await kernel.invoke(
+      'feature.ready_to_merge',
+      {
+        feature_id: 'feature_merge',
+        commit_message: 'feat: merge',
+        merge_strategy: 'merge_commit',
+        user_approval_token: 'approved'
+      },
+      ORCH
+    );
+    expect(notReady.ok).toBe(false);
+    expect(notReady.error.code).toBe(ERROR_CODES.INVALID_STATUS_TRANSITION);
+
+    const state = await kernel.invoke('feature.state_get', { feature_id: 'feature_merge' }, ORCH);
+    expect(state.ok).toBe(true);
+
+    const toQa = await kernel.invoke(
+      'feature.state_patch',
+      {
+        feature_id: 'feature_merge',
+        expected_version: state.data.front_matter.version,
+        patch: {
+          front_matter: {
+            status: STATUS.QA
+          }
+        }
+      },
+      ORCH
+    );
+    expect(toQa.ok).toBe(true);
+
+    const toReady = await kernel.invoke(
+      'feature.state_patch',
+      {
+        feature_id: 'feature_merge',
+        expected_version: toQa.data.version,
+        patch: {
+          front_matter: {
+            status: STATUS.READY_TO_MERGE
+          }
+        }
+      },
+      ORCH
+    );
+    expect(toReady.ok).toBe(true);
+
+    const missingGatePass = await kernel.invoke(
+      'feature.ready_to_merge',
+      {
+        feature_id: 'feature_merge',
+        commit_message: 'feat: merge',
+        merge_strategy: 'merge_commit',
+        user_approval_token: 'approved'
+      },
+      ORCH
+    );
+    expect(missingGatePass.ok).toBe(false);
+    expect(missingGatePass.error.code).toBe(ERROR_CODES.MERGE_DISABLED);
+  });
+});