agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/session-management.spec.ts

@@ -30,21 +30,26 @@ async function writeFeatureSession(root: string, featureId: string): Promise<voi
     [featureId]: {
       planner_session_id: 'planner:1',
       builder_session_id: 'builder:1',
-      qa_session_id: 'qa:1'
-    }
+      qa_session_id: 'qa:1',
+    },
   };
   await fs.writeFile(leasePath, `${JSON.stringify(lease, null, 2)}\n`, 'utf8');
 }
 
 function makeProvider(overrides: Partial<WorkerProvider> = {}): WorkerProvider {
   return {
-    selection: { provider: 'null', model: 'null-default', provider_config_env: null, provider_config_ref: null },
+    selection: {
+      provider: 'null',
+      model: 'null-default',
+      provider_config_env: null,
+      provider_config_ref: null,
+    },
     createSession: vi.fn(),
     reattachSession: vi.fn(),
     closeSession: vi.fn(),
     runWorker: vi.fn(),
     sendMessage: vi.fn(async () => undefined),
-    ...overrides
+    ...overrides,
   } as unknown as WorkerProvider;
 }
 
@@ -53,7 +58,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_1');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_1' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_1' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_send_1');
 
     const sendMessageMock = vi.fn(async () => undefined);
@@ -63,7 +72,7 @@ describe('feature.send_message kernel handler', () => {
     const result = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_1', message: 'Hello agent!', operation_id: 'op:send:1' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result.ok).toBe(true);
@@ -71,7 +80,7 @@ describe('feature.send_message kernel handler', () => {
       feature_id: 'feature_send_1',
       session_id: 'planner:1',
       target_role: 'planner',
-      delivered: true
+      delivered: true,
     });
     expect(sendMessageMock).toHaveBeenCalledWith('planner:1', 'Hello agent!');
   });
@@ -80,7 +89,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_wait');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_wait' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_wait' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_send_wait');
 
     const getSessionInfo = vi
@@ -93,8 +106,12 @@ describe('feature.send_message kernel handler', () => {
 
     const result = await kernel.invoke(
       'feature.send_message',
-      { feature_id: 'feature_send_wait', message: 'Wait for ready session', operation_id: 'op:send:wait' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      {
+        feature_id: 'feature_send_wait',
+        message: 'Wait for ready session',
+        operation_id: 'op:send:wait',
+      },
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result.ok).toBe(true);
@@ -106,7 +123,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_nosession');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_nosession' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_nosession' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
 
     const provider = makeProvider();
     kernel.setProvider(provider);
@@ -114,13 +135,13 @@ describe('feature.send_message kernel handler', () => {
     const result = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_nosession', message: 'Hello agent!', operation_id: 'op:send:2' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result.ok).toBe(false);
     expect(result.error).toMatchObject({
       code: 'session_not_found',
-      message: 'No active session cluster for feature'
+      message: 'No active session cluster for feature',
     });
   });
 
@@ -128,7 +149,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_noprovider');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_noprovider' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_noprovider' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_send_noprovider');
 
     // Provider without sendMessage
@@ -138,13 +163,13 @@ describe('feature.send_message kernel handler', () => {
     const result = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_noprovider', message: 'Hello agent!', operation_id: 'op:send:3' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result.ok).toBe(false);
     expect(result.error).toMatchObject({
       code: 'provider_unsupported',
-      message: 'Provider does not support sendMessage'
+      message: 'Provider does not support sendMessage',
     });
   });
 
@@ -152,7 +177,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_empty_msg');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_empty_msg' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_empty_msg' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_send_empty_msg');
 
     const provider = makeProvider();
@@ -161,7 +190,7 @@ describe('feature.send_message kernel handler', () => {
     const result = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_empty_msg', message: '', operation_id: 'op:send:4' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result.ok).toBe(false);
@@ -171,7 +200,11 @@ describe('feature.send_message kernel handler', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_send_idem');
-    await kernel.invoke('feature.init', { feature_id: 'feature_send_idem' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_send_idem' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_send_idem');
 
     const sendMessageMock = vi.fn(async () => undefined);
@@ -182,12 +215,12 @@ describe('feature.send_message kernel handler', () => {
     const result1 = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_idem', message: 'idem message', operation_id: operationId },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
     const result2 = await kernel.invoke(
       'feature.send_message',
       { feature_id: 'feature_send_idem', message: 'idem message', operation_id: operationId },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     expect(result1.ok).toBe(true);
@@ -201,7 +234,7 @@ describe('SendCommandHandler', () => {
   it('GIVEN send CLI command WHEN executed THEN tool client called with correct params', async () => {
     const call = vi.fn(async () => ({
       ok: true,
-      data: { feature_id: 'feature_a', session_id: 'orch:1', delivered: true }
+      data: { feature_id: 'feature_a', session_id: 'orch:1', delivered: true },
     }));
     const toolClient = { call };
     const handler = new SendCommandHandler(toolClient as never, 'run:test');
@@ -209,7 +242,7 @@ describe('SendCommandHandler', () => {
     const result = await handler.execute({
       command: 'send',
       feature_id: 'feature_a',
-      message: 'Do something'
+      message: 'Do something',
     });
 
     expect(call).toHaveBeenCalledWith(
@@ -217,33 +250,31 @@ describe('SendCommandHandler', () => {
       expect.objectContaining({
         feature_id: 'feature_a',
         message: 'Do something',
-        operation_id: expect.any(String)
+        operation_id: expect.any(String),
       }),
       expect.objectContaining({
         run_id: 'run:test',
-        actor_type: 'system'
-      })
+        actor_type: 'system',
+      }),
     );
     expect(result).toMatchObject({
       ok: true,
       data: {
         command: 'send',
         feature_id: 'feature_a',
-        delivered: true
-      }
+        delivered: true,
+      },
     });
   });
 
   it('GIVEN feature_id missing WHEN send CLI called THEN validation error thrown', async () => {
     const handler = new SendCommandHandler({ call: vi.fn() } as never, 'run:test');
 
-    await expect(
-      handler.execute({ command: 'send', message: 'Hello' })
-    ).rejects.toMatchObject({
+    await expect(handler.execute({ command: 'send', message: 'Hello' })).rejects.toMatchObject({
       code: ERROR_CODES.INVALID_CLI_ARGS,
       details: expect.objectContaining({
-        reason: '--feature-id is required for send'
-      })
+        reason: '--feature-id is required for send',
+      }),
     });
   });
 
@@ -251,12 +282,12 @@ describe('SendCommandHandler', () => {
     const handler = new SendCommandHandler({ call: vi.fn() } as never, 'run:test');
 
     await expect(
-      handler.execute({ command: 'send', feature_id: 'feature_a' })
+      handler.execute({ command: 'send', feature_id: 'feature_a' }),
     ).rejects.toMatchObject({
       code: ERROR_CODES.INVALID_CLI_ARGS,
       details: expect.objectContaining({
-        reason: '--message is required for send'
-      })
+        reason: '--message is required for send',
+      }),
     });
   });
 });
@@ -269,18 +300,21 @@ describe('AttachCommandHandler', () => {
     await kernel.invoke(
       'feature.init',
       { feature_id: 'feature_attach_planning' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
     await writeFeatureSession(repoRoot, 'feature_attach_planning');
 
     const attachToSession = vi.fn(async () => undefined);
     const provider = makeProvider({ attachToSession, reattachSession: undefined });
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    const result = await handler.execute({ command: 'attach', feature_id: 'feature_attach_planning' });
+    const result = await handler.execute({
+      command: 'attach',
+      feature_id: 'feature_attach_planning',
+    });
 
     expect(attachToSession).toHaveBeenCalledWith('planner:1');
     expect(result).toMatchObject({
@@ -290,8 +324,8 @@ describe('AttachCommandHandler', () => {
         feature_id: 'feature_attach_planning',
         role: 'planner',
         session_id: 'planner:1',
-        attached: true
-      }
+        attached: true,
+      },
     });
   });
 
@@ -302,7 +336,7 @@ describe('AttachCommandHandler', () => {
     await kernel.invoke(
       'feature.init',
       { feature_id: 'feature_attach_builder' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
     await writeFeatureSession(repoRoot, 'feature_attach_builder');
 
@@ -311,21 +345,23 @@ describe('AttachCommandHandler', () => {
         provider: 'custom',
         model: 'custom-default',
         provider_config_env: null,
-        provider_config_ref: null
+        provider_config_ref: null,
       },
-      attachToSession: undefined
+      attachToSession: undefined,
     });
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'building' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'building' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    await expect(handler.execute({ command: 'attach', feature_id: 'feature_attach_builder' })).rejects.toMatchObject({
+    await expect(
+      handler.execute({ command: 'attach', feature_id: 'feature_attach_builder' }),
+    ).rejects.toMatchObject({
       code: ERROR_CODES.INVALID_CLI_ARGS,
       details: expect.objectContaining({
         reason: expect.stringContaining('does not support interactive attach'),
-        provider: 'custom'
-      })
+        provider: 'custom',
+      }),
     });
   });
 
@@ -336,20 +372,22 @@ describe('AttachCommandHandler', () => {
     await kernel.invoke(
       'feature.init',
       { feature_id: 'feature_attach_missing' },
-      { actor_type: 'orchestrator', actor_id: 'test' }
+      { actor_type: 'orchestrator', actor_id: 'test' },
     );
 
     const provider = makeProvider();
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    await expect(handler.execute({ command: 'attach', feature_id: 'feature_attach_missing' })).rejects.toMatchObject({
+    await expect(
+      handler.execute({ command: 'attach', feature_id: 'feature_attach_missing' }),
+    ).rejects.toMatchObject({
       code: ERROR_CODES.INVALID_CLI_ARGS,
       details: expect.objectContaining({
-        reason: expect.stringContaining('No active session cluster found')
-      })
+        reason: expect.stringContaining('No active session cluster found'),
+      }),
     });
   });
 });
@@ -361,7 +399,7 @@ describe('AttachCommandHandler branch coverage', () => {
     const toolClient = { call: vi.fn() };
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
     await expect(handler.execute({ command: 'attach' })).rejects.toMatchObject({
-      code: ERROR_CODES.INVALID_CLI_ARGS
+      code: ERROR_CODES.INVALID_CLI_ARGS,
     });
   });
 
@@ -370,8 +408,10 @@ describe('AttachCommandHandler branch coverage', () => {
     const provider = makeProvider();
     const toolClient = { call: vi.fn() };
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    await expect(handler.execute({ command: 'attach', feature_id: 'INVALID Feature ID' })).rejects.toMatchObject({
-      code: ERROR_CODES.INVALID_CLI_ARGS
+    await expect(
+      handler.execute({ command: 'attach', feature_id: 'INVALID Feature ID' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INVALID_CLI_ARGS,
     });
   });
 
@@ -379,13 +419,17 @@ describe('AttachCommandHandler branch coverage', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_attach_qa');
-    await kernel.invoke('feature.init', { feature_id: 'feature_attach_qa' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_attach_qa' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_attach_qa');
 
     const attachToSession = vi.fn(async () => undefined);
     const provider = makeProvider({ attachToSession });
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'qa' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'qa' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
@@ -399,17 +443,24 @@ describe('AttachCommandHandler branch coverage', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_attach_building');
-    await kernel.invoke('feature.init', { feature_id: 'feature_attach_building' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_attach_building' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     await writeFeatureSession(repoRoot, 'feature_attach_building');
 
     const attachToSession = vi.fn(async () => undefined);
     const provider = makeProvider({ attachToSession });
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'building' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'building' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    const result = await handler.execute({ command: 'attach', feature_id: 'feature_attach_building' });
+    const result = await handler.execute({
+      command: 'attach',
+      feature_id: 'feature_attach_building',
+    });
     const data = (result as Record<string, unknown>).data as Record<string, unknown>;
     expect(data.role).toBe('builder');
     expect(attachToSession).toHaveBeenCalledWith('builder:1');
@@ -419,30 +470,41 @@ describe('AttachCommandHandler branch coverage', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_attach_fallback');
-    await kernel.invoke('feature.init', { feature_id: 'feature_attach_fallback' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_attach_fallback' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
 
     // Write session with unassigned planner_session_id but valid orchestrator session
     const leasePath = path.join(repoRoot, '.aop', 'runtime', 'default', 'run-lease.json');
     await fs.mkdir(path.dirname(leasePath), { recursive: true });
-    await fs.writeFile(leasePath, JSON.stringify({
-      orchestrator_session_id: 'orch:fallback-1',
-      feature_sessions: {
-        feature_attach_fallback: {
-          planner_session_id: 'unassigned',
-          builder_session_id: 'unassigned',
-          qa_session_id: 'unassigned'
-        }
-      }
-    }), 'utf8');
+    await fs.writeFile(
+      leasePath,
+      JSON.stringify({
+        orchestrator_session_id: 'orch:fallback-1',
+        feature_sessions: {
+          feature_attach_fallback: {
+            planner_session_id: 'unassigned',
+            builder_session_id: 'unassigned',
+            qa_session_id: 'unassigned',
+          },
+        },
+      }),
+      'utf8',
+    );
 
     const attachToSession = vi.fn(async () => undefined);
     const provider = makeProvider({ attachToSession });
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } }))
+      call: vi.fn(async () => ({ ok: true, data: { front_matter: { status: 'planning' } } })),
     };
 
     const handler = new AttachCommandHandler(toolClient as never, 'run:test', kernel, provider);
-    const result = await handler.execute({ command: 'attach', feature_id: 'feature_attach_fallback' });
+    const result = await handler.execute({
+      command: 'attach',
+      feature_id: 'feature_attach_fallback',
+    });
     const data = (result as Record<string, unknown>).data as Record<string, unknown>;
     expect(data.session_id).toBe('orch:fallback-1');
     expect(attachToSession).toHaveBeenCalledWith('orch:fallback-1');

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

@@ -13,29 +13,29 @@ const mocks = vi.hoisted(() => ({
   writeFile: vi.fn(async () => {}),
   canonicalFeatureIdFromPath: vi.fn(() => 'derived-feature'),
   isCanonicalSpecPath: vi.fn((): string | null => null),
-  isLegacyCanonicalSpecPath: vi.fn((): string | null => null)
+  isLegacyCanonicalSpecPath: vi.fn((): string | null => null),
 }));
 
 vi.mock('../src/core/fs.js', () => ({
   stableHash: mocks.stableHash,
-  ensureDir: mocks.ensureDir
+  ensureDir: mocks.ensureDir,
 }));
 
 vi.mock('../src/cli/tooling.js', () => ({
-  callCliTool: mocks.callCliTool
+  callCliTool: mocks.callCliTool,
 }));
 
 vi.mock('node:fs/promises', () => ({
   default: {
     readFile: mocks.readFile,
-    writeFile: mocks.writeFile
-  }
+    writeFile: mocks.writeFile,
+  },
 }));
 
 vi.mock('../src/cli/spec-utils.js', () => ({
   canonicalFeatureIdFromPath: mocks.canonicalFeatureIdFromPath,
   isCanonicalSpecPath: mocks.isCanonicalSpecPath,
-  isLegacyCanonicalSpecPath: mocks.isLegacyCanonicalSpecPath
+  isLegacyCanonicalSpecPath: mocks.isLegacyCanonicalSpecPath,
 }));
 
 import { SpecIngestionService } from '../src/cli/spec-ingestion-service.js';
@@ -51,12 +51,14 @@ function makeService() {
 describe('SpecIngestionService', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mocks.callCliTool.mockImplementation(async (_client: unknown, _runId: string, toolName: string) => {
-      if (toolName === 'feature.state_get') {
-        return { data: { front_matter: { version: 1 } } };
-      }
-      return { data: {} };
-    });
+    mocks.callCliTool.mockImplementation(
+      async (_client: unknown, _runId: string, toolName: string) => {
+        if (toolName === 'feature.state_get') {
+          return { data: { front_matter: { version: 1 } } };
+        }
+        return { data: {} };
+      },
+    );
     mocks.isCanonicalSpecPath.mockReturnValue(null);
     mocks.isLegacyCanonicalSpecPath.mockReturnValue(null);
     mocks.canonicalFeatureIdFromPath.mockReturnValue('derived-feature');
@@ -130,7 +132,9 @@ describe('SpecIngestionService', () => {
 
       expect(result).toHaveLength(1);
       expect(result[0].feature_id).toBe('derived-feature');
-      expect(mocks.canonicalFeatureIdFromPath).toHaveBeenCalledWith('/somewhere/derived-feature.md');
+      expect(mocks.canonicalFeatureIdFromPath).toHaveBeenCalledWith(
+        '/somewhere/derived-feature.md',
+      );
       expect(mocks.ensureDir).toHaveBeenCalled();
       expect(mocks.writeFile).toHaveBeenCalled();
     });
@@ -144,8 +148,8 @@ describe('SpecIngestionService', () => {
       await expect(
         service.ingest([
           '/repo/.aop/features/my-feature/spec.md',
-          '/repo/.aop/features/my-feature/spec.md'
-        ])
+          '/repo/.aop/features/my-feature/spec.md',
+        ]),
       ).rejects.toMatchObject({ code: 'feature_slug_collision' });
     });
 
@@ -156,22 +160,20 @@ describe('SpecIngestionService', () => {
       await expect(
         service.ingest([
           '/repo/.aop/features/colliding-feature/spec.md',
-          '/repo/.aop/features/colliding-feature/spec.md'
-        ])
+          '/repo/.aop/features/colliding-feature/spec.md',
+        ]),
       ).rejects.toMatchObject({ details: { feature_id: 'colliding-feature' } });
     });
   });
 
   describe('ingest - multiple paths', () => {
     it('GIVEN_multiple_distinct_canonical_paths_WHEN_ingest_called_THEN_returns_item_for_each', async () => {
-      mocks.isCanonicalSpecPath
-        .mockReturnValueOnce('feature-a')
-        .mockReturnValueOnce('feature-b');
+      mocks.isCanonicalSpecPath.mockReturnValueOnce('feature-a').mockReturnValueOnce('feature-b');
       const service = makeService();
 
       const result = await service.ingest([
         '/repo/.aop/features/feature-a/spec.md',
-        '/repo/.aop/features/feature-b/spec.md'
+        '/repo/.aop/features/feature-b/spec.md',
       ]);
 
       expect(result).toHaveLength(2);

package/apps/control-plane/test/spec-input-resolver.spec.ts

@@ -7,7 +7,7 @@ import { ERROR_CODES } from '../src/core/error-codes.js';
 const callCliToolMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../src/cli/tooling.js', () => ({
-  callCliTool: callCliToolMock
+  callCliTool: callCliToolMock,
 }));
 
 import { SpecInputResolver } from '../src/cli/spec-input-resolver.js';
@@ -36,18 +36,19 @@ describe('SpecInputResolver', () => {
     const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
     const files = await resolver.resolve({ command: 'run', folder_input: 'incoming' });
 
-    expect(files).toEqual([
-      path.join(incoming, 'b.md'),
-      path.join(nested, 'a.md')
-    ].sort((a, b) => a.localeCompare(b)));
+    expect(files).toEqual(
+      [path.join(incoming, 'b.md'), path.join(nested, 'a.md')].sort((a, b) => a.localeCompare(b)),
+    );
   });
 
   it('GIVEN_folder_input_pointing_to_file_WHEN_resolving_THEN_returns_input_path_not_found', async () => {
     await fs.writeFile(path.join(repoRoot, 'not-a-folder.md'), '# spec\n', 'utf8');
     const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
 
-    await expect(resolver.resolve({ command: 'run', folder_input: 'not-a-folder.md' })).rejects.toMatchObject({
-      code: ERROR_CODES.INPUT_PATH_NOT_FOUND
+    await expect(
+      resolver.resolve({ command: 'run', folder_input: 'not-a-folder.md' }),
+    ).rejects.toMatchObject({
+      code: ERROR_CODES.INPUT_PATH_NOT_FOUND,
     });
   });
 
@@ -56,7 +57,7 @@ describe('SpecInputResolver', () => {
     const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');
 
     await expect(resolver.resolve({ command: 'run' })).rejects.toMatchObject({
-      code: ERROR_CODES.NO_SPECS_FOUND
+      code: ERROR_CODES.NO_SPECS_FOUND,
     });
   });
 
@@ -64,8 +65,8 @@ describe('SpecInputResolver', () => {
     callCliToolMock.mockResolvedValue({
       ok: true,
       data: {
-        specs: [{ spec_path: '.aop/features/alpha/spec.md' }]
-      }
+        specs: [{ spec_path: '.aop/features/alpha/spec.md' }],
+      },
     });
 
     const resolver = new SpecInputResolver(repoRoot, {} as any, 'run:resolver');