agentic-orchestrator 0.1.6 → 0.1.7

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

@@ -1,7 +1,11 @@
 import { describe, it, expect, vi } from 'vitest';
 
 vi.mock('../src/providers/providers.js', () => ({
-  resolveProviderSelection: vi.fn(() => ({ provider: 'null', model: 'none', provider_config_ref: null })),
+  resolveProviderSelection: vi.fn(() => ({
+    provider: 'null',
+    model: 'none',
+    provider_config_ref: null,
+  })),
   NullWorkerProvider: class NullWorkerProvider {
     selection: unknown;
 
@@ -20,7 +24,7 @@ vi.mock('../src/providers/providers.js', () => ({
     async closeSession() {
       return {};
     }
-  }
+  },
 }));
 
 vi.mock('../src/supervisor/runtime.js', () => ({
@@ -30,10 +34,10 @@ vi.mock('../src/supervisor/runtime.js', () => ({
         queue_depth: features.length,
         status: 'running',
         run_metadata: {},
-        dashboard: null
+        dashboard: null,
       };
     }
-  }
+  },
 }));
 
 import { ResumeCommandHandler } from '../src/cli/resume-command-handler.js';
@@ -49,19 +53,22 @@ function makeKernel(overrides: Record<string, unknown> = {}) {
       owner_instance_id: 'none',
       orchestrator_session_id: 'unknown',
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     })),
     featureDiscoverSpecs: vi.fn(async () => ({ data: { specs: [] } })),
     featureStateGet: vi.fn(async () => ({
-      data: { front_matter: { status: STATUS.PLANNING } }
+      data: { front_matter: { status: STATUS.PLANNING } },
     })),
     getAgentsConfig: vi.fn(() => ({ roles: {} })),
     getPolicySnapshot: vi.fn(() => ({})),
-    ...overrides
+    ...overrides,
   };
 }
 
-function makeContext(kernel: ReturnType<typeof makeKernel>, toolClientOverride?: Record<string, unknown>) {
+function makeContext(
+  kernel: ReturnType<typeof makeKernel>,
+  toolClientOverride?: Record<string, unknown>,
+) {
   return {
     repoRoot: '/tmp/repo',
     env: process.env,
@@ -69,7 +76,9 @@ function makeContext(kernel: ReturnType<typeof makeKernel>, toolClientOverride?:
     transport: 'stdio' as unknown as ToolTransport,
     options: {} as any,
     kernel: kernel as any,
-    toolClient: (toolClientOverride ?? { call: vi.fn(async () => ({ ok: true, data: {} })) }) as any
+    toolClient: (toolClientOverride ?? {
+      call: vi.fn(async () => ({ ok: true, data: {} })),
+    }) as any,
   };
 }
 
@@ -77,7 +86,7 @@ describe('ResumeCommandHandler', () => {
   it('GIVEN_no_resumable_features_WHEN_execute_called_THEN_returns_resumed_false', async () => {
     const kernel = makeKernel();
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     expect(result.data.resumed).toBe(false);
@@ -91,11 +100,11 @@ describe('ResumeCommandHandler', () => {
         owner_instance_id: 'owner-abc',
         orchestrator_session_id: 'unknown',
         orchestrator_epoch: 0,
-        feature_sessions: {}
-      }))
+        feature_sessions: {},
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     expect(result.data.resumed).toBe(false);
@@ -104,14 +113,18 @@ describe('ResumeCommandHandler', () => {
   it('GIVEN_two_features_same_phase_WHEN_sorted_THEN_localeCompares_feature_ids', async () => {
     // Exercises the secondary sort (localeCompare on feature_id when phaseDelta === 0)
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: ['feature_b', 'feature_a'], blocked: [], blocked_queue: [] })),
+      readIndex: vi.fn(async () => ({
+        active: ['feature_b', 'feature_a'],
+        blocked: [],
+        blocked_queue: [],
+      })),
       featureStateGet: vi.fn(async (_fid: string) => ({
-        data: { front_matter: { status: STATUS.BUILDING } }
-      }))
+        data: { front_matter: { status: STATUS.BUILDING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
     // Features have non-terminal status, will be returned sorted
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     // Both features at BUILDING phase → sort by localeCompare; supervisor mock returns ok
     expect(result.ok).toBe(true);
@@ -122,13 +135,17 @@ describe('ResumeCommandHandler', () => {
 
   it('GIVEN_feature_with_terminal_status_WHEN_buildResumePlan_THEN_excludes_from_resumable', async () => {
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: ['merged-feature'], blocked: [], blocked_queue: [] })),
+      readIndex: vi.fn(async () => ({
+        active: ['merged-feature'],
+        blocked: [],
+        blocked_queue: [],
+      })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.MERGED } }
-      }))
+        data: { front_matter: { status: STATUS.MERGED } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     expect(result.data.resumed).toBe(false); // Terminal feature excluded, no resumables
@@ -141,18 +158,18 @@ describe('ResumeCommandHandler', () => {
         active: [],
         blocked: [],
         blocked_queue: [
-          { feature_id: '' },   // empty → guarded
+          { feature_id: '' }, // empty → guarded
           { feature_id: null }, // not string → skipped
-          { feature_id: 'valid-feature' }
-        ]
+          { feature_id: 'valid-feature' },
+        ],
       })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.PLANNING } }
-      }))
+        data: { front_matter: { status: STATUS.PLANNING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
     // Should not throw on empty/null feature_ids
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
   });
@@ -163,14 +180,14 @@ describe('ResumeCommandHandler', () => {
       readIndex: vi.fn(async () => ({
         active: ['shared-feature'],
         blocked: ['shared-feature'], // same ID in both active and blocked
-        blocked_queue: []
+        blocked_queue: [],
       })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.PLANNING } }
-      }))
+        data: { front_matter: { status: STATUS.PLANNING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     // 'shared-feature' appears in both sources, addSource should merge them
@@ -179,10 +196,12 @@ describe('ResumeCommandHandler', () => {
   it('GIVEN_feature_state_throws_WHEN_buildResumePlan_THEN_silently_skips_feature', async () => {
     const kernel = makeKernel({
       readIndex: vi.fn(async () => ({ active: ['bad-feature'], blocked: [], blocked_queue: [] })),
-      featureStateGet: vi.fn(async () => { throw new Error('state parse error'); })
+      featureStateGet: vi.fn(async () => {
+        throw new Error('state parse error');
+      }),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     expect(result.data.resumed).toBe(false);
@@ -191,14 +210,14 @@ describe('ResumeCommandHandler', () => {
   it('GIVEN_discovered_specs_WHEN_buildResumePlan_THEN_includes_spec_feature_ids', async () => {
     const kernel = makeKernel({
       featureDiscoverSpecs: vi.fn(async () => ({
-        data: { specs: [{ feature_id: 'spec-feature-1' }] }
+        data: { specs: [{ feature_id: 'spec-feature-1' }] },
       })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.QA } }
-      }))
+        data: { front_matter: { status: STATUS.QA } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
     // spec-feature-1 is non-terminal, will be included (no supervisor to run it)
@@ -211,14 +230,14 @@ describe('ResumeCommandHandler', () => {
         owner_instance_id: 'owner-def',
         orchestrator_session_id: 'sess-1',
         orchestrator_epoch: 1,
-        feature_sessions: { 'session-feature': { planner: 's1' } }
+        feature_sessions: { 'session-feature': { planner: 's1' } },
       })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.PLANNING } }
-      }))
+        data: { front_matter: { status: STATUS.PLANNING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
 
     expect(result.ok).toBe(true);
   });
@@ -229,28 +248,36 @@ describe('ResumeCommandHandler additional branches', () => {
     const kernel = makeKernel({
       readIndex: vi.fn(async () => ({ active: ['feature_rtm'], blocked: [], blocked_queue: [] })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.READY_TO_MERGE } }
-      }))
+        data: { front_matter: { status: STATUS.READY_TO_MERGE } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     // Feature is non-terminal, included → supervisor called → resumed: true
     expect(result.data.resumed).toBe(true);
-    expect(result.data.resumed_features?.some((f: any) => f.resume_phase === STATUS.READY_TO_MERGE)).toBe(true);
+    expect(
+      result.data.resumed_features?.some((f: any) => f.resume_phase === STATUS.READY_TO_MERGE),
+    ).toBe(true);
   });
 
   it('GIVEN_feature_with_FAILED_status_WHEN_buildResumePlan_THEN_feature_excluded_as_terminal', async () => {
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: ['feature_failed'], blocked: [], blocked_queue: [] })),
+      readIndex: vi.fn(async () => ({
+        active: ['feature_failed'],
+        blocked: [],
+        blocked_queue: [],
+      })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.FAILED } }
-      }))
+        data: { front_matter: { status: STATUS.FAILED } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
-    expect(result.data.resume_plan?.features?.some((f: any) => f.feature_id === 'feature_failed')).toBe(false);
+    expect(
+      result.data.resume_plan?.features?.some((f: any) => f.feature_id === 'feature_failed'),
+    ).toBe(false);
   });
 
   it('GIVEN_runtime_sessions_with_real_run_id_WHEN_execute_THEN_uses_session_run_id_and_owner', async () => {
@@ -260,11 +287,11 @@ describe('ResumeCommandHandler additional branches', () => {
         owner_instance_id: 'owner:real',
         orchestrator_session_id: 'orch-sess',
         orchestrator_epoch: 1,
-        feature_sessions: {}
-      }))
+        feature_sessions: {},
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     expect(result.data.resume_plan?.run_id).toBe('run:real-session');
     expect(result.data.resume_plan?.owner_instance_id).toBe('owner:real');
@@ -274,11 +301,11 @@ describe('ResumeCommandHandler additional branches', () => {
     const kernel = makeKernel({
       readIndex: vi.fn(async () => ({ active: ['feature_rtm'], blocked: [], blocked_queue: [] })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.READY_TO_MERGE } }
-      }))
+        data: { front_matter: { status: STATUS.READY_TO_MERGE } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     const feature = features.find((f: any) => f.feature_id === 'feature_rtm');
@@ -289,11 +316,11 @@ describe('ResumeCommandHandler additional branches', () => {
     const kernel = makeKernel({
       readIndex: vi.fn(async () => ({ active: ['feature_unk'], blocked: [], blocked_queue: [] })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: 'some_unknown_status' } }
-      }))
+        data: { front_matter: { status: 'some_unknown_status' } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     const feature = features.find((f: any) => f.feature_id === 'feature_unk');
@@ -305,20 +332,24 @@ describe('ResumeCommandHandler additional branches', () => {
       readIndex: vi.fn(async () => ({ active: null, blocked: 42, blocked_queue: [] })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     expect(result.data.resumed).toBe(false);
   });
 
   it('GIVEN_index_active_with_non_string_items_WHEN_buildResumePlan_THEN_non_string_items_filtered', async () => {
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: [42, null, 'feature_valid', '  '], blocked: [], blocked_queue: [] })),
+      readIndex: vi.fn(async () => ({
+        active: [42, null, 'feature_valid', '  '],
+        blocked: [],
+        blocked_queue: [],
+      })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.PLANNING } }
-      }))
+        data: { front_matter: { status: STATUS.PLANNING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     expect(features.some((f: any) => f.feature_id === 'feature_valid')).toBe(true);
@@ -330,14 +361,14 @@ describe('ResumeCommandHandler additional branches', () => {
       readIndex: vi.fn(async () => ({
         active: [],
         blocked: [],
-        blocked_queue: [{ feature_id: '' }, { feature_id: 'valid_feature' }]
+        blocked_queue: [{ feature_id: '' }, { feature_id: 'valid_feature' }],
       })),
       featureStateGet: vi.fn(async () => ({
-        data: { front_matter: { status: STATUS.PLANNING } }
-      }))
+        data: { front_matter: { status: STATUS.PLANNING } },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     expect(features.some((f: any) => f.feature_id === 'valid_feature')).toBe(true);
@@ -348,13 +379,19 @@ describe('ResumeCommandHandler additional branches', () => {
 describe('ResumeCommandHandler phaseRank and addSource branches', () => {
   it('GIVEN_two_features_one_READY_TO_MERGE_WHEN_execute_THEN_phaseRank_called_with_ready_to_merge', async () => {
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: ['feature_rtm', 'feature_qa'], blocked: [], blocked_queue: [] })),
+      readIndex: vi.fn(async () => ({
+        active: ['feature_rtm', 'feature_qa'],
+        blocked: [],
+        blocked_queue: [],
+      })),
       featureStateGet: vi.fn(async (featureId: string) => ({
-        data: { front_matter: { status: featureId.includes('rtm') ? STATUS.READY_TO_MERGE : STATUS.QA } }
-      }))
+        data: {
+          front_matter: { status: featureId.includes('rtm') ? STATUS.READY_TO_MERGE : STATUS.QA },
+        },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? [];
     expect(features.length).toBe(2);
@@ -368,11 +405,11 @@ describe('ResumeCommandHandler phaseRank and addSource branches', () => {
         owner_instance_id: 'none',
         orchestrator_session_id: 'unknown',
         orchestrator_epoch: 0,
-        feature_sessions: { '': 'session-x' }
-      }))
+        feature_sessions: { '': 'session-x' },
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     expect(features.every((f: any) => f.feature_id !== '')).toBe(true);
@@ -385,20 +422,24 @@ describe('ResumeCommandHandler phaseRank and addSource branches', () => {
         owner_instance_id: 'none',
         orchestrator_session_id: 'unknown',
         orchestrator_epoch: 0,
-        feature_sessions: null
-      }))
+        feature_sessions: null,
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
   });
 
   it('GIVEN_blocked_queue_with_non_string_feature_id_WHEN_execute_THEN_skips_entry', async () => {
     const kernel = makeKernel({
-      readIndex: vi.fn(async () => ({ active: [], blocked: [], blocked_queue: [{ feature_id: 123 }, { feature_id: null }] }))
+      readIndex: vi.fn(async () => ({
+        active: [],
+        blocked: [],
+        blocked_queue: [{ feature_id: 123 }, { feature_id: null }],
+      })),
     });
     const handler = new ResumeCommandHandler();
-    const result = await handler.execute(makeContext(kernel)) as any;
+    const result = (await handler.execute(makeContext(kernel))) as any;
     expect(result.ok).toBe(true);
     const features = result.data.resumed_features ?? result.data.resume_plan?.features ?? [];
     expect(features.length).toBe(0);