agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,390 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('../src/providers/providers.js', () => ({
+  resolveProviderSelection: vi.fn(() => ({ provider: 'null', model: 'none', provider_config_ref: null })),
+  NullWorkerProvider: vi.fn().mockImplementation(() => ({
+    selection: { provider: 'null', model: 'none', provider_config_ref: null },
+    createSession: vi.fn(async () => ({ session_id: 'mock-session' })),
+    reattachSession: vi.fn(async () => null),
+    closeSession: vi.fn(async () => ({}))
+  }))
+}));
+
+vi.mock('../src/supervisor/runtime.js', () => ({
+  SupervisorRuntime: vi.fn().mockImplementation(() => ({
+    start: vi.fn(async (features: unknown[]) => ({
+      queue_depth: features.length,
+      status: 'running',
+      run_metadata: {},
+      dashboard: null
+    }))
+  }))
+}));
+
+import { ResumeCommandHandler } from '../src/cli/resume-command-handler.js';
+import { STATUS } from '../src/core/constants.js';
+
+function makeKernel(overrides: Record<string, unknown> = {}) {
+  return {
+    recoverFromState: vi.fn(async () => ({ data: { recovered: false } })),
+    readIndex: vi.fn(async () => ({ active: [], blocked: [], blocked_queue: [] })),
+    getRuntimeSessions: vi.fn(async () => ({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      orchestrator_session_id: 'unknown',
+      orchestrator_epoch: 0,
+      feature_sessions: {}
+    })),
+    featureDiscoverSpecs: vi.fn(async () => ({ data: { specs: [] } })),
+    featureStateGet: vi.fn(async () => ({
+      data: { front_matter: { status: STATUS.PLANNING } }
+    })),
+    getAgentsConfig: vi.fn(() => ({ roles: {} })),
+    getPolicySnapshot: vi.fn(() => ({})),
+    ...overrides
+  };
+}
+
+function makeContext(kernel: ReturnType<typeof makeKernel>, toolClientOverride?: Record<string, unknown>) {
+  return {
+    repoRoot: '/tmp/repo',
+    env: process.env,
+    runId: 'fallback-run-id',
+    transport: 'stdio' as const,
+    options: {} as any,
+    kernel: kernel as any,
+    toolClient: (toolClientOverride ?? { call: vi.fn(async () => ({ ok: true, data: {} })) }) as any
+  };
+}
+
+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;
+
+    expect(result.ok).toBe(true);
+    expect(result.data.resumed).toBe(false);
+    expect(result.data.command).toBe('resume');
+  });
+
+  it('GIVEN_runtime_sessions_with_run_id_WHEN_execute_THEN_uses_session_run_id', async () => {
+    const kernel = makeKernel({
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'session-run-123',
+        owner_instance_id: 'owner-abc',
+        orchestrator_session_id: 'unknown',
+        orchestrator_epoch: 0,
+        feature_sessions: {}
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    const result = await handler.execute(makeContext(kernel)) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.data.resumed).toBe(false);
+  });
+
+  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: [] })),
+      featureStateGet: vi.fn(async (_fid: string) => ({
+        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;
+
+    // Both features at BUILDING phase → sort by localeCompare; supervisor mock returns ok
+    expect(result.ok).toBe(true);
+    expect(result.data.resumed).toBe(true);
+    expect(result.data.resumed_features[0].feature_id).toBe('feature_a');
+    expect(result.data.resumed_features[1].feature_id).toBe('feature_b');
+  });
+
+  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: [] })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.MERGED } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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
+  });
+
+  it('GIVEN_empty_feature_id_in_blocked_queue_WHEN_addSource_called_THEN_guards_and_skips', async () => {
+    // Exercises addSource's `if (!featureId) return` guard
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({
+        active: [],
+        blocked: [],
+        blocked_queue: [
+          { feature_id: '' },   // empty → guarded
+          { feature_id: null }, // not string → skipped
+          { feature_id: 'valid-feature' }
+        ]
+      })),
+      featureStateGet: vi.fn(async () => ({
+        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;
+
+    expect(result.ok).toBe(true);
+  });
+
+  it('GIVEN_feature_id_added_from_multiple_sources_WHEN_addSource_called_THEN_merges_sources', async () => {
+    // Exercises `existing.add(source)` branch in addSource when same featureId appears in multiple sources
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({
+        active: ['shared-feature'],
+        blocked: ['shared-feature'], // same ID in both active and blocked
+        blocked_queue: []
+      })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.PLANNING } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    const result = await handler.execute(makeContext(kernel)) as any;
+
+    expect(result.ok).toBe(true);
+    // 'shared-feature' appears in both sources, addSource should merge them
+  });
+
+  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'); })
+    });
+    const handler = new ResumeCommandHandler();
+    const result = await handler.execute(makeContext(kernel)) as any;
+
+    expect(result.ok).toBe(true);
+    expect(result.data.resumed).toBe(false);
+  });
+
+  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' }] }
+      })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.QA } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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)
+  });
+
+  it('GIVEN_feature_sessions_in_runtime_WHEN_buildResumePlan_THEN_includes_session_features', async () => {
+    const kernel = makeKernel({
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run-abc',
+        owner_instance_id: 'owner-def',
+        orchestrator_session_id: 'sess-1',
+        orchestrator_epoch: 1,
+        feature_sessions: { 'session-feature': { planner: 's1' } }
+      })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.PLANNING } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    const result = await handler.execute(makeContext(kernel)) as any;
+
+    expect(result.ok).toBe(true);
+  });
+});
+
+describe('ResumeCommandHandler additional branches', () => {
+  it('GIVEN_feature_with_READY_TO_MERGE_status_WHEN_buildResumePlan_THEN_phase_is_READY_TO_MERGE', async () => {
+    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 } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+  });
+
+  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: [] })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.FAILED } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+  });
+
+  it('GIVEN_runtime_sessions_with_real_run_id_WHEN_execute_THEN_uses_session_run_id_and_owner', async () => {
+    const kernel = makeKernel({
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:real-session',
+        owner_instance_id: 'owner:real',
+        orchestrator_session_id: 'orch-sess',
+        orchestrator_epoch: 1,
+        feature_sessions: {}
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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');
+  });
+
+  it('GIVEN_feature_with_READY_TO_MERGE_status_WHEN_buildResumePlan_THEN_phase_is_ready_to_merge', async () => {
+    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 } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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');
+    expect(feature?.resume_phase).toBe(STATUS.READY_TO_MERGE);
+  });
+
+  it('GIVEN_feature_with_unknown_status_WHEN_buildResumePlan_THEN_phase_is_planning', async () => {
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({ active: ['feature_unk'], blocked: [], blocked_queue: [] })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: 'some_unknown_status' } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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');
+    expect(feature?.resume_phase).toBe(STATUS.PLANNING);
+  });
+
+  it('GIVEN_index_active_is_not_array_WHEN_buildResumePlan_THEN_asStringArray_returns_empty', async () => {
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({ active: null, blocked: 42, blocked_queue: [] })),
+    });
+    const handler = new ResumeCommandHandler();
+    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: [] })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.PLANNING } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+    expect(features.some((f: any) => typeof f.feature_id !== 'string')).toBe(false);
+  });
+
+  it('GIVEN_feature_sessions_with_empty_feature_id_WHEN_buildResumePlan_THEN_empty_id_skipped', async () => {
+    const kernel = makeKernel({
+      readIndex: vi.fn(async () => ({
+        active: [],
+        blocked: [],
+        blocked_queue: [{ feature_id: '' }, { feature_id: 'valid_feature' }]
+      })),
+      featureStateGet: vi.fn(async () => ({
+        data: { front_matter: { status: STATUS.PLANNING } }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+    expect(features.some((f: any) => f.feature_id === '')).toBe(false);
+  });
+});
+
+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: [] })),
+      featureStateGet: vi.fn(async (featureId: string) => ({
+        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;
+    expect(result.ok).toBe(true);
+    const features = result.data.resumed_features ?? [];
+    expect(features.length).toBe(2);
+    expect(features.some((f: any) => f.resume_phase === STATUS.READY_TO_MERGE)).toBe(true);
+  });
+
+  it('GIVEN_feature_sessions_with_empty_key_WHEN_execute_THEN_addSource_empty_featureId_guard', async () => {
+    const kernel = makeKernel({
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'none',
+        owner_instance_id: 'none',
+        orchestrator_session_id: 'unknown',
+        orchestrator_epoch: 0,
+        feature_sessions: { '': 'session-x' }
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+  });
+
+  it('GIVEN_feature_sessions_null_WHEN_execute_THEN_asRecord_returns_empty_object', async () => {
+    const kernel = makeKernel({
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'none',
+        owner_instance_id: 'none',
+        orchestrator_session_id: 'unknown',
+        orchestrator_epoch: 0,
+        feature_sessions: null
+      }))
+    });
+    const handler = new ResumeCommandHandler();
+    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 }] }))
+    });
+    const handler = new ResumeCommandHandler();
+    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);
+  });
+});