agentic-orchestrator 0.1.6 → 0.1.7

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

@@ -16,9 +16,9 @@ vi.mock('node:readline/promises', () => ({
   default: {
     createInterface: vi.fn(() => ({
       question: readlineQuestionMock,
-      close: readlineCloseMock
-    }))
-  }
+      close: readlineCloseMock,
+    })),
+  },
 }));
 
 vi.mock('../src/core/kernel.js', () => {
@@ -59,7 +59,7 @@ vi.mock('../src/core/kernel.js', () => {
 
 vi.mock('../src/mcp/runtime-factory.js', () => ({
   createToolingRuntime: createToolingRuntimeMock,
-  resolveToolClient: resolveToolClientMock
+  resolveToolClient: resolveToolClientMock,
 }));
 
 vi.mock('../src/cli/init-command-handler.js', () => ({
@@ -73,11 +73,11 @@ vi.mock('../src/cli/init-command-handler.js', () => ({
           updated: [],
           skipped: [],
           validation_warnings: [],
-          next_steps: []
-        }
+          next_steps: [],
+        },
       };
     }
-  }
+  },
 }));
 
 vi.mock('../src/cli/dashboard-command-handler.js', () => ({
@@ -85,7 +85,7 @@ vi.mock('../src/cli/dashboard-command-handler.js', () => ({
     async execute() {
       return { ok: true, data: { message: 'started', port: 3000 } };
     }
-  }
+  },
 }));
 
 vi.mock('../src/cli/run-command-handler.js', () => ({
@@ -93,7 +93,7 @@ vi.mock('../src/cli/run-command-handler.js', () => ({
     async execute() {
       return { ok: true, data: { status: 'running' } };
     }
-  }
+  },
 }));
 
 vi.mock('../src/cli/resume-command-handler.js', () => ({
@@ -101,7 +101,7 @@ vi.mock('../src/cli/resume-command-handler.js', () => ({
     async execute() {
       return { ok: true, data: { resumed: false } };
     }
-  }
+  },
 }));
 
 // ── helpers ───────────────────────────────────────────────────────────────────
@@ -121,16 +121,22 @@ function asJsonWrites(spy: ReturnType<typeof vi.spyOn>): unknown[] {
 }
 
 async function writeMultiProjectYaml(dir: string, content: string): Promise<void> {
-  const configDir = path.join(dir, 'agentic', 'orchestrator');
+  const configDir = path.join(dir, 'config', 'agentic', 'orchestrator');
   await fs.mkdir(configDir, { recursive: true });
   await fs.writeFile(path.join(configDir, 'multi-project.yaml'), content, 'utf8');
 }
 
 async function writeSchemaFile(dir: string): Promise<void> {
-  const schemasDir = path.join(dir, 'agentic', 'orchestrator', 'schemas');
+  const schemasDir = path.join(dir, 'config', 'agentic', 'orchestrator', 'schemas');
   await fs.mkdir(schemasDir, { recursive: true });
   const repoRoot = path.resolve(import.meta.dirname, '../../../');
-  const srcSchema = path.join(repoRoot, 'agentic', 'orchestrator', 'schemas', 'multi-project.schema.json');
+  const srcSchema = path.join(
+    repoRoot,
+    'agentic',
+    'orchestrator',
+    'schemas',
+    'multi-project.schema.json',
+  );
   const destSchema = path.join(schemasDir, 'multi-project.schema.json');
   await fs.copyFile(srcSchema, destSchema);
 }
@@ -168,7 +174,7 @@ describe('bootstrap runCli', () => {
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
     const code = await runCli(['delete', '--feature-id', 'feat_x', '--yes'], {
       cwd: '/tmp',
-      env: process.env
+      env: process.env,
     });
 
     const writes = asJsonWrites(stdoutSpy);
@@ -185,14 +191,14 @@ describe('bootstrap runCli', () => {
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
     const code = await runCli(['retry', '--feature-id', 'feat_x'], {
       cwd: '/tmp',
-      env: process.env
+      env: process.env,
     });
 
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: { feature_id: 'feat_x', retry_count_reset: false, retry_executed: true }
+      data: { feature_id: 'feat_x', retry_count_reset: false, retry_executed: true },
     });
     expect(toolCallMock).toHaveBeenCalled();
   });
@@ -203,7 +209,7 @@ describe('bootstrap runCli', () => {
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
     const code = await runCli(['send', '--feature-id', 'feat_x', '--message', 'hello'], {
       cwd: '/tmp',
-      env: process.env
+      env: process.env,
     });
 
     const writes = asJsonWrites(stdoutSpy);
@@ -227,7 +233,7 @@ describe('bootstrap runCli', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({
       ok: true,
-      data: expect.objectContaining({ would_clean: expect.any(Array), cleaned: expect.any(Array) })
+      data: expect.objectContaining({ would_clean: expect.any(Array), cleaned: expect.any(Array) }),
     });
   });
 
@@ -239,7 +245,7 @@ describe('bootstrap runCli', () => {
     expect(code).toBe(1);
     expect(writes[0]).toMatchObject({
       ok: false,
-      error: expect.objectContaining({ message: expect.stringContaining('unknown-command') })
+      error: expect.objectContaining({ message: expect.stringContaining('unknown-command') }),
     });
   });
 
@@ -281,7 +287,7 @@ describe('bootstrap runCli', () => {
 
   it('GIVEN_ensureLoaded_throws_WHEN_run_command_executed_THEN_returns_exit_code_1', async () => {
     ensureLoadedMock.mockRejectedValueOnce(
-      Object.assign(new Error('config load failed'), { code: 'CONFIG_LOAD_ERROR' })
+      Object.assign(new Error('config load failed'), { code: 'CONFIG_LOAD_ERROR' }),
     );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
@@ -289,7 +295,10 @@ describe('bootstrap runCli', () => {
 
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(1);
-    expect(writes[0]).toMatchObject({ ok: false, error: expect.objectContaining({ message: 'config load failed' }) });
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: expect.objectContaining({ message: 'config load failed' }),
+    });
   });
 
   it('GIVEN_project_flag_with_no_multi_project_yaml_WHEN_executed_THEN_returns_exit_code_1', async () => {
@@ -301,7 +310,7 @@ describe('bootstrap runCli', () => {
     expect(code).toBe(1);
     expect(writes[0]).toMatchObject({
       ok: false,
-      error: expect.objectContaining({ message: expect.stringContaining('multi-project.yaml') })
+      error: expect.objectContaining({ message: expect.stringContaining('multi-project.yaml') }),
     });
   });
 });
@@ -341,7 +350,7 @@ projects:
     path: ${proj1}
   - name: proj2
     path: ${proj2}
-`
+`,
     );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
@@ -354,9 +363,9 @@ projects:
       data: {
         projects: expect.arrayContaining([
           expect.objectContaining({ name: 'proj1' }),
-          expect.objectContaining({ name: 'proj2' })
-        ])
-      }
+          expect.objectContaining({ name: 'proj2' }),
+        ]),
+      },
     });
   });
 
@@ -373,20 +382,25 @@ projects:
     path: ${projGood}
   - name: proj-bad
     path: /nonexistent/path/that/will/fail
-`
+`,
     );
 
     // First project succeeds, second causes ensureLoaded to fail
     ensureLoadedMock
       .mockResolvedValueOnce(undefined)
-      .mockRejectedValueOnce(Object.assign(new Error('project load error'), { code: 'CONFIG_LOAD_ERROR' }));
+      .mockRejectedValueOnce(
+        Object.assign(new Error('project load error'), { code: 'CONFIG_LOAD_ERROR' }),
+      );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
     const code = await runCli(['status', '--all'], { cwd: tmpDir, env: process.env });
 
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
-    const aggregate = writes[0] as { ok: boolean; data: { projects: Array<{ name: string; status: unknown }> } };
+    const aggregate = writes[0] as {
+      ok: boolean;
+      data: { projects: Array<{ name: string; status: unknown }> };
+    };
     expect(aggregate.ok).toBe(true);
     expect(aggregate.data.projects).toHaveLength(2);
     const badProject = aggregate.data.projects.find((p) => p.name === 'proj-bad');
@@ -417,7 +431,10 @@ describe('bootstrap multi-project selection branches', () => {
   it('GIVEN_single_project_multi_yaml_WHEN_status_no_project_flag_THEN_auto_selects_only_project', async () => {
     const proj1 = path.join(tmpDir, 'proj1');
     await fs.mkdir(proj1, { recursive: true });
-    await writeMultiProjectYaml(tmpDir, `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`,
+    );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
     const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
@@ -431,7 +448,7 @@ describe('bootstrap multi-project selection branches', () => {
     await fs.mkdir(proj2, { recursive: true });
     await writeMultiProjectYaml(
       tmpDir,
-      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`,
     );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
@@ -447,7 +464,7 @@ describe('bootstrap multi-project selection branches', () => {
     await fs.mkdir(proj2, { recursive: true });
     await writeMultiProjectYaml(
       tmpDir,
-      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\ndefaults:\n  default_project: proj1\n`
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\ndefaults:\n  default_project: proj1\n`,
     );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
@@ -463,7 +480,7 @@ describe('bootstrap multi-project selection branches', () => {
     await fs.mkdir(proj2, { recursive: true });
     await writeMultiProjectYaml(
       tmpDir,
-      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`,
     );
 
     // Mock stdin/stdout to simulate non-TTY environment
@@ -479,17 +496,26 @@ describe('bootstrap multi-project selection branches', () => {
       expect(code).toBe(1);
     } finally {
       Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
-      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: origStdoutIsTTY,
+        configurable: true,
+      });
     }
   });
 
   it('GIVEN_project_flag_and_project_not_found_WHEN_run_THEN_returns_exit_code_1', async () => {
     const proj1 = path.join(tmpDir, 'proj1');
     await fs.mkdir(proj1, { recursive: true });
-    await writeMultiProjectYaml(tmpDir, `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`);
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`,
+    );
 
     const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
-    const code = await runCli(['status', '--project', 'nonexistent'], { cwd: tmpDir, env: process.env });
+    const code = await runCli(['status', '--project', 'nonexistent'], {
+      cwd: tmpDir,
+      env: process.env,
+    });
     expect(code).toBe(1);
   });
 
@@ -514,7 +540,7 @@ describe('bootstrap multi-project selection branches', () => {
     await fs.mkdir(proj2, { recursive: true });
     await writeMultiProjectYaml(
       tmpDir,
-      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`,
     );
 
     // Simulate TTY and user entering '1' to select first project
@@ -532,7 +558,10 @@ describe('bootstrap multi-project selection branches', () => {
       expect(readlineQuestionMock).toHaveBeenCalled();
     } finally {
       Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
-      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: origStdoutIsTTY,
+        configurable: true,
+      });
       readlineQuestionMock.mockReset();
     }
   });
@@ -544,7 +573,7 @@ describe('bootstrap multi-project selection branches', () => {
     await fs.mkdir(proj2, { recursive: true });
     await writeMultiProjectYaml(
       tmpDir,
-      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`,
     );
 
     // Simulate TTY and user entering 'abc' (invalid number)
@@ -561,7 +590,10 @@ describe('bootstrap multi-project selection branches', () => {
       expect(code).toBe(1);
     } finally {
       Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
-      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', {
+        value: origStdoutIsTTY,
+        configurable: true,
+      });
       readlineQuestionMock.mockReset();
     }
   });

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

@@ -52,15 +52,19 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn();
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_a', reason: 'terminal status: merged' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
     expect(callMock).not.toHaveBeenCalled();
   });
@@ -81,20 +85,24 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn(async () => ({ ok: true, data: {} }));
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', yes: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_a' }],
-        cleaned: [{ feature_id: 'feature_a' }]
-      }
+        cleaned: [{ feature_id: 'feature_a' }],
+      },
     });
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_DELETE,
       expect.objectContaining({ feature_id: 'feature_a', confirm: true, dry_run: false }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
@@ -112,19 +120,23 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockResolvedValue([
       { name: 'orphan_feature', isDirectory: () => true },
       { name: 'feature_a', isDirectory: () => true },
-      { name: 'not_a_dir.txt', isDirectory: () => false }
+      { name: 'not_a_dir.txt', isDirectory: () => false },
     ] as never);
 
     const callMock = vi.fn();
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'orphan_feature', reason: 'orphan worktree' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
     expect(callMock).not.toHaveBeenCalled();
   });
@@ -145,7 +157,11 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn().mockRejectedValue(new Error('delete failed'));
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', yes: true });
 
     expect(result).toMatchObject({
@@ -153,8 +169,8 @@ describe('CleanupCommandHandler', () => {
       data: {
         would_clean: [{ feature_id: 'feature_a' }],
         cleaned: [],
-        skipped: [{ feature_id: 'feature_a' }]
-      }
+        skipped: [{ feature_id: 'feature_a' }],
+      },
     });
   });
 
@@ -173,23 +189,35 @@ describe('CleanupCommandHandler', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const defaultHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const defaultHandler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const defaultResult = await defaultHandler.execute({ command: 'cleanup', dry_run: true });
     expect(defaultResult).toMatchObject({
       ok: true,
       data: {
-        would_clean: []
-      }
+        would_clean: [],
+      },
     });
 
-    const autoHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const autoHandler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      true,
+    );
     const autoResult = await autoHandler.execute({ command: 'cleanup', dry_run: true });
     expect(autoResult).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_merged', reason: 'terminal status: merged' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
   });
 });
@@ -219,14 +247,20 @@ describe('CleanupCommandHandler branch coverage', () => {
     // Allow readdir to succeed with empty array so isRunLeaseInactive checks candidate paths
     vi.spyOn(fs, 'readdir').mockResolvedValue([]);
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_active_lease', reason: 'run lease still active' }]
-      }
+        skipped: [{ feature_id: 'feature_active_lease', reason: 'run lease still active' }],
+      },
     });
   });
 
@@ -245,14 +279,20 @@ describe('CleanupCommandHandler branch coverage', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_grace_period', reason: 'not eligible' }]
-      }
+        skipped: [{ feature_id: 'feature_grace_period', reason: 'not eligible' }],
+      },
     });
   });
 
@@ -266,13 +306,21 @@ describe('CleanupCommandHandler branch coverage', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      true,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
-        would_clean: [{ feature_id: 'feature_no_state', reason: 'merged residue with missing state' }]
-      }
+        would_clean: [
+          { feature_id: 'feature_no_state', reason: 'merged residue with missing state' },
+        ],
+      },
     });
   });
 });
@@ -288,14 +336,20 @@ describe('CleanupCommandHandler state unreadable branch', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_bad_state', reason: 'state unreadable' }]
-      }
+        skipped: [{ feature_id: 'feature_bad_state', reason: 'state unreadable' }],
+      },
     });
   });
 });