agentic-orchestrator 0.1.6 → 0.1.7

package/apps/control-plane/test/cli.unit.spec.ts

@@ -6,72 +6,65 @@ import { ERROR_CODES } from '../src/core/error-codes.js';
 import { STATUS, TOOLS } from '../src/core/constants.js';
 
 const ensureLoadedMock = vi.hoisted(() => vi.fn(async () => undefined));
-const recoverFromStateMock = vi.hoisted(
-  () =>
-    vi.fn(async () => ({
-      data: {
-        recovered: true,
-        stale_features: [] as string[],
-        active: {}
-      }
-    }))
+const recoverFromStateMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    data: {
+      recovered: true,
+      stale_features: [] as string[],
+      active: {},
+    },
+  })),
 );
 const createToolingRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ runtime: 'ok' })));
 const resolveToolClientMock = vi.hoisted(() => vi.fn());
 const toolCallMock = vi.hoisted(() => vi.fn());
-const readIndexMock = vi.hoisted(
-  () =>
-    vi.fn(async () => ({
-      version: 1,
-      active: ['feature_resume'],
-      blocked: [],
-      blocked_queue: []
-    }))
+const readIndexMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    version: 1,
+    active: ['feature_resume'],
+    blocked: [],
+    blocked_queue: [],
+  })),
 );
-const getRuntimeSessionsMock = vi.hoisted(
-  () =>
-    vi.fn(async () => ({
-      run_id: 'run:resume',
-      owner_instance_id: 'owner:resume',
-      feature_sessions: {}
-    }))
+const getRuntimeSessionsMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    run_id: 'run:resume',
+    owner_instance_id: 'owner:resume',
+    feature_sessions: {},
+  })),
 );
-const featureDiscoverSpecsMock = vi.hoisted(
-  () =>
-    vi.fn(async () => ({
-      data: {
-        specs: [{ feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' }]
-      }
-    }))
+const featureDiscoverSpecsMock = vi.hoisted(() =>
+  vi.fn(async () => ({
+    data: {
+      specs: [{ feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' }],
+    },
+  })),
 );
-const featureStateGetMock = vi.hoisted(
-  () =>
-    vi.fn(async (_featureId?: string) => ({
-      data: {
-        front_matter: {
-          status: 'planning'
-        }
-      }
-    }))
+const featureStateGetMock = vi.hoisted(() =>
+  vi.fn(async (_featureId?: string) => ({
+    data: {
+      front_matter: {
+        status: 'planning',
+      },
+    },
+  })),
 );
-const resolveProviderSelectionMock = vi.hoisted(
-  () =>
-    vi.fn(() => ({
-      provider: 'custom',
-      model: 'model',
-      provider_config_env: null,
-      provider_config_ref: null
-    }))
+const resolveProviderSelectionMock = vi.hoisted(() =>
+  vi.fn(() => ({
+    provider: 'custom',
+    model: 'model',
+    provider_config_env: null,
+    provider_config_ref: null,
+  })),
 );
 const supervisorConstructorOptionsMock = vi.hoisted(() => vi.fn());
-const supervisorStartMock = vi.hoisted(
-  () =>
-    vi.fn(async (..._args: unknown[]) => ({
-      queue_depth: 0,
-      status: 'running',
-      run_metadata: { started_at: 'now' } as Record<string, unknown>,
-      dashboard: { features: [] }
-    }))
+const supervisorStartMock = vi.hoisted(() =>
+  vi.fn(async (..._args: unknown[]) => ({
+    queue_depth: 0,
+    status: 'running',
+    run_metadata: { started_at: 'now' } as Record<string, unknown>,
+    dashboard: { features: [] },
+  })),
 );
 
 vi.mock('../src/core/kernel.js', () => {
@@ -126,7 +119,7 @@ vi.mock('../src/core/kernel.js', () => {
 
 vi.mock('../src/mcp/runtime-factory.js', () => ({
   createToolingRuntime: createToolingRuntimeMock,
-  resolveToolClient: resolveToolClientMock
+  resolveToolClient: resolveToolClientMock,
 }));
 
 vi.mock('../src/providers/providers.js', () => ({
@@ -137,19 +130,14 @@ vi.mock('../src/providers/providers.js', () => ({
     constructor(selection: unknown) {
       this.selection = selection;
     }
-  }
+  },
 }));
 
 vi.mock('../src/supervisor/runtime.js', () => {
   class SupervisorRuntime {
     private readonly options: unknown;
 
-    constructor(
-      _kernel: unknown,
-      _provider: unknown,
-      _toolClient: unknown,
-      options: unknown
-    ) {
+    constructor(_kernel: unknown, _provider: unknown, _toolClient: unknown, options: unknown) {
       this.options = options;
       supervisorConstructorOptionsMock(options);
     }
@@ -188,35 +176,37 @@ describe('aop CLI unit', () => {
       data: {
         recovered: true,
         stale_features: [],
-        active: {}
-      }
+        active: {},
+      },
     });
     readIndexMock.mockReset();
     readIndexMock.mockResolvedValue({
       version: 1,
       active: ['feature_resume'],
       blocked: [],
-      blocked_queue: []
+      blocked_queue: [],
     });
     getRuntimeSessionsMock.mockReset();
     getRuntimeSessionsMock.mockResolvedValue({
       run_id: 'run:resume',
       owner_instance_id: 'owner:resume',
-      feature_sessions: {}
+      feature_sessions: {},
     });
     featureDiscoverSpecsMock.mockReset();
     featureDiscoverSpecsMock.mockResolvedValue({
       data: {
-        specs: [{ feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' }]
-      }
+        specs: [
+          { feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' },
+        ],
+      },
     });
     featureStateGetMock.mockReset();
     featureStateGetMock.mockResolvedValue({
       data: {
         front_matter: {
-          status: 'planning'
-        }
-      }
+          status: 'planning',
+        },
+      },
     });
     createToolingRuntimeMock.mockReset();
     createToolingRuntimeMock.mockResolvedValue({ runtime: 'ok' });
@@ -225,7 +215,7 @@ describe('aop CLI unit', () => {
       provider: 'custom',
       model: 'model',
       provider_config_env: null,
-      provider_config_ref: null
+      provider_config_ref: null,
     });
     supervisorConstructorOptionsMock.mockReset();
     supervisorStartMock.mockReset();
@@ -233,7 +223,7 @@ describe('aop CLI unit', () => {
       queue_depth: 0,
       status: 'running',
       run_metadata: { started_at: 'now' },
-      dashboard: { features: [] }
+      dashboard: { features: [] },
     });
     stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
   });
@@ -252,8 +242,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.INVALID_CLI_ARGS
-      }
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+      },
     });
   });
 
@@ -265,8 +255,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.INVALID_CLI_ARGS
-      }
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+      },
     });
   });
 
@@ -280,18 +270,20 @@ describe('aop CLI unit', () => {
     expect(toolCallMock).toHaveBeenCalledWith(
       TOOLS.REPORT_DASHBOARD,
       expect.any(Object),
-      expect.objectContaining({ actor_type: 'system' })
+      expect.objectContaining({ actor_type: 'system' }),
     );
     expect(writes[0]).toMatchObject({ ok: true, data: { healthy: true } });
   });
 
   it('GIVEN_resume_command_WHEN_main_runs_THEN_resumes_non_terminal_features_from_persisted_state', async () => {
-    recoverFromStateMock.mockResolvedValue({ data: { recovered: true, stale_features: ['f1'], active: {} } });
+    recoverFromStateMock.mockResolvedValue({
+      data: { recovered: true, stale_features: ['f1'], active: {} },
+    });
     supervisorStartMock.mockResolvedValue({
       queue_depth: 0,
       status: 'running',
       run_metadata: { resumed: true },
-      dashboard: { features: ['feature_resume'] }
+      dashboard: { features: ['feature_resume'] },
     });
     const code = await main(['resume'], { cwd, env: {} as NodeJS.ProcessEnv });
     const writes = asJsonWrites(stdoutSpy);
@@ -300,7 +292,10 @@ describe('aop CLI unit', () => {
     expect(recoverFromStateMock).toHaveBeenCalledTimes(1);
     expect(featureDiscoverSpecsMock).toHaveBeenCalledTimes(1);
     expect(featureStateGetMock).toHaveBeenCalledWith('feature_resume');
-    expect(supervisorStartMock).toHaveBeenCalledWith([{ feature_id: 'feature_resume' }], expect.any(Object));
+    expect(supervisorStartMock).toHaveBeenCalledWith(
+      [{ feature_id: 'feature_resume' }],
+      expect.any(Object),
+    );
     expect(writes[0]).toMatchObject({
       ok: true,
       data: {
@@ -309,11 +304,11 @@ describe('aop CLI unit', () => {
         resumed_features: [
           expect.objectContaining({
             feature_id: 'feature_resume',
-            resume_phase: 'planning'
-          })
+            resume_phase: 'planning',
+          }),
         ],
-        recovery: { stale_features: ['f1'] }
-      }
+        recovery: { stale_features: ['f1'] },
+      },
     });
   });
 
@@ -324,7 +319,7 @@ describe('aop CLI unit', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { status: 'stop_not_implemented_yet' }
+      data: { status: 'stop_not_implemented_yet' },
     });
   });
 
@@ -336,8 +331,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.INVALID_CLI_ARGS
-      }
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+      },
     });
     expect(toolCallMock).not.toHaveBeenCalled();
   });
@@ -349,11 +344,14 @@ describe('aop CLI unit', () => {
         feature_id: 'feature_delete',
         dry_run: true,
         plan: { feature_dir_exists: true },
-        summary: { feature_dir_removed: false }
-      }
+        summary: { feature_dir_removed: false },
+      },
     });
 
-    const code = await main(['delete', '--feature-id', 'feature_delete'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const code = await main(['delete', '--feature-id', 'feature_delete'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
     const writes = asJsonWrites(stdoutSpy);
 
     expect(code).toBe(0);
@@ -364,17 +362,17 @@ describe('aop CLI unit', () => {
         dry_run: true,
         confirm: false,
         remove_worktree: true,
-        remove_branch: 'none'
+        remove_branch: 'none',
       }),
-      expect.objectContaining({ actor_type: 'system' })
+      expect.objectContaining({ actor_type: 'system' }),
     );
     expect(writes[0]).toMatchObject({
       ok: true,
       data: {
         command: 'delete',
         feature_id: 'feature_delete',
-        dry_run: true
-      }
+        dry_run: true,
+      },
     });
   });
 
@@ -386,8 +384,8 @@ describe('aop CLI unit', () => {
         dry_run: false,
         plan: { feature_dir_exists: true },
         applied: { feature_dir_removed: true },
-        summary: { feature_dir_removed: true }
-      }
+        summary: { feature_dir_removed: true },
+      },
     });
 
     const code = await main(
@@ -399,9 +397,9 @@ describe('aop CLI unit', () => {
         '--remove-worktree',
         'false',
         '--remove-branch',
-        'force'
+        'force',
       ],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
 
     expect(code).toBe(0);
@@ -412,16 +410,16 @@ describe('aop CLI unit', () => {
         dry_run: false,
         confirm: true,
         remove_worktree: false,
-        remove_branch: 'force'
+        remove_branch: 'force',
       }),
-      expect.objectContaining({ actor_type: 'system' })
+      expect.objectContaining({ actor_type: 'system' }),
     );
   });
 
   it('GIVEN_delete_with_invalid_remove_branch_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
     const code = await main(
       ['delete', '--feature-id', 'feature_delete', '--remove-branch', 'hard'],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
     const writes = asJsonWrites(stdoutSpy);
 
@@ -429,8 +427,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.INVALID_CLI_ARGS
-      }
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+      },
     });
     expect(toolCallMock).not.toHaveBeenCalled();
   });
@@ -443,8 +441,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.INPUT_PATH_NOT_FOUND
-      }
+        code: ERROR_CODES.INPUT_PATH_NOT_FOUND,
+      },
     });
   });
 
@@ -457,8 +455,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.NO_SPECS_FOUND
-      }
+        code: ERROR_CODES.NO_SPECS_FOUND,
+      },
     });
   });
 
@@ -476,8 +474,8 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.FEATURE_SLUG_COLLISION
-      }
+        code: ERROR_CODES.FEATURE_SLUG_COLLISION,
+      },
     });
   });
 
@@ -495,32 +493,36 @@ describe('aop CLI unit', () => {
 
     const code = await main(
       ['run', '-fi', path.join('incoming', 'feature_one.md'), '--agent-provider', 'custom'],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
     const writes = asJsonWrites(stdoutSpy);
 
     expect(code).toBe(0);
     expect(supervisorStartMock).toHaveBeenCalledWith(
       [expect.objectContaining({ feature_id: 'feature_one' })],
-      expect.any(Object)
+      expect.any(Object),
     );
     expect(resolveProviderSelectionMock).toHaveBeenCalledTimes(1);
     expect(writes.at(-1)).toMatchObject({
       ok: true,
       data: {
         command: 'run',
-        runtime_status: 'running'
-      }
+        runtime_status: 'running',
+      },
     });
     await expect(
-      fs.stat(path.join(cwd, '.aop', 'features', 'feature_one', 'spec.md'))
+      fs.stat(path.join(cwd, '.aop', 'features', 'feature_one', 'spec.md')),
     ).resolves.toBeTruthy();
   });
 
   it('GIVEN_takeover_flag_WHEN_run_command_THEN_forwards_takeover_option_to_supervisor', async () => {
     const incoming = path.join(cwd, 'incoming');
     await fs.mkdir(incoming, { recursive: true });
-    await fs.writeFile(path.join(incoming, 'feature_takeover.md'), '# Spec\n\nRecover stale run.\n', 'utf8');
+    await fs.writeFile(
+      path.join(incoming, 'feature_takeover.md'),
+      '# Spec\n\nRecover stale run.\n',
+      'utf8',
+    );
 
     toolCallMock.mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
@@ -530,22 +532,33 @@ describe('aop CLI unit', () => {
     });
 
     const code = await main(
-      ['run', '-fi', path.join('incoming', 'feature_takeover.md'), '--agent-provider', 'custom', '--takeover-stale-run'],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      [
+        'run',
+        '-fi',
+        path.join('incoming', 'feature_takeover.md'),
+        '--agent-provider',
+        'custom',
+        '--takeover-stale-run',
+      ],
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
 
     expect(code).toBe(0);
     expect(supervisorConstructorOptionsMock).toHaveBeenCalledWith(
       expect.objectContaining({
-        takeover_stale_run: true
-      })
+        takeover_stale_run: true,
+      }),
     );
   });
 
   it('GIVEN_stale_takeover_contract_WHEN_run_without_and_with_flag_THEN_returns_run_already_active_then_succeeds', async () => {
     const incoming = path.join(cwd, 'incoming');
     await fs.mkdir(incoming, { recursive: true });
-    await fs.writeFile(path.join(incoming, 'feature_stale.md'), '# Spec\n\nHandle takeover.\n', 'utf8');
+    await fs.writeFile(
+      path.join(incoming, 'feature_stale.md'),
+      '# Spec\n\nHandle takeover.\n',
+      'utf8',
+    );
 
     toolCallMock.mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
@@ -554,38 +567,47 @@ describe('aop CLI unit', () => {
       return { ok: true, data: {} };
     });
 
-    supervisorStartMock.mockImplementation(async (_features: Array<{ feature_id: string }>, options?: any) => {
-      if (!options?.takeover_stale_run) {
-        const error = new Error('run_already_active');
-        (error as any).code = ERROR_CODES.RUN_ALREADY_ACTIVE;
-        throw error;
-      }
-      return {
-        queue_depth: 0,
-        status: 'running',
-        run_metadata: { started_at: 'now', took_over_stale: true },
-        dashboard: { features: [] }
-      };
-    });
+    supervisorStartMock.mockImplementation(
+      async (_features: Array<{ feature_id: string }>, options?: any) => {
+        if (!options?.takeover_stale_run) {
+          const error = new Error('run_already_active');
+          (error as any).code = ERROR_CODES.RUN_ALREADY_ACTIVE;
+          throw error;
+        }
+        return {
+          queue_depth: 0,
+          status: 'running',
+          run_metadata: { started_at: 'now', took_over_stale: true },
+          dashboard: { features: [] },
+        };
+      },
+    );
 
     const noTakeoverCode = await main(
       ['run', '-fi', path.join('incoming', 'feature_stale.md'), '--agent-provider', 'custom'],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
     const noTakeoverWrites = asJsonWrites(stdoutSpy);
     expect(noTakeoverCode).toBe(1);
     expect(noTakeoverWrites.at(-1)).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.RUN_ALREADY_ACTIVE
-      }
+        code: ERROR_CODES.RUN_ALREADY_ACTIVE,
+      },
     });
 
     stdoutSpy.mockClear();
 
     const withTakeoverCode = await main(
-      ['run', '-fi', path.join('incoming', 'feature_stale.md'), '--agent-provider', 'custom', '--takeover-stale-run'],
-      { cwd, env: {} as NodeJS.ProcessEnv }
+      [
+        'run',
+        '-fi',
+        path.join('incoming', 'feature_stale.md'),
+        '--agent-provider',
+        'custom',
+        '--takeover-stale-run',
+      ],
+      { cwd, env: {} as NodeJS.ProcessEnv },
     );
     const withTakeoverWrites = asJsonWrites(stdoutSpy);
     expect(withTakeoverCode).toBe(0);
@@ -593,8 +615,8 @@ describe('aop CLI unit', () => {
       ok: true,
       data: {
         command: 'run',
-        runtime_status: 'running'
-      }
+        runtime_status: 'running',
+      },
     });
   });
 
@@ -613,15 +635,18 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({
       ok: false,
       error: {
-        code: ERROR_CODES.NO_SPECS_FOUND
-      }
+        code: ERROR_CODES.NO_SPECS_FOUND,
+      },
     });
   });
 
   it('GIVEN_inprocess_transport_flag_WHEN_status_runs_THEN_uses_inprocess_transport_override', async () => {
     toolCallMock.mockResolvedValue({ ok: true, data: { healthy: true } });
 
-    const code = await main(['status', '--transport', 'inprocess'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const code = await main(['status', '--transport', 'inprocess'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
     const writes = asJsonWrites(stdoutSpy);
 
     expect(code).toBe(0);
@@ -635,8 +660,8 @@ describe('aop CLI unit', () => {
       error: {
         code: ERROR_CODES.INTERNAL_ERROR,
         message: 'tool failure',
-        details: { reason: 'simulated' }
-      }
+        details: { reason: 'simulated' },
+      },
     });
 
     const code = await main(['run'], { cwd, env: {} as NodeJS.ProcessEnv });
@@ -647,8 +672,8 @@ describe('aop CLI unit', () => {
       ok: false,
       error: {
         code: ERROR_CODES.INTERNAL_ERROR,
-        message: 'tool failure'
-      }
+        message: 'tool failure',
+      },
     });
   });
 
@@ -659,7 +684,10 @@ describe('aop CLI unit', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { resumed: true, resumed_features: [expect.objectContaining({ resume_phase: STATUS.BUILDING })] }
+      data: {
+        resumed: true,
+        resumed_features: [expect.objectContaining({ resume_phase: STATUS.BUILDING })],
+      },
     });
   });
 
@@ -670,18 +698,22 @@ describe('aop CLI unit', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { resumed_features: [expect.objectContaining({ resume_phase: STATUS.QA })] }
+      data: { resumed_features: [expect.objectContaining({ resume_phase: STATUS.QA })] },
     });
   });
 
   it('GIVEN_resume_with_READY_TO_MERGE_status_WHEN_main_runs_THEN_resumes_in_ready_to_merge_phase', async () => {
-    featureStateGetMock.mockResolvedValue({ data: { front_matter: { status: STATUS.READY_TO_MERGE } } });
+    featureStateGetMock.mockResolvedValue({
+      data: { front_matter: { status: STATUS.READY_TO_MERGE } },
+    });
     const code = await main(['resume'], { cwd, env: {} as NodeJS.ProcessEnv });
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { resumed_features: [expect.objectContaining({ resume_phase: STATUS.READY_TO_MERGE })] }
+      data: {
+        resumed_features: [expect.objectContaining({ resume_phase: STATUS.READY_TO_MERGE })],
+      },
     });
   });
 
@@ -713,7 +745,7 @@ describe('aop CLI unit', () => {
     getRuntimeSessionsMock.mockResolvedValue({
       run_id: 'run:from-sessions',
       owner_instance_id: 'owner:from-sessions',
-      feature_sessions: { feature_resume: { planner: 'p1', builder: 'b1', qa: 'q1' } }
+      feature_sessions: { feature_resume: { planner: 'p1', builder: 'b1', qa: 'q1' } },
     });
     featureDiscoverSpecsMock.mockResolvedValue({ data: { specs: [] } });
     readIndexMock.mockResolvedValue({ version: 1, active: [], blocked: [], blocked_queue: [] });
@@ -724,7 +756,10 @@ describe('aop CLI unit', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { resumed: true, resumed_features: [expect.objectContaining({ feature_id: 'feature_resume' })] }
+      data: {
+        resumed: true,
+        resumed_features: [expect.objectContaining({ feature_id: 'feature_resume' })],
+      },
     });
   });
 
@@ -733,12 +768,12 @@ describe('aop CLI unit', () => {
       version: 1,
       active: [],
       blocked: [],
-      blocked_queue: [{ feature_id: 'feature_queued' }]
+      blocked_queue: [{ feature_id: 'feature_queued' }],
     });
     getRuntimeSessionsMock.mockResolvedValue({
       run_id: 'none',
       owner_instance_id: 'none',
-      feature_sessions: {}
+      feature_sessions: {},
     });
     featureDiscoverSpecsMock.mockResolvedValue({ data: { specs: [] } });
     featureStateGetMock.mockResolvedValue({ data: { front_matter: { status: STATUS.PLANNING } } });
@@ -754,9 +789,13 @@ describe('aop CLI unit', () => {
       version: 1,
       active: [],
       blocked: ['feature_blocked'],
-      blocked_queue: []
+      blocked_queue: [],
+    });
+    getRuntimeSessionsMock.mockResolvedValue({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      feature_sessions: {},
     });
-    getRuntimeSessionsMock.mockResolvedValue({ run_id: 'none', owner_instance_id: 'none', feature_sessions: {} });
     featureDiscoverSpecsMock.mockResolvedValue({ data: { specs: [] } });
     featureStateGetMock.mockResolvedValue({ data: { front_matter: { status: STATUS.PLANNING } } });
 
@@ -769,9 +808,13 @@ describe('aop CLI unit', () => {
       version: 1,
       active: ['feature_a', 'feature_b'],
       blocked: [],
-      blocked_queue: []
+      blocked_queue: [],
+    });
+    getRuntimeSessionsMock.mockResolvedValue({
+      run_id: 'none',
+      owner_instance_id: 'none',
+      feature_sessions: {},
     });
-    getRuntimeSessionsMock.mockResolvedValue({ run_id: 'none', owner_instance_id: 'none', feature_sessions: {} });
     featureDiscoverSpecsMock.mockResolvedValue({ data: { specs: [] } });
     featureStateGetMock.mockImplementation(async (featureId?: string) => {
       if (featureId === 'feature_a') {
@@ -796,7 +839,10 @@ describe('aop CLI unit', () => {
 
     toolCallMock.mockResolvedValue({ ok: true, data: {} });
 
-    const code = await main(['run', '-fl', 'batch_folder', '--batch'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const code = await main(['run', '-fl', 'batch_folder', '--batch'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({ ok: true, data: { command: 'batch-run', created: 1 } });
@@ -810,14 +856,24 @@ describe('aop CLI unit', () => {
     // Write an index that marks this feature as already active
     const indexDir = path.join(cwd, '.aop', 'features');
     await fs.mkdir(indexDir, { recursive: true });
-    await fs.writeFile(path.join(indexDir, 'index.json'), JSON.stringify({ active: ['existing_feature'] }), 'utf8');
+    await fs.writeFile(
+      path.join(indexDir, 'index.json'),
+      JSON.stringify({ active: ['existing_feature'] }),
+      'utf8',
+    );
 
     toolCallMock.mockResolvedValue({ ok: true, data: {} });
 
-    const code = await main(['run', '-fl', 'batch_folder2', '--batch'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const code = await main(['run', '-fl', 'batch_folder2', '--batch'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
-    expect(writes[0]).toMatchObject({ ok: true, data: { command: 'batch-run', skipped: 1, created: 0 } });
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: { command: 'batch-run', skipped: 1, created: 0 },
+    });
   });
 
   it('GIVEN_batch_mode_with_init_failure_WHEN_run_command_THEN_counts_as_failed', async () => {
@@ -827,7 +883,10 @@ describe('aop CLI unit', () => {
 
     toolCallMock.mockRejectedValue(new Error('init failure'));
 
-    const code = await main(['run', '-fl', 'batch_folder3', '--batch'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const code = await main(['run', '-fl', 'batch_folder3', '--batch'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({ ok: true, data: { command: 'batch-run', failed: 1 } });