agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -4,7 +4,7 @@ import {
   getUnresolvedDeps,
   detectCircularDependency,
   addToDepBlocked,
-  resolveDepBlocked
+  resolveDepBlocked,
 } from '../src/application/services/dependency-scheduler-service.js';
 import { makeTempRepo, writeFeatureSpec } from './helpers.js';
 
@@ -56,20 +56,27 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
     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'] }]);
+      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'] }] };
+      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[] }>;
+      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'] }]
+        dep_blocked: [{ feature_id: 'feat-child', depends_on_unresolved: ['feat-parent'] }],
       };
       const promoted = resolveDepBlocked(index, 'feat-parent');
       expect(promoted).toEqual(['feat-child']);
@@ -78,11 +85,14 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
 
     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'] }]
+        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[] }>;
+      const entries = index.dep_blocked as Array<{
+        feature_id: string;
+        depends_on_unresolved: string[];
+      }>;
       expect(entries[0].depends_on_unresolved).toEqual(['feat-b']);
     });
   });
@@ -98,7 +108,7 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
       files: { create: [], modify: [], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'none' },
       acceptance_criteria: ['works'],
-      gate_profile: 'default'
+      gate_profile: 'default',
     });
 
     it('rejects plan when dependency is not merged', async () => {
@@ -111,12 +121,18 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
 
       // 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'] }
+        frontMatter: { ...fm, depends_on: ['feat-parent'] },
       }));
 
-      const result = await kernel.invoke('plan.submit', { feature_id: 'feat-child', plan_json: validPlan('feat-child') }, ORCH_CTX);
+      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');
+      expect((result as { ok: false; error: { code: string } }).error.code).toBe(
+        'dependency_unresolved',
+      );
     });
 
     it('accepts plan when dependency is already merged', async () => {
@@ -129,17 +145,21 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
 
       // Mark feat-merged-dep as merged directly in index
       await kernel.withIndexLock(async () => {
-        const idx = await kernel.readIndex() as Record<string, unknown>;
+        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'] }
+        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);
+      const result = await kernel.invoke(
+        'plan.submit',
+        { feature_id: 'feat-child2', plan_json: validPlan('feat-child2') },
+        ORCH_CTX,
+      );
       expect(result.ok).toBe(true);
     });
 
@@ -152,13 +172,20 @@ describe('N4: Dependency-Aware Feature Scheduling', () => {
       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'] }
+        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[] }>;
+      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);
     });
   });
@@ -178,7 +205,7 @@ describe('DependencySchedulerService branch coverage', () => {
   });
 
   it('GIVEN_cycle_with_only_one_node_self_referencing_WHEN_detectCircular_called_THEN_detects_cycle', () => {
-    const result = detectCircularDependency('self', (id) => id === 'self' ? ['self'] : []);
+    const result = detectCircularDependency('self', (id) => (id === 'self' ? ['self'] : []));
     expect(result).not.toBeNull();
   });
 

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

@@ -19,7 +19,7 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
     expect(result.data.runtime_sessions.orchestrator_epoch).toBe(0);
@@ -33,7 +33,7 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
     const renewResult = await kernel.renewRunLease('test-run-2', 'test-owner-2');
@@ -50,14 +50,14 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
     await kernel.updateOrchestratorSession({
       run_id: 'test-run-3',
       owner_instance_id: 'test-owner-3',
       orchestrator_session_id: 'new-orch-session-1',
-      increment_epoch: true
+      increment_epoch: true,
     });
 
     const sessions = await kernel.getRuntimeSessions();
@@ -71,14 +71,14 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
     await kernel.updateOrchestratorSession({
       run_id: 'test-run-4',
       owner_instance_id: 'test-owner-4',
       orchestrator_session_id: 'new-orch-session-2',
-      increment_epoch: false
+      increment_epoch: false,
     });
 
     const sessions = await kernel.getRuntimeSessions();
@@ -92,14 +92,14 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
     await kernel.updateOrchestratorSession({
       run_id: 'test-run-5',
       owner_instance_id: 'test-owner-5a',
       orchestrator_session_id: 'orch-session-5',
-      increment_epoch: true
+      increment_epoch: true,
     });
 
     const lease = await kernel.readRunLease();
@@ -112,7 +112,7 @@ describe('Orchestrator Epoch Tracking and Recovery', () => {
       provider: 'custom',
       model: 'test-model',
       provider_config_ref_hash: 'hash123',
-      takeover_stale_run: true
+      takeover_stale_run: true,
     });
 
     expect(takeoverResult.data.took_over_stale).toBe(true);

package/apps/control-plane/test/feature-deletion-service.spec.ts

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('../src/core/git.js', () => ({
-  runGit: vi.fn()
+  runGit: vi.fn(),
 }));
 
 import { runGit } from '../src/core/git.js';
@@ -13,13 +13,15 @@ import type { FeatureDeletionServicePort } from '../src/application/services/fea
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
 
-function commandResult(overrides: Partial<{
-  code: number;
-  signal: NodeJS.Signals | null;
-  stdout: string;
-  stderr: string;
-  timeout: boolean;
-}> = {}) {
+function commandResult(
+  overrides: Partial<{
+    code: number;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    timeout: boolean;
+  }> = {},
+) {
   return { code: 0, signal: null, stdout: '', stderr: '', timeout: false, ...overrides };
 }
 
@@ -36,7 +38,7 @@ function makeStaleRunLease(): RuntimeSessionsSnapshot {
     started_at: now,
     last_heartbeat_at: now,
     lease_expires_at: now,
-    feature_sessions: {}
+    feature_sessions: {},
   };
 }
 
@@ -75,31 +77,36 @@ describe('FeatureDeletionService git failure paths', () => {
         locks: {},
         lock_leases: {},
         blocked_queue: [],
-        updated_at: new Date().toISOString()
+        updated_at: new Date().toISOString(),
       })),
       writeIndex: vi.fn(async () => {}),
       readRunLease: vi.fn(async () => ({ ...staleRunLease })),
       writeRunLease: vi.fn(async () => {}),
       normalizeRuntimeSessions: vi.fn(() => staleRunLease),
       isRunLeaseFresh: vi.fn(() => false),
-      locksRelease: vi.fn(async () => {})
+      locksRelease: vi.fn(async () => {}),
     };
   }
 
   it('GIVEN_worktree_exists_WHEN_runGit_worktree_remove_fails_THEN_throws_GIT_FAILURE', async () => {
     vi.mocked(runGit)
-      .mockResolvedValueOnce(commandResult({ code: 1 }))                          // show-ref → no branch
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // show-ref → no branch
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'not a worktree' })); // worktree remove fails
 
     const service = new FeatureDeletionService(makeMockPort());
 
     await expect(
-      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeWorktree: true, removeBranch: 'none' })
+      service.featureDelete('feature_x', {
+        dryRun: false,
+        confirm: true,
+        removeWorktree: true,
+        removeBranch: 'none',
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE }),
+      }),
     });
   });
 
@@ -114,7 +121,7 @@ describe('FeatureDeletionService git failure paths', () => {
       dryRun: false,
       confirm: true,
       removeWorktree: false,
-      removeBranch: 'safe'
+      removeBranch: 'safe',
     });
 
     expect(result.data.summary.branch_removed).toBe(true);
@@ -123,18 +130,23 @@ describe('FeatureDeletionService git failure paths', () => {
 
   it('GIVEN_branch_exists_WHEN_runGit_branch_remove_fails_THEN_throws_GIT_FAILURE', async () => {
     vi.mocked(runGit)
-      .mockResolvedValueOnce(commandResult({ code: 0 }))                           // show-ref → branch exists
+      .mockResolvedValueOnce(commandResult({ code: 0 })) // show-ref → branch exists
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'branch not merged' })); // branch -d fails
 
     const service = new FeatureDeletionService(makeMockPort());
 
     await expect(
-      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeWorktree: false, removeBranch: 'safe' })
+      service.featureDelete('feature_x', {
+        dryRun: false,
+        confirm: true,
+        removeWorktree: false,
+        removeBranch: 'safe',
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.GIT_FAILURE }),
+      }),
     });
   });
 
@@ -149,7 +161,7 @@ describe('FeatureDeletionService git failure paths', () => {
       dryRun: false,
       confirm: true,
       removeWorktree: false,
-      removeBranch: 'force'
+      removeBranch: 'force',
     });
 
     expect(result.data.summary.branch_removed).toBe(true);
@@ -192,40 +204,36 @@ describe('FeatureDeletionService input validation paths', () => {
         locks: {},
         lock_leases: {},
         blocked_queue: [],
-        updated_at: new Date().toISOString()
+        updated_at: new Date().toISOString(),
       })),
       writeIndex: vi.fn(async () => {}),
       readRunLease: vi.fn(async () => ({ ...staleRunLease })),
       writeRunLease: vi.fn(async () => {}),
       normalizeRuntimeSessions: vi.fn(() => staleRunLease),
       isRunLeaseFresh: vi.fn(() => false),
-      locksRelease: vi.fn(async () => {})
+      locksRelease: vi.fn(async () => {}),
     };
   }
 
   it('GIVEN_null_feature_id_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
     const service = new FeatureDeletionService(makeMockPort());
 
-    await expect(
-      service.featureDelete(null)
-    ).rejects.toMatchObject({
+    await expect(service.featureDelete(null)).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+      }),
     });
   });
 
   it('GIVEN_invalid_feature_id_format_WHEN_featureDelete_called_THEN_throws_INVALID_ARGUMENT', async () => {
     const service = new FeatureDeletionService(makeMockPort());
 
-    await expect(
-      service.featureDelete('INVALID FEATURE ID!')
-    ).rejects.toMatchObject({
+    await expect(service.featureDelete('INVALID FEATURE ID!')).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+      }),
     });
   });
 
@@ -233,12 +241,12 @@ describe('FeatureDeletionService input validation paths', () => {
     const service = new FeatureDeletionService(makeMockPort());
 
     await expect(
-      service.featureDelete('feature_x', { removeBranch: 'invalid-mode' })
+      service.featureDelete('feature_x', { removeBranch: 'invalid-mode' }),
     ).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+      }),
     });
   });
 
@@ -246,12 +254,12 @@ describe('FeatureDeletionService input validation paths', () => {
     const service = new FeatureDeletionService(makeMockPort());
 
     await expect(
-      service.featureDelete('feature_x', { dryRun: false, confirm: false, removeBranch: 'none' })
+      service.featureDelete('feature_x', { dryRun: false, confirm: false, removeBranch: 'none' }),
     ).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+      }),
     });
   });
 
@@ -282,7 +290,7 @@ describe('FeatureDeletionService input validation paths', () => {
       started_at: now,
       last_heartbeat_at: now,
       lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
-      feature_sessions: {}
+      feature_sessions: {},
     };
 
     const port = makeMockPort();
@@ -292,12 +300,12 @@ describe('FeatureDeletionService input validation paths', () => {
     const service = new FeatureDeletionService(port);
 
     await expect(
-      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeBranch: 'none' })
+      service.featureDelete('feature_x', { dryRun: false, confirm: true, removeBranch: 'none' }),
     ).rejects.toMatchObject({
       normalizedResponse: expect.objectContaining({
         ok: false,
-        error: expect.objectContaining({ code: ERROR_CODES.RUN_ALREADY_ACTIVE })
-      })
+        error: expect.objectContaining({ code: ERROR_CODES.RUN_ALREADY_ACTIVE }),
+      }),
     });
   });
 
@@ -310,7 +318,7 @@ describe('FeatureDeletionService input validation paths', () => {
       dryRun: false,
       confirm: true,
       removeWorktree: false,
-      removeBranch: 'none'
+      removeBranch: 'none',
     });
 
     expect(result.data.dry_run).toBe(false);
@@ -354,17 +362,17 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
         merged: [],
         locks: {},
         lock_leases: {
-          openapi: { holder: 'feature_lock_lease', expires_at: new Date().toISOString() }
+          openapi: { holder: 'feature_lock_lease', expires_at: new Date().toISOString() },
         },
         blocked_queue: [],
-        updated_at: new Date().toISOString()
+        updated_at: new Date().toISOString(),
       })),
       writeIndex: vi.fn(async () => {}),
       readRunLease: vi.fn(async () => ({ ...staleRunLease })),
       writeRunLease: vi.fn(async () => {}),
       normalizeRuntimeSessions: vi.fn(() => staleRunLease),
       isRunLeaseFresh: vi.fn(() => false),
-      locksRelease: vi.fn(async () => {})
+      locksRelease: vi.fn(async () => {}),
     };
 
     const service = new FeatureDeletionService(port);
@@ -372,7 +380,7 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
       dryRun: false,
       confirm: true,
       removeWorktree: false,
-      removeBranch: 'none'
+      removeBranch: 'none',
     });
 
     expect(result.data.summary.locks_released).toContain('openapi');
@@ -383,7 +391,7 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
 
     const staleRunLease = {
       ...makeStaleRunLease(),
-      feature_sessions: undefined as unknown as Record<string, unknown>
+      feature_sessions: undefined as unknown as Record<string, unknown>,
     };
     const port = {
       getRepoRoot: () => repoRoot,
@@ -400,14 +408,14 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
         locks: {},
         lock_leases: {},
         blocked_queue: [],
-        updated_at: new Date().toISOString()
+        updated_at: new Date().toISOString(),
       })),
       writeIndex: vi.fn(async () => {}),
       readRunLease: vi.fn(async () => ({ ...staleRunLease })),
       writeRunLease: vi.fn(async () => {}),
       normalizeRuntimeSessions: vi.fn(() => ({ ...staleRunLease })),
       isRunLeaseFresh: vi.fn(() => false),
-      locksRelease: vi.fn(async () => {})
+      locksRelease: vi.fn(async () => {}),
     };
 
     const service = new FeatureDeletionService(port as unknown as FeatureDeletionServicePort);
@@ -415,7 +423,7 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
       dryRun: false,
       confirm: true,
       removeWorktree: false,
-      removeBranch: 'none'
+      removeBranch: 'none',
     });
 
     expect(result.data.summary.runtime_session_assignment_removed).toBe(false);