agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,247 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const resolveProjectRootMock = vi.hoisted(() => vi.fn(async () => '/tmp'));
+const readDashboardStatusMock = vi.hoisted(() =>
+  vi.fn(async () => ({ index: { active: [], blocked: [], merged: [], blocked_queue: [] }, features: [] }))
+);
+const readFeatureStateMock = vi.hoisted(() => vi.fn(async () => null));
+const getAopRootMock = vi.hoisted(() => vi.fn(() => process.cwd()));
+const approveFeatureReviewMock = vi.hoisted(() => vi.fn(async () => ({ ok: true, data: { merged: true } })));
+const denyFeatureReviewMock = vi.hoisted(() => vi.fn(async () => ({ ok: true, data: { blocked: true } })));
+const requestFeatureChangesMock = vi.hoisted(() =>
+  vi.fn(async () => ({ ok: true, data: { delivered: true } }))
+);
+const execFileMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../../../packages/web-dashboard/src/lib/aop-client.js', () => ({
+  resolveProjectRoot: resolveProjectRootMock,
+  readDashboardStatus: readDashboardStatusMock,
+  readFeatureState: readFeatureStateMock,
+  getAopRoot: getAopRootMock
+}));
+
+vi.mock('../../../packages/web-dashboard/src/lib/orchestrator-tools.js', () => ({
+  approveFeatureReview: approveFeatureReviewMock,
+  denyFeatureReview: denyFeatureReviewMock,
+  requestFeatureChanges: requestFeatureChangesMock
+}));
+
+vi.mock('node:child_process', () => ({
+  execFile: (...args: unknown[]) => {
+    const callback = args[args.length - 1] as (err: null | Error, result?: { stdout: string; stderr: string }) => void;
+    const call = execFileMock(...args.slice(0, -1)) as Promise<{ stdout: string; stderr: string }>;
+    void call.then(
+      (result) => callback(null, result),
+      (error: Error) => callback(error)
+    );
+  }
+}));
+
+import { POST as actionsPost } from '../../../packages/web-dashboard/src/app/api/actions/route.js';
+import { POST as checkoutPost } from '../../../packages/web-dashboard/src/app/api/features/[id]/checkout/route.js';
+import { GET as statusGet } from '../../../packages/web-dashboard/src/app/api/status/route.js';
+import { GET as projectsGet } from '../../../packages/web-dashboard/src/app/api/projects/route.js';
+
+describe('dashboard api integration', () => {
+  let repoRoot: string;
+
+  beforeEach(async () => {
+    repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dashboard-api-'));
+    await fs.mkdir(path.join(repoRoot, '.git'), { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.aop', 'runtime'), { recursive: true });
+    await fs.mkdir(path.join(repoRoot, '.worktrees', 'feature_checkout'), { recursive: true });
+
+    resolveProjectRootMock.mockReset();
+    readDashboardStatusMock.mockReset();
+    readFeatureStateMock.mockReset();
+    getAopRootMock.mockReset();
+    approveFeatureReviewMock.mockReset();
+    denyFeatureReviewMock.mockReset();
+    requestFeatureChangesMock.mockReset();
+    execFileMock.mockReset();
+
+    resolveProjectRootMock.mockResolvedValue(repoRoot);
+    getAopRootMock.mockReturnValue(repoRoot);
+    readDashboardStatusMock.mockResolvedValue({
+      index: { active: ['feature_checkout'], blocked: [], merged: [], blocked_queue: [] },
+      features: [
+        {
+          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'),
+          pr: null
+        }
+      ]
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
+
+  it('GIVEN_review_approve_action_WHEN_posted_THEN_routes_to_feature_ready_to_merge', async () => {
+    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'
+        })
+      })
+    );
+
+    expect(response.status).toBe(200);
+    expect(approveFeatureReviewMock).toHaveBeenCalledWith(
+      'feature_checkout',
+      'approved',
+      'merge_commit',
+      undefined,
+      repoRoot
+    );
+  });
+
+  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', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.request_changes',
+          feature_id: 'feature_checkout',
+          message: 'Please address CI failures'
+        })
+      })
+    );
+
+    expect(response.status).toBe(200);
+    expect(requestFeatureChangesMock).toHaveBeenCalledWith('feature_checkout', 'Please address CI failures', repoRoot);
+  });
+
+  it('GIVEN_review_deny_without_reason_WHEN_posted_THEN_returns_400', async () => {
+    const response = await actionsPost(
+      new Request('http://localhost/api/actions', {
+        method: 'POST',
+        body: JSON.stringify({
+          action: 'review.deny',
+          feature_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('reason_required');
+  });
+
+  it('GIVEN_checkout_then_restore_WHEN_feature_branch_exists_THEN_persists_and_restores_checkout_record', async () => {
+    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'),
+      pr: null
+    });
+
+    execFileMock.mockImplementation(async (_file: string, args: string[]) => {
+      const command = args.join(' ');
+      if (command.startsWith('show-ref --verify --quiet refs/heads/feature/feature_checkout')) {
+        return { stdout: '', stderr: '' };
+      }
+      if (command === 'status --porcelain') {
+        return { stdout: '', stderr: '' };
+      }
+      if (command === 'rev-parse --abbrev-ref HEAD') {
+        return { stdout: 'main\n', stderr: '' };
+      }
+      if (command === 'checkout feature/feature_checkout') {
+        return { stdout: '', stderr: '' };
+      }
+      if (command === 'checkout main') {
+        return { stdout: '', stderr: '' };
+      }
+      throw new Error(`unexpected git command: ${command}`);
+    });
+
+    const checkoutResponse = await checkoutPost(
+      new Request('http://localhost/api/features/feature_checkout/checkout?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'checkout', stash_changes: false })
+      }),
+      { params: { id: 'feature_checkout' } }
+    );
+    const checkoutBody = (await checkoutResponse.json()) as { ok: boolean; data: { previous_branch: string } };
+    expect(checkoutResponse.status).toBe(200);
+    expect(checkoutBody.ok).toBe(true);
+    expect(checkoutBody.data.previous_branch).toBe('main');
+
+    const restoreRecordPath = path.join(repoRoot, '.aop', 'runtime', 'checkout-restore.json');
+    await expect(fs.access(restoreRecordPath)).resolves.toBeUndefined();
+
+    const restoreResponse = await checkoutPost(
+      new Request('http://localhost/api/features/feature_checkout/checkout?project=alpha', {
+        method: 'POST',
+        body: JSON.stringify({ action: 'restore' })
+      }),
+      { params: { id: 'feature_checkout' } }
+    );
+    const restoreBody = (await restoreResponse.json()) as { ok: boolean; data: { restored_to: string } };
+    expect(restoreResponse.status).toBe(200);
+    expect(restoreBody.ok).toBe(true);
+    expect(restoreBody.data.restored_to).toBe('main');
+    await expect(fs.access(restoreRecordPath)).rejects.toThrow();
+  });
+
+  it('GIVEN_status_query_with_project_WHEN_requested_THEN_uses_project_specific_root', async () => {
+    resolveProjectRootMock.mockResolvedValue(path.join(repoRoot, 'project-beta'));
+
+    const response = await statusGet(new Request('http://localhost/api/status?project=beta'));
+    const body = (await response.json()) as { ok: boolean; data: { features: unknown[] } };
+
+    expect(response.status).toBe(200);
+    expect(body.ok).toBe(true);
+    expect(resolveProjectRootMock).toHaveBeenCalledWith('beta');
+    expect(readDashboardStatusMock).toHaveBeenCalledWith(path.join(repoRoot, 'project-beta'));
+  });
+
+  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');
+    await fs.mkdir(path.join(repoRoot, 'agentic', 'orchestrator', 'schemas'), { recursive: true });
+    await fs.copyFile(
+      path.resolve(import.meta.dirname, '../../../agentic/orchestrator/schemas/multi-project.schema.json'),
+      path.join(repoRoot, 'agentic', 'orchestrator', 'schemas', 'multi-project.schema.json')
+    );
+    await fs.writeFile(
+      path.join(repoRoot, 'agentic', 'orchestrator', 'multi-project.yaml'),
+      [
+        'version: "1.0"',
+        'projects:',
+        `  - name: alpha`,
+        `    path: ${projectAlpha}`,
+        `  - name: beta`,
+        `    path: ${projectBeta}`
+      ].join('\n'),
+      'utf8'
+    );
+
+    const response = await projectsGet();
+    const body = (await response.json()) as {
+      ok: boolean;
+      data: { projects: Array<{ name: string; path: string }> };
+    };
+
+    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]);
+  });
+});

package/apps/control-plane/test/dashboard-client.spec.ts

@@ -0,0 +1,116 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { readDashboardStatus } from '../../../packages/web-dashboard/src/lib/aop-client.js';
+
+async function writeState(repoRoot: string, featureId: string, frontMatter: string): Promise<void> {
+  const featureDir = path.join(repoRoot, '.aop', 'features', featureId);
+  await fs.mkdir(featureDir, { recursive: true });
+  await fs.writeFile(path.join(featureDir, 'state.md'), `---\n${frontMatter}\n---\n`, 'utf8');
+}
+
+describe('dashboard aop client mapping', () => {
+  const tempRoots: string[] = [];
+
+  afterEach(async () => {
+    await Promise.all(tempRoots.map(async (root) => fs.rm(root, { recursive: true, force: true })));
+    tempRoots.length = 0;
+  });
+
+  it('GIVEN_active_feature_with_unknown_status_WHEN_readDashboardStatus_THEN_phase_falls_back_to_planning', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    await fs.mkdir(path.join(repoRoot, '.aop', 'features'), { recursive: true });
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'features', 'index.json'),
+      JSON.stringify({ active: ['feature_a'], blocked: [], merged: [], blocked_queue: [] }),
+      'utf8'
+    );
+    await writeState(
+      repoRoot,
+      'feature_a',
+      [
+        'feature_id: feature_a',
+        'version: 1',
+        'status: unknown_status',
+        'branch: feature_a',
+        'worktree_path: /tmp/worktrees/feature_a',
+        'gate_profile: default',
+        'last_updated: 2026-03-03T00:00:00Z'
+      ].join('\n')
+    );
+
+    const payload = await readDashboardStatus(repoRoot);
+    expect(payload.features).toHaveLength(1);
+    expect(payload.features[0]).toMatchObject({
+      feature_id: 'feature_a',
+      status: 'unknown_status',
+      phase: 'planning'
+    });
+  });
+
+  it('GIVEN_state_with_nested_pr_object_WHEN_readDashboardStatus_THEN_pr_fields_and_merge_score_are_parsed', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    await fs.mkdir(path.join(repoRoot, '.aop', 'features'), { recursive: true });
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'features', 'index.json'),
+      JSON.stringify({ active: ['feature_pr'], blocked: [], merged: [], blocked_queue: [] }),
+      'utf8'
+    );
+    await writeState(
+      repoRoot,
+      'feature_pr',
+      [
+        'feature_id: feature_pr',
+        'version: 1',
+        'status: ready_to_merge',
+        'branch: feature_pr',
+        'worktree_path: /tmp/worktrees/feature_pr',
+        'gate_profile: default',
+        'last_updated: 2026-03-03T00:00:00Z',
+        'pr:',
+        '  number: 42',
+        '  url: https://github.com/org/repo/pull/42',
+        '  ci_status: passing',
+        '  review_decision: approved',
+        '  merge_ready: true',
+        '  pending_review_threads: 0',
+        '  has_conflicts: false',
+        '  merge_score: 100'
+      ].join('\n')
+    );
+
+    const payload = await readDashboardStatus(repoRoot);
+    expect(payload.features[0].pr).toMatchObject({
+      number: 42,
+      ci_status: 'passing',
+      review_decision: 'approved',
+      merge_score: 100
+    });
+  });
+
+  it('GIVEN_blocked_queue_feature_without_state_WHEN_readDashboardStatus_THEN_phase_is_blocked', async () => {
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-dash-client-'));
+    tempRoots.push(repoRoot);
+    await fs.mkdir(path.join(repoRoot, '.aop', 'features'), { recursive: true });
+    await fs.writeFile(
+      path.join(repoRoot, '.aop', 'features', 'index.json'),
+      JSON.stringify({
+        active: [],
+        blocked: [],
+        merged: [],
+        blocked_queue: [{ feature_id: 'feature_q', detected_at: '2026-03-03T00:00:00Z', collision_fingerprint: 'abc' }]
+      }),
+      'utf8'
+    );
+
+    const payload = await readDashboardStatus(repoRoot);
+    expect(payload.features).toHaveLength(1);
+    expect(payload.features[0]).toMatchObject({
+      feature_id: 'feature_q',
+      phase: 'blocked'
+    });
+  });
+});

package/apps/control-plane/test/dashboard-command.spec.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { DashboardCommandHandler } from '../src/cli/dashboard-command-handler.js';
+import type { ChildProcess } from 'node:child_process';
+
+vi.mock('node:child_process', () => ({
+  execFile: vi.fn(),
+  spawn: vi.fn(),
+}));
+
+describe('DashboardCommandHandler', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_foreground_false_WHEN_dashboard_command_THEN_starts_background_process', async () => {
+    const { execFile, spawn } = await import('node:child_process');
+    const mockChild = { unref: vi.fn(), on: vi.fn() } as unknown as ChildProcess;
+    vi.mocked(execFile).mockImplementation((_file, _args, _opts, cb) => {
+      cb?.(null, '', '');
+      return {} as never;
+    });
+    vi.mocked(spawn).mockReturnValue(mockChild);
+
+    const handler = new DashboardCommandHandler();
+    const result = await handler.execute({ port: 3000, foreground: false });
+
+    expect(execFile).toHaveBeenCalledWith(
+      'npm',
+      ['run', '--workspace', '@aop/web-dashboard', 'build'],
+      expect.any(Object),
+      expect.any(Function)
+    );
+    expect(spawn).toHaveBeenCalledWith(
+      'npm',
+      ['run', '--workspace', '@aop/web-dashboard', 'start'],
+      expect.objectContaining({ detached: true })
+    );
+    expect(mockChild.unref).toHaveBeenCalled();
+    expect(result).toMatchObject({ ok: true, data: { port: 3000, background: true, built: true } });
+  });
+
+  it('GIVEN_foreground_true_WHEN_dashboard_command_THEN_runs_in_foreground', async () => {
+    const { spawn } = await import('node:child_process');
+    const mockChild = {
+      on: vi.fn((event: string, cb: () => void) => {
+        if (event === 'close') { setTimeout(cb, 0); }
+        return mockChild;
+      }),
+    } as unknown as ChildProcess;
+    vi.mocked(spawn).mockReturnValue(mockChild);
+
+    const handler = new DashboardCommandHandler();
+    const result = await handler.execute({ foreground: true });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'npm',
+      ['run', '--workspace', '@aop/web-dashboard', 'start'],
+      expect.objectContaining({ stdio: 'inherit' })
+    );
+    expect(result).toMatchObject({ ok: true, data: { port: 3000, mode: 'production' } });
+  });
+
+  it('GIVEN_custom_port_WHEN_dashboard_command_THEN_uses_provided_port', async () => {
+    const { execFile, spawn } = await import('node:child_process');
+    const mockChild = { unref: vi.fn(), on: vi.fn() } as unknown as ChildProcess;
+    vi.mocked(execFile).mockImplementation((_file, _args, _opts, cb) => {
+      cb?.(null, '', '');
+      return {} as never;
+    });
+    vi.mocked(spawn).mockReturnValue(mockChild);
+
+    const handler = new DashboardCommandHandler();
+    const result = await handler.execute({ port: 4000, foreground: false });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'npm',
+      ['run', '--workspace', '@aop/web-dashboard', 'start'],
+      expect.objectContaining({ env: expect.objectContaining({ PORT: '4000' }) })
+    );
+    expect(result).toMatchObject({ ok: true, data: { port: 4000 } });
+  });
+
+  it('GIVEN_dev_mode_WHEN_dashboard_command_THEN_runs_next_dev_in_foreground', async () => {
+    const { spawn } = await import('node:child_process');
+    const mockChild = {
+      on: vi.fn((event: string, cb: () => void) => {
+        if (event === 'close') { setTimeout(cb, 0); }
+        return mockChild;
+      }),
+    } as unknown as ChildProcess;
+    vi.mocked(spawn).mockReturnValue(mockChild);
+
+    const handler = new DashboardCommandHandler();
+    const result = await handler.execute({ dev: true });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'npm',
+      ['run', '--workspace', '@aop/web-dashboard', 'dev'],
+      expect.objectContaining({ stdio: 'inherit' })
+    );
+    expect(result).toMatchObject({ ok: true, data: { mode: 'dev' } });
+  });
+});

package/apps/control-plane/test/dependency-scheduler.spec.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AopKernel } from '../src/index.js';
+import {
+  getUnresolvedDeps,
+  detectCircularDependency,
+  addToDepBlocked,
+  resolveDepBlocked
+} from '../src/application/services/dependency-scheduler-service.js';
+import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+
+let repoRoot: string;
+
+const ORCH_CTX = { actor_type: 'orchestrator', actor_id: 'test' };
+
+beforeEach(async () => {
+  repoRoot = await makeTempRepo(process.cwd());
+});
+
+describe('N4: Dependency-Aware Feature Scheduling', () => {
+  describe('getUnresolvedDeps', () => {
+    it('returns deps not yet merged', () => {
+      expect(getUnresolvedDeps(['feat-a', 'feat-b'], ['feat-a'])).toEqual(['feat-b']);
+    });
+
+    it('returns empty when all deps are merged', () => {
+      expect(getUnresolvedDeps(['feat-a', 'feat-b'], ['feat-a', 'feat-b'])).toEqual([]);
+    });
+
+    it('returns all deps when nothing is merged', () => {
+      expect(getUnresolvedDeps(['feat-a', 'feat-b'], [])).toEqual(['feat-a', 'feat-b']);
+    });
+  });
+
+  describe('detectCircularDependency', () => {
+    it('returns null for linear dependency chain', () => {
+      const deps: Record<string, string[]> = { a: ['b'], b: ['c'], c: [] };
+      expect(detectCircularDependency('a', (id) => deps[id] ?? [])).toBeNull();
+    });
+
+    it('detects a direct cycle', () => {
+      const deps: Record<string, string[]> = { a: ['b'], b: ['a'] };
+      expect(detectCircularDependency('a', (id) => deps[id] ?? [])).not.toBeNull();
+    });
+
+    it('detects an indirect cycle', () => {
+      const deps: Record<string, string[]> = { a: ['b'], b: ['c'], c: ['a'] };
+      expect(detectCircularDependency('a', (id) => deps[id] ?? [])).not.toBeNull();
+    });
+
+    it('returns null for feature with no deps', () => {
+      expect(detectCircularDependency('solo', (_id) => [])).toBeNull();
+    });
+  });
+
+  describe('addToDepBlocked / resolveDepBlocked', () => {
+    it('adds a new dep_blocked entry', () => {
+      const index: Record<string, unknown> = { dep_blocked: [] };
+      addToDepBlocked(index, 'feat-child', ['feat-parent']);
+      expect(index.dep_blocked).toEqual([{ feature_id: 'feat-child', depends_on_unresolved: ['feat-parent'] }]);
+    });
+
+    it('updates existing dep_blocked entry for the same feature', () => {
+      const index: Record<string, unknown> = { dep_blocked: [{ feature_id: 'feat-child', depends_on_unresolved: ['feat-a', 'feat-b'] }] };
+      addToDepBlocked(index, 'feat-child', ['feat-b']);
+      const entries = index.dep_blocked as Array<{ feature_id: string; depends_on_unresolved: string[] }>;
+      expect(entries).toHaveLength(1);
+      expect(entries[0].depends_on_unresolved).toEqual(['feat-b']);
+    });
+
+    it('resolveDepBlocked removes entries that are now fully resolved', () => {
+      const index: Record<string, unknown> = {
+        dep_blocked: [{ feature_id: 'feat-child', depends_on_unresolved: ['feat-parent'] }]
+      };
+      const promoted = resolveDepBlocked(index, 'feat-parent');
+      expect(promoted).toEqual(['feat-child']);
+      expect(index.dep_blocked).toEqual([]);
+    });
+
+    it('resolveDepBlocked reduces unresolved list when multiple deps exist', () => {
+      const index: Record<string, unknown> = {
+        dep_blocked: [{ feature_id: 'feat-child', depends_on_unresolved: ['feat-a', 'feat-b'] }]
+      };
+      const promoted = resolveDepBlocked(index, 'feat-a');
+      expect(promoted).toEqual([]);
+      const entries = index.dep_blocked as Array<{ feature_id: string; depends_on_unresolved: string[] }>;
+      expect(entries[0].depends_on_unresolved).toEqual(['feat-b']);
+    });
+  });
+
+  describe('Kernel integration: plan.submit dependency enforcement', () => {
+    const validPlan = (featureId: string) => ({
+      feature_id: featureId,
+      plan_version: 1,
+      summary: 'test plan',
+      allowed_areas: ['src'],
+      forbidden_areas: [],
+      base_ref: 'HEAD',
+      files: { create: [], modify: [], delete: [] },
+      contracts: { openapi: 'none', events: 'none', db: 'none' },
+      acceptance_criteria: ['works'],
+      gate_profile: 'default'
+    });
+
+    it('rejects plan when dependency is not merged', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-parent');
+      await writeFeatureSpec(repoRoot, 'feat-child');
+      await kernel.invoke('feature.init', { feature_id: 'feat-parent' }, ORCH_CTX);
+      await kernel.invoke('feature.init', { feature_id: 'feat-child' }, ORCH_CTX);
+
+      // Set depends_on in feat-child's state
+      await kernel.updateState('feat-child', null, async (fm: Record<string, unknown>) => ({
+        frontMatter: { ...fm, depends_on: ['feat-parent'] }
+      }));
+
+      const result = await kernel.invoke('plan.submit', { feature_id: 'feat-child', plan_json: validPlan('feat-child') }, ORCH_CTX);
+      expect(result.ok).toBe(false);
+      expect((result as { ok: false; error: { code: string } }).error.code).toBe('dependency_unresolved');
+    });
+
+    it('accepts plan when dependency is already merged', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-merged-dep');
+      await writeFeatureSpec(repoRoot, 'feat-child2');
+      await kernel.invoke('feature.init', { feature_id: 'feat-merged-dep' }, ORCH_CTX);
+      await kernel.invoke('feature.init', { feature_id: 'feat-child2' }, ORCH_CTX);
+
+      // Mark feat-merged-dep as merged directly in index
+      await kernel.withIndexLock(async () => {
+        const idx = await kernel.readIndex() as Record<string, unknown>;
+        idx.merged = [...(Array.isArray(idx.merged) ? idx.merged : []), 'feat-merged-dep'];
+        await kernel.writeIndex(idx);
+      });
+
+      // Set depends_on in feat-child2's state
+      await kernel.updateState('feat-child2', null, async (fm: Record<string, unknown>) => ({
+        frontMatter: { ...fm, depends_on: ['feat-merged-dep'] }
+      }));
+
+      const result = await kernel.invoke('plan.submit', { feature_id: 'feat-child2', plan_json: validPlan('feat-child2') }, ORCH_CTX);
+      expect(result.ok).toBe(true);
+    });
+
+    it('adds feature to dep_blocked in index when dependency is unresolved', async () => {
+      const kernel = new AopKernel(repoRoot);
+      await kernel.ensureLoaded();
+      await writeFeatureSpec(repoRoot, 'feat-blocker');
+      await writeFeatureSpec(repoRoot, 'feat-waiter');
+      await kernel.invoke('feature.init', { feature_id: 'feat-blocker' }, ORCH_CTX);
+      await kernel.invoke('feature.init', { feature_id: 'feat-waiter' }, ORCH_CTX);
+
+      await kernel.updateState('feat-waiter', null, async (fm: Record<string, unknown>) => ({
+        frontMatter: { ...fm, depends_on: ['feat-blocker'] }
+      }));
+
+      await kernel.invoke('plan.submit', { feature_id: 'feat-waiter', plan_json: validPlan('feat-waiter') }, ORCH_CTX);
+
+      const index = await kernel.readIndex() as Record<string, unknown>;
+      const depBlocked = index.dep_blocked as Array<{ feature_id: string; depends_on_unresolved: string[] }>;
+      expect(depBlocked.some((e) => e.feature_id === 'feat-waiter')).toBe(true);
+    });
+  });
+});
+
+describe('DependencySchedulerService branch coverage', () => {
+  it('GIVEN_index_without_dep_blocked_WHEN_addToDepBlocked_called_THEN_creates_new_array', () => {
+    const index: Record<string, unknown> = {};
+    addToDepBlocked(index, 'feat-a', ['dep-1']);
+    expect(index.dep_blocked).toEqual([{ feature_id: 'feat-a', depends_on_unresolved: ['dep-1'] }]);
+  });
+
+  it('GIVEN_index_without_dep_blocked_WHEN_resolveDepBlocked_called_THEN_returns_empty', () => {
+    const index: Record<string, unknown> = {};
+    const promoted = resolveDepBlocked(index, 'some-feature');
+    expect(promoted).toEqual([]);
+  });
+
+  it('GIVEN_cycle_with_only_one_node_self_referencing_WHEN_detectCircular_called_THEN_detects_cycle', () => {
+    const result = detectCircularDependency('self', (id) => id === 'self' ? ['self'] : []);
+    expect(result).not.toBeNull();
+  });
+
+  it('GIVEN_empty_index_merged_WHEN_getUnresolvedDeps_called_THEN_returns_all_deps', () => {
+    const result = getUnresolvedDeps(['dep-a', 'dep-b'], []);
+    expect(result).toEqual(['dep-a', 'dep-b']);
+  });
+});

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { AopKernel } from '../src/core/kernel.js';
+import { AopKernel } from '../src/index.js';
 import { makeTempRepo } from './helpers.js';
 
 describe('Orchestrator Epoch Tracking and Recovery', () => {
@@ -102,9 +102,9 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       increment_epoch: true
     });
 
-    const index = await kernel.readIndex();
-    index.runtime_sessions.lease_expires_at = new Date(Date.now() - 60000).toISOString();
-    await kernel.writeIndex(index);
+    const lease = await kernel.readRunLease();
+    lease.lease_expires_at = new Date(Date.now() - 60000).toISOString();
+    await kernel.writeRunLease(lease);
 
     const takeoverResult = await kernel.acquireRunLease({
       run_id: 'test-run-5-takeover',