agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/supervisor/types.ts

@@ -5,7 +5,7 @@ export type {
   FeatureStateFrontMatter,
   FeatureStatePayload,
   RuntimeRole,
-  ToolCaller as SupervisorToolCaller
+  ToolCaller as SupervisorToolCaller,
 } from '../core/tool-caller.js';
 
 export interface AppError extends Error {
@@ -103,14 +103,29 @@ export interface FeatureOrchestrationPort {
   ensureLoaded(): Promise<void>;
   recoverFromState(): Promise<{ data: Record<string, unknown> }>;
   acquireRunLease(input: AcquireRunLeaseInput): Promise<{ data: { took_over_stale: boolean } }>;
-  updateOrchestratorSession(params: UpdateOrchestratorSessionInput): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }>;
-  updateFeatureSessionAssignment(params: UpdateFeatureSessionAssignmentInput): Promise<{ data: { updated: boolean } }>;
-  pruneFeatureSessionAssignments(params: PruneFeatureSessionAssignmentsInput): Promise<{ data: { removed: string[] } }>;
+  updateOrchestratorSession(
+    params: UpdateOrchestratorSessionInput,
+  ): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }>;
+  updateFeatureSessionAssignment(
+    params: UpdateFeatureSessionAssignmentInput,
+  ): Promise<{ data: { updated: boolean } }>;
+  pruneFeatureSessionAssignments(
+    params: PruneFeatureSessionAssignmentsInput,
+  ): Promise<{ data: { removed: string[] } }>;
   renewLeases(featureIds: string[]): Promise<void>;
-  renewRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { lease_expires_at: string } }>;
+  renewRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { lease_expires_at: string } }>;
   repoDiff(featureId: string, options?: string[]): Promise<{ data: Record<string, unknown> }>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  updateState(featureId: string, expectedVersion: number | null, updater: (fm: Record<string, any>, body: string) => Promise<{ frontMatter?: Record<string, any>; body?: string }>): Promise<Record<string, unknown>>;
+  updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: (
+      fm: Record<string, unknown>,
+      body: string,
+    ) => Promise<{ frontMatter?: Record<string, unknown>; body?: string }>,
+  ): Promise<Record<string, unknown>>;
   checkBudget(featureId: string): Promise<BudgetCheckResult>;
 }
 

package/apps/control-plane/src/supervisor/worker-decision-loop.ts

@@ -62,9 +62,7 @@ function readPlanVersion(value: unknown): number | null {
 function asOutputs(result: Record<string, unknown>): AnyRecord[] {
   const outputs = result.outputs;
   if (Array.isArray(outputs)) {
-    return outputs
-      .map((item) => asRecord(item))
-      .filter((item) => Object.keys(item).length > 0);
+    return outputs.map((item) => asRecord(item)).filter((item) => Object.keys(item).length > 0);
   }
   return [asRecord(result)];
 }
@@ -76,12 +74,12 @@ function makeEmptyResult(): WorkerDecisionResult {
     noteLogged: false,
     requestHandled: false,
     priorityOrder: [],
-    toolResults: []
+    toolResults: [],
   };
 }
 
 export const NOOP_WORKER_DECISION_RUNNER: WorkerDecisionRunner = {
-  execute: () => Promise.resolve(makeEmptyResult())
+  execute: () => Promise.resolve(makeEmptyResult()),
 };
 
 interface WorkerDecisionLoopDependencies {
@@ -116,8 +114,8 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       runtime_selection: {
         provider: this.provider.selection.provider,
         model: this.provider.selection.model,
-        provider_config_ref: this.provider.selection.provider_config_ref
-      }
+        provider_config_ref: this.provider.selection.provider_config_ref,
+      },
     });
 
     const outputs = asOutputs(workerOutput);
@@ -154,7 +152,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
   private async routePlanSubmission(
     input: WorkerDecisionInput,
     output: AnyRecord,
-    result: WorkerDecisionResult
+    result: WorkerDecisionResult,
   ): Promise<void> {
     if (input.role !== 'planner') {
       return;
@@ -172,7 +170,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     if (existingVersion == null) {
       const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_SUBMIT, {
         feature_id: input.featureId,
-        plan_json: planJson
+        plan_json: planJson,
       });
       result.toolResults.push(asRecord(response.data));
       result.planSubmission = true;
@@ -183,13 +181,17 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_UPDATE, {
       feature_id: input.featureId,
       expected_plan_version: expectedPlanVersion,
-      plan_json: planJson
+      plan_json: planJson,
     });
     result.toolResults.push(asRecord(response.data));
     result.planSubmission = true;
   }
 
-  private async routePatch(input: WorkerDecisionInput, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routePatch(
+    input: WorkerDecisionInput,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     if (input.role !== 'builder' && input.role !== 'qa') {
       return;
     }
@@ -201,18 +203,22 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
 
     const response = await this.toolCaller.callTool(input.role, TOOLS.REPO_APPLY_PATCH, {
       feature_id: input.featureId,
-      unified_diff: unifiedDiff
+      unified_diff: unifiedDiff,
     });
     result.toolResults.push(asRecord(response.data));
     result.patchApplied = true;
   }
 
-  private async routeNote(featureId: string, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routeNote(
+    featureId: string,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     const content = asNonEmptyString(output.content) ?? JSON.stringify(output);
     try {
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
         feature_id: featureId,
-        note: content
+        note: content,
       });
       result.toolResults.push(asRecord(response.data));
       result.noteLogged = true;
@@ -221,7 +227,11 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     }
   }
 
-  private async routeRequest(input: WorkerDecisionInput, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routeRequest(
+    input: WorkerDecisionInput,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     const request = asRecord(output.request ?? output);
     const action = asNonEmptyString(request.action ?? request.request_type)?.toLowerCase();
     if (!action) {
@@ -244,7 +254,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.LOCKS_ACQUIRE, {
         feature_id: input.featureId,
-        resources
+        resources,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -258,7 +268,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.LOCKS_RELEASE, {
         feature_id: input.featureId,
-        resources
+        resources,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -267,7 +277,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
 
     if (action === 'more_context' || action === 'context_refresh') {
       const response = await this.toolCaller.callTool(input.role, TOOLS.FEATURE_GET_CONTEXT, {
-        feature_id: input.featureId
+        feature_id: input.featureId,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -286,7 +296,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       if (existingVersion == null) {
         const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_SUBMIT, {
           feature_id: input.featureId,
-          plan_json: planJson
+          plan_json: planJson,
         });
         result.toolResults.push(asRecord(response.data));
         result.requestHandled = true;
@@ -297,7 +307,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_UPDATE, {
         feature_id: input.featureId,
         expected_plan_version: requestedExpectedVersion ?? existingVersion,
-        plan_json: planJson
+        plan_json: planJson,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;

package/apps/control-plane/test/activity-monitor.spec.ts

@@ -14,7 +14,7 @@ function makeToolCaller(frontMatter: Record<string, unknown>) {
         return { ok: true, data: { front_matter: { version: 1, ...frontMatter } } };
       }
       return { ok: true, data: {} };
-    })
+    }),
   };
 }
 
@@ -27,7 +27,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      idleThresholdMs: DEFAULT_THRESHOLD
+      idleThresholdMs: DEFAULT_THRESHOLD,
     });
 
     const snapshot = await service.getActivityState('feature_a');
@@ -42,7 +42,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: STALE_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      idleThresholdMs: DEFAULT_THRESHOLD
+      idleThresholdMs: DEFAULT_THRESHOLD,
     });
 
     const snapshot = await service.getActivityState('feature_b');
@@ -89,8 +89,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: true, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: true,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_f');
@@ -98,7 +103,7 @@ describe('ActivityMonitorService', () => {
     expect(stuck).toBe(true);
     expect(notifier.notify).toHaveBeenCalledWith(
       'agent_stuck',
-      expect.objectContaining({ feature_id: 'feature_f' })
+      expect.objectContaining({ feature_id: 'feature_f' }),
     );
   });
 
@@ -110,8 +115,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: false, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: false,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_g');
@@ -122,13 +132,13 @@ describe('ActivityMonitorService', () => {
 
   it('GIVEN formatForStatus called WHEN state is idle THEN string includes idle', () => {
     const service = new ActivityMonitorService({
-      toolCaller: { callTool: vi.fn() } as never
+      toolCaller: { callTool: vi.fn() } as never,
     });
     const snapshot: ActivitySnapshot = {
       featureId: 'feature_h',
       state: 'idle',
       lastEventAt: new Date(Date.now() - 10 * 60_000).toISOString(),
-      detectedVia: 'jsonl'
+      detectedVia: 'jsonl',
     };
 
     const str = service.formatForStatus(snapshot);
@@ -138,13 +148,13 @@ describe('ActivityMonitorService', () => {
 
   it('GIVEN formatForStatus called WHEN state has no timestamp THEN returns state name', () => {
     const service = new ActivityMonitorService({
-      toolCaller: { callTool: vi.fn() } as never
+      toolCaller: { callTool: vi.fn() } as never,
     });
     const snapshot: ActivitySnapshot = {
       featureId: 'feature_i',
       state: 'unknown',
       lastEventAt: null,
-      detectedVia: 'unknown'
+      detectedVia: 'unknown',
     };
 
     const str = service.formatForStatus(snapshot);
@@ -160,8 +170,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: true, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: true,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_j');
@@ -174,7 +189,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_run_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'codex-rpc'
+      detectorName: 'codex-rpc',
     });
 
     const snapshot = await service.getActivityState('feature_codex');
@@ -188,10 +203,10 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({
       status: 'building',
       status_reason: 'waiting_input:user_confirmation',
-      last_heartbeat_at: RECENT_TIMESTAMP
+      last_heartbeat_at: RECENT_TIMESTAMP,
     });
     const service = new ActivityMonitorService({
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const snapshot = await service.getActivityState('feature_wait');
@@ -202,7 +217,7 @@ describe('ActivityMonitorService', () => {
   it('GIVEN_checkAndNotifyStuck_WHEN_snapshot_changes_THEN_activity_snapshot_persisted_to_state', async () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: STALE_TIMESTAMP });
     const service = new ActivityMonitorService({
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     await service.checkAndNotifyStuck('feature_patch');
@@ -215,10 +230,10 @@ describe('ActivityMonitorService', () => {
         patch: expect.objectContaining({
           front_matter: expect.objectContaining({
             activity_state: 'idle',
-            activity_detected_via: 'jsonl'
-          })
-        })
-      })
+            activity_detected_via: 'jsonl',
+          }),
+        }),
+      }),
     );
   });
 });
@@ -230,7 +245,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
       detectorName: 'codex-rpc',
-      operationLedger
+      operationLedger,
     });
     const snapshot = await service.getActivityState('feature_ledger');
     expect(snapshot.detectedVia).toBe('ledger');
@@ -240,7 +255,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'process-heuristic'
+      detectorName: 'process-heuristic',
     });
     const snapshot = await service.getActivityState('feature_proc');
     expect(snapshot.detectedVia).toBe('process');
@@ -252,17 +267,21 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
       detectorName: 'codex-rpc',
-      operationLedger
+      operationLedger,
     });
     const snapshot = await service.getActivityState('feature_norpc');
     expect(snapshot.detectedVia).toBe('process');
   });
 
   it('GIVEN_process_heuristic_with_last_run_at_WHEN_getActivityState_THEN_uses_last_run_at', async () => {
-    const toolCaller = makeToolCaller({ status: 'building', last_run_at: RECENT_TIMESTAMP, last_heartbeat_at: undefined });
+    const toolCaller = makeToolCaller({
+      status: 'building',
+      last_run_at: RECENT_TIMESTAMP,
+      last_heartbeat_at: undefined,
+    });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'process-heuristic'
+      detectorName: 'process-heuristic',
     });
     const snapshot = await service.getActivityState('feature_run_at');
     expect(snapshot.lastEventAt).toBe(RECENT_TIMESTAMP);
@@ -272,7 +291,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'some-unknown-detector'
+      detectorName: 'some-unknown-detector',
     });
     const snapshot = await service.getActivityState('feature_unknown_detector');
     expect(snapshot.detectedVia).toBe('unknown');
@@ -282,10 +301,15 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = {
       callTool: vi.fn(async (_role: string, toolName: string) => {
         if (toolName === TOOLS.FEATURE_STATE_GET) {
-          return { ok: true, data: { front_matter: { version: 1, status: 'building', last_heartbeat_at: STALE_TIMESTAMP } } };
+          return {
+            ok: true,
+            data: {
+              front_matter: { version: 1, status: 'building', last_heartbeat_at: STALE_TIMESTAMP },
+            },
+          };
         }
         throw new Error('patch failed');
-      })
+      }),
     };
     const service = new ActivityMonitorService({ toolCaller: toolCaller as never });
     // Should not throw even when persistSnapshot fails - still returns stuck status

package/apps/control-plane/test/adapter-registry.spec.ts

@@ -3,7 +3,7 @@ import {
   DefaultAdapterRegistry,
   AGENT_PROVIDER_SLOT,
   globalAdapterRegistry,
-  REGISTERED_PROVIDER_NAMES
+  REGISTERED_PROVIDER_NAMES,
 } from '../src/application/adapters/adapter-registry.js';
 import { SUPPORTED_PROVIDERS } from '../src/providers/providers.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
@@ -47,7 +47,7 @@ describe('DefaultAdapterRegistry', () => {
       const registry = new DefaultAdapterRegistry();
       const slot = { name: 'compute-slot' };
       registry.register(slot, { slot: 'compute-slot', name: 'fast' }, (config) => ({
-        speed: (config as { speed: number }).speed
+        speed: (config as { speed: number }).speed,
       }));
       const result = registry.resolve(slot, 'fast', { speed: 100 });
       expect(result).toEqual({ speed: 100 });
@@ -59,7 +59,7 @@ describe('DefaultAdapterRegistry', () => {
       const registry = new DefaultAdapterRegistry();
       const slot = { name: 'missing-slot' };
       expect(() => registry.resolve(slot, 'ghost', {})).toThrowError(
-        expect.objectContaining({ code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER })
+        expect.objectContaining({ code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER }),
       );
     });
 
@@ -74,7 +74,7 @@ describe('DefaultAdapterRegistry', () => {
       }
       expect((caught as { details: Record<string, unknown> }).details).toMatchObject({
         slot: 'missing-slot',
-        name: 'ghost'
+        name: 'ghost',
       });
     });
   });
@@ -87,7 +87,7 @@ describe('DefaultAdapterRegistry', () => {
       registry.register(slot, { slot: 'multi-slot', name: 'b' }, () => 'b');
       registry.register(slot, { slot: 'multi-slot', name: 'c' }, () => 'c');
       expect(registry.list('multi-slot').map((m) => m.name)).toEqual(
-        expect.arrayContaining(['a', 'b', 'c'])
+        expect.arrayContaining(['a', 'b', 'c']),
       );
     });
   });

package/apps/control-plane/test/aop.spec.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runCli } from '../src/interfaces/cli/bootstrap.js';
 
 vi.mock('../src/interfaces/cli/bootstrap.js', () => ({
-  runCli: vi.fn()
+  runCli: vi.fn(),
 }));
 
 const ORIGINAL_ARGV = [...process.argv];
@@ -33,7 +33,7 @@ describe('aop.ts entrypoint', () => {
 
     const runtime = {
       cwd: '/tmp/custom-repo',
-      env: { NODE_ENV: 'test' } as NodeJS.ProcessEnv
+      env: { NODE_ENV: 'test' } as NodeJS.ProcessEnv,
     };
     const exitCode = await main(['status'], runtime);
 
@@ -51,7 +51,7 @@ describe('aop.ts entrypoint', () => {
     expect(exitCode).toBe(0);
     expect(runCli).toHaveBeenCalledWith(['resume'], {
       cwd: process.cwd(),
-      env: process.env
+      env: process.env,
     });
   });
 
@@ -132,7 +132,7 @@ describe('aop.ts entrypoint', () => {
     expect(process.exitCode).toBe(17);
     expect(runCli).toHaveBeenCalledWith(['status'], {
       cwd: process.cwd(),
-      env: process.env
+      env: process.env,
     });
   });
 });

package/apps/control-plane/test/batch-operations.spec.ts

@@ -8,8 +8,8 @@ const specResolverResolveMock = vi.hoisted(() => vi.fn());
 
 vi.mock('node:fs/promises', () => ({
   default: {
-    readFile: fsReadFileMock
-  }
+    readFile: fsReadFileMock,
+  },
 }));
 
 vi.mock('../src/cli/spec-input-resolver.js', () => ({
@@ -17,12 +17,14 @@ vi.mock('../src/cli/spec-input-resolver.js', () => ({
     async resolve(...args: unknown[]) {
       return await specResolverResolveMock(...args);
     }
-  }
+  },
 }));
 
 import { RunCommandHandler } from '../src/cli/run-command-handler.js';
 
-function makeContext(toolCallImpl = vi.fn(async () => ({ ok: true, data: {} }))): RunCommandContext {
+function makeContext(
+  toolCallImpl = vi.fn(async () => ({ ok: true, data: {} })),
+): RunCommandContext {
   return {
     repoRoot: '/repo',
     env: {},
@@ -30,7 +32,7 @@ function makeContext(toolCallImpl = vi.fn(async () => ({ ok: true, data: {} })))
     transport: 'inprocess' as const,
     options: { command: 'run', batch: true, folder_input: '/specs' },
     kernel: { getAgentsConfig: () => ({}) } as never,
-    toolClient: { call: toolCallImpl } as never
+    toolClient: { call: toolCallImpl } as never,
   };
 }
 
@@ -42,7 +44,7 @@ describe('BatchOperations', () => {
   it('GIVEN_folder_with_specs_WHEN_batch_run_all_new_THEN_all_created', async () => {
     specResolverResolveMock.mockResolvedValue([
       '/repo/.aop/features/feature_a/spec.md',
-      '/repo/.aop/features/feature_b/spec.md'
+      '/repo/.aop/features/feature_b/spec.md',
     ]);
     fsReadFileMock.mockResolvedValue(JSON.stringify({ active: [], blocked: [] }));
 
@@ -52,24 +54,24 @@ describe('BatchOperations', () => {
 
     expect(result).toMatchObject({
       ok: true,
-      data: { command: 'batch-run', created: 2, skipped: 0, failed: 0 }
+      data: { command: 'batch-run', created: 2, skipped: 0, failed: 0 },
     });
     expect(toolCallMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_INIT,
       expect.objectContaining({ feature_id: 'feature_a' }),
-      expect.any(Object)
+      expect.any(Object),
     );
     expect(toolCallMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_INIT,
       expect.objectContaining({ feature_id: 'feature_b' }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
   it('GIVEN_folder_with_specs_WHEN_batch_run_some_active_THEN_active_skipped', async () => {
     specResolverResolveMock.mockResolvedValue([
       '/repo/.aop/features/feature_a/spec.md',
-      '/repo/.aop/features/feature_b/spec.md'
+      '/repo/.aop/features/feature_b/spec.md',
     ]);
     fsReadFileMock.mockResolvedValue(JSON.stringify({ active: ['feature_a'], blocked: [] }));
 
@@ -79,12 +81,12 @@ describe('BatchOperations', () => {
 
     expect(result).toMatchObject({
       ok: true,
-      data: { command: 'batch-run', created: 1, skipped: 1, failed: 0 }
+      data: { command: 'batch-run', created: 1, skipped: 1, failed: 0 },
     });
     expect(toolCallMock).not.toHaveBeenCalledWith(
       TOOLS.FEATURE_INIT,
       expect.objectContaining({ feature_id: 'feature_a' }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
@@ -94,9 +96,9 @@ describe('BatchOperations', () => {
       data: {
         features: [
           { feature_id: 'feature_a', status: 'planning' },
-          { feature_id: 'feature_b', status: 'building' }
-        ]
-      }
+          { feature_id: 'feature_b', status: 'building' },
+        ],
+      },
     }));
     const handler = new StatusCommandHandler({ call: dashboardCall } as never, 'run:test');
     const result = await handler.execute({ summary: true });
@@ -106,9 +108,9 @@ describe('BatchOperations', () => {
       data: {
         summary: [
           { feature_id: 'feature_a', status: 'planning', activity: 'unknown' },
-          { feature_id: 'feature_b', status: 'building', activity: 'unknown' }
-        ]
-      }
+          { feature_id: 'feature_b', status: 'building', activity: 'unknown' },
+        ],
+      },
     });
   });
 });