agentic-orchestrator 0.1.4 → 0.1.6

package/apps/control-plane/src/mcp/tool-registry-loader.ts

@@ -1,18 +1,54 @@
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { pathExists } from '../core/fs.js';
 import { MCP_PROTOCOL_PIN, REQUIRED_MCP_TRANSPORTS } from './protocol-contract.js';
 import type { LoadedToolRegistry, ProtocolContract, ToolCatalog, ToolCatalogEntry } from './runtime-types.js';
 
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+function resolveBundledToolsRoot(startDir: string): string | null {
+  let current = path.resolve(startDir);
+
+  while (true) {
+    const candidateCatalog = path.join(current, 'agentic', 'orchestrator', 'tools', 'catalog.json');
+    if (fsSync.existsSync(candidateCatalog)) {
+      return path.dirname(candidateCatalog);
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+const BUNDLED_TOOLS_ROOT = resolveBundledToolsRoot(MODULE_DIR);
+
 export class ToolRegistryLoader {
   readonly repoRoot: string;
+  private readonly resolvedToolsRoot: string;
 
   constructor(repoRoot: string) {
     this.repoRoot = repoRoot;
+    this.resolvedToolsRoot = this.resolveToolsRoot();
+  }
+
+  private resolveToolsRoot(): string {
+    const repoToolsRoot = path.join(this.repoRoot, 'agentic', 'orchestrator', 'tools');
+    if (fsSync.existsSync(path.join(repoToolsRoot, 'catalog.json'))) {
+      return repoToolsRoot;
+    }
+    if (BUNDLED_TOOLS_ROOT) {
+      return BUNDLED_TOOLS_ROOT;
+    }
+    return repoToolsRoot;
   }
 
   get toolsRoot(): string {
-    return path.join(this.repoRoot, 'agentic', 'orchestrator', 'tools');
+    return this.resolvedToolsRoot;
   }
 
   get catalogPath(): string {

package/apps/control-plane/src/supervisor/qa-wave-executor.ts

@@ -79,7 +79,7 @@ export class QaWaveExecutor {
       const initialRetryCount = stateForRetry.data.front_matter.gate_retry_count ?? 0;
 
       let gateOverall: string;
-      let gateExitCode = 0;
+      let gateExitCode: number;
       let gateEvidencePath = '';
       let gateLogs = '';
       const failureHistory: GateRepairContext['failureHistory'] = [];

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

@@ -1,3 +1,5 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -61,6 +63,21 @@ describe('aop.ts entrypoint', () => {
     expect(isDirectExecution(`file://${modulePath}`, undefined)).toBe(false);
   });
 
+  it('GIVEN_symlinked_entrypoint_WHEN_direct_execution_checked_THEN_returns_true', async () => {
+    const { isDirectExecution } = await import('../src/cli/aop.js');
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-entrypoint-'));
+    try {
+      const realFilePath = path.join(tempDir, 'real-aop.js');
+      const symlinkPath = path.join(tempDir, 'aop');
+      await fs.writeFile(realFilePath, 'export {};');
+      await fs.symlink(realFilePath, symlinkPath);
+
+      expect(isDirectExecution(pathToFileURL(realFilePath).href, symlinkPath)).toBe(true);
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
   it('GIVEN_not_direct_execution_WHEN_runAsEntrypoint_called_THEN_does_not_call_main_or_change_exit_code', async () => {
     const { runAsEntrypoint } = await import('../src/cli/aop.js');
     const executeMain = vi.fn(async () => 11);
@@ -84,6 +101,26 @@ describe('aop.ts entrypoint', () => {
     expect(process.exitCode).toBe(13);
   });
 
+  it('GIVEN_direct_execution_via_symlink_WHEN_runAsEntrypoint_called_THEN_calls_main', async () => {
+    const { runAsEntrypoint } = await import('../src/cli/aop.js');
+    const executeMain = vi.fn(async () => 19);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-entrypoint-run-'));
+    try {
+      const modulePath = path.resolve(process.cwd(), 'apps/control-plane/src/cli/aop.ts');
+      const symlinkPath = path.join(tempDir, 'aop');
+      await fs.symlink(modulePath, symlinkPath);
+
+      const started = runAsEntrypoint(`file://${modulePath}`, symlinkPath, executeMain);
+
+      expect(started).toBe(true);
+      expect(executeMain).toHaveBeenCalledTimes(1);
+      await new Promise((resolve) => setImmediate(resolve));
+      expect(process.exitCode).toBe(19);
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
   it('GIVEN_module_executed_as_script_WHEN_imported_fresh_THEN_sets_process_exit_code_from_main', async () => {
     vi.mocked(runCli).mockResolvedValueOnce(17);
     const modulePath = path.resolve(process.cwd(), 'apps/control-plane/src/cli/aop.ts');

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

@@ -13,9 +13,11 @@ vi.mock('node:fs/promises', () => ({
 }));
 
 vi.mock('../src/cli/spec-input-resolver.js', () => ({
-  SpecInputResolver: vi.fn().mockImplementation(() => ({
-    resolve: specResolverResolveMock
-  }))
+  SpecInputResolver: class SpecInputResolver {
+    async resolve(...args: unknown[]) {
+      return await specResolverResolveMock(...args);
+    }
+  }
 }));
 
 import { RunCommandHandler } from '../src/cli/run-command-handler.js';

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

@@ -38,36 +38,46 @@ vi.mock('../src/mcp/runtime-factory.js', () => ({
 }));
 
 vi.mock('../src/cli/init-command-handler.js', () => ({
-  InitCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { command: 'init', created: [], updated: [], skipped: [], validation_warnings: [], next_steps: [] } }))
-  }))
+  InitCommandHandler: class InitCommandHandler {
+    async execute() {
+      return { ok: true, data: { command: 'init', created: [], updated: [], skipped: [], validation_warnings: [], next_steps: [] } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/dashboard-command-handler.js', () => ({
-  DashboardCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { message: 'started', port: 3000 } }))
-  }))
+  DashboardCommandHandler: class DashboardCommandHandler {
+    async execute() {
+      return { ok: true, data: { message: 'started', port: 3000 } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/run-command-handler.js', () => ({
-  RunCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { status: 'running' } }))
-  }))
+  RunCommandHandler: class RunCommandHandler {
+    async execute() {
+      return { ok: true, data: { status: 'running' } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/resume-command-handler.js', () => ({
-  ResumeCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { resumed: false } }))
-  }))
+  ResumeCommandHandler: class ResumeCommandHandler {
+    async execute() {
+      return { ok: true, data: { resumed: false } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/attach-command-handler.js', () => ({
-  AttachCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({
-      ok: true,
-      data: { command: 'attach', feature_id: 'feat_x', status: 'building', role: 'builder', session_id: 'sess-1', attached: true }
-    }))
-  }))
+  AttachCommandHandler: class AttachCommandHandler {
+    async execute() {
+      return {
+        ok: true,
+        data: { command: 'attach', feature_id: 'feat_x', status: 'building', role: 'builder', session_id: 'sess-1', attached: true }
+      };
+    }
+  }
 }));
 
 describe('bootstrap runCli attach success path', () => {

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

@@ -65,33 +65,43 @@ vi.mock('../src/mcp/runtime-factory.js', () => ({
 }));
 
 vi.mock('../src/cli/init-command-handler.js', () => ({
-  InitCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { command: 'init', created: [], updated: [], skipped: [], validation_warnings: [], next_steps: [] } }))
-  }))
+  InitCommandHandler: class InitCommandHandler {
+    async execute() {
+      return { ok: true, data: { command: 'init', created: [], updated: [], skipped: [], validation_warnings: [], next_steps: [] } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/dashboard-command-handler.js', () => ({
-  DashboardCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { message: 'started', port: 3000 } }))
-  }))
+  DashboardCommandHandler: class DashboardCommandHandler {
+    async execute() {
+      return { ok: true, data: { message: 'started', port: 3000 } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/run-command-handler.js', () => ({
-  RunCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { status: 'running' } }))
-  }))
+  RunCommandHandler: class RunCommandHandler {
+    async execute() {
+      return { ok: true, data: { status: 'running' } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/resume-command-handler.js', () => ({
-  ResumeCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { resumed: false } }))
-  }))
+  ResumeCommandHandler: class ResumeCommandHandler {
+    async execute() {
+      return { ok: true, data: { resumed: false } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/attach-command-handler.js', () => ({
-  AttachCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { command: 'attach' } }))
-  }))
+  AttachCommandHandler: class AttachCommandHandler {
+    async execute() {
+      return { ok: true, data: { command: 'attach' } };
+    }
+  }
 }));
 
 // ── helpers ───────────────────────────────────────────────────────────────────

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

@@ -63,37 +63,45 @@ vi.mock('../src/mcp/runtime-factory.js', () => ({
 }));
 
 vi.mock('../src/cli/init-command-handler.js', () => ({
-  InitCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({
-      ok: true,
-      data: {
-        command: 'init',
-        created: [],
-        updated: [],
-        skipped: [],
-        validation_warnings: [],
-        next_steps: []
-      }
-    }))
-  }))
+  InitCommandHandler: class InitCommandHandler {
+    async execute() {
+      return {
+        ok: true,
+        data: {
+          command: 'init',
+          created: [],
+          updated: [],
+          skipped: [],
+          validation_warnings: [],
+          next_steps: []
+        }
+      };
+    }
+  }
 }));
 
 vi.mock('../src/cli/dashboard-command-handler.js', () => ({
-  DashboardCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { message: 'started', port: 3000 } }))
-  }))
+  DashboardCommandHandler: class DashboardCommandHandler {
+    async execute() {
+      return { ok: true, data: { message: 'started', port: 3000 } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/run-command-handler.js', () => ({
-  RunCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { status: 'running' } }))
-  }))
+  RunCommandHandler: class RunCommandHandler {
+    async execute() {
+      return { ok: true, data: { status: 'running' } };
+    }
+  }
 }));
 
 vi.mock('../src/cli/resume-command-handler.js', () => ({
-  ResumeCommandHandler: vi.fn().mockImplementation(() => ({
-    execute: vi.fn(async () => ({ ok: true, data: { resumed: false } }))
-  }))
+  ResumeCommandHandler: class ResumeCommandHandler {
+    async execute() {
+      return { ok: true, data: { resumed: false } };
+    }
+  }
 }));
 
 // ── helpers ───────────────────────────────────────────────────────────────────

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

@@ -178,18 +178,63 @@ describe('aop CLI unit', () => {
   beforeEach(async () => {
     cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-cli-unit-'));
     await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+    resolveToolClientMock.mockReset();
     resolveToolClientMock.mockReturnValue({ call: toolCallMock });
     toolCallMock.mockReset();
-    ensureLoadedMock.mockClear();
-    recoverFromStateMock.mockClear();
-    readIndexMock.mockClear();
-    getRuntimeSessionsMock.mockClear();
-    featureDiscoverSpecsMock.mockClear();
-    featureStateGetMock.mockClear();
-    createToolingRuntimeMock.mockClear();
-    resolveProviderSelectionMock.mockClear();
-    supervisorConstructorOptionsMock.mockClear();
-    supervisorStartMock.mockClear();
+    ensureLoadedMock.mockReset();
+    ensureLoadedMock.mockResolvedValue(undefined);
+    recoverFromStateMock.mockReset();
+    recoverFromStateMock.mockResolvedValue({
+      data: {
+        recovered: true,
+        stale_features: [],
+        active: {}
+      }
+    });
+    readIndexMock.mockReset();
+    readIndexMock.mockResolvedValue({
+      version: 1,
+      active: ['feature_resume'],
+      blocked: [],
+      blocked_queue: []
+    });
+    getRuntimeSessionsMock.mockReset();
+    getRuntimeSessionsMock.mockResolvedValue({
+      run_id: 'run:resume',
+      owner_instance_id: 'owner:resume',
+      feature_sessions: {}
+    });
+    featureDiscoverSpecsMock.mockReset();
+    featureDiscoverSpecsMock.mockResolvedValue({
+      data: {
+        specs: [{ feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' }]
+      }
+    });
+    featureStateGetMock.mockReset();
+    featureStateGetMock.mockResolvedValue({
+      data: {
+        front_matter: {
+          status: 'planning'
+        }
+      }
+    });
+    createToolingRuntimeMock.mockReset();
+    createToolingRuntimeMock.mockResolvedValue({ runtime: 'ok' });
+    resolveProviderSelectionMock.mockReset();
+    resolveProviderSelectionMock.mockReturnValue({
+      provider: 'custom',
+      model: 'model',
+      provider_config_env: null,
+      provider_config_ref: null
+    });
+    supervisorConstructorOptionsMock.mockReset();
+    supervisorStartMock.mockReset();
+    supervisorStartMock.mockResolvedValue({
+      queue_depth: 0,
+      status: 'running',
+      run_metadata: { started_at: 'now' },
+      dashboard: { features: [] }
+    });
     stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
   });
 

package/apps/control-plane/test/core-utils.spec.ts

@@ -263,13 +263,22 @@ describe('core-utils additional branch coverage', () => {
     const repoRoot = process.cwd();
     const registry = new SchemaRegistry(repoRoot);
     // Pre-populate cache with a manually compiled validator
-    const AjvCtor = (await import('ajv')).default;
+    const { Ajv: AjvCtor } = await import('ajv');
     const ajv = new AjvCtor({ strict: false });
     const validator = ajv.compile({ type: 'object' });
-    // @ts-expect-error - access private validators map for cache testing
-    registry['validators'].set('policy.schema.json' as any, validator);
+    (registry as any).validators.set('policy.schema.json' as any, validator);
     // Second call should use cached validator
     const result = await registry.validate('policy.schema.json' as any, { anything: true });
     expect(result.valid).toBe(true);
   });
+
+  it('GIVEN_repo_without_local_schema_files_WHEN_validating_THEN_uses_bundled_schema_contracts', async () => {
+    const { SchemaRegistry } = await import('../src/core/schemas.js');
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-schema-fallback-'));
+    const registry = new SchemaRegistry(repoRoot);
+    const result = await registry.validate('adapters.schema.json' as any, {});
+
+    expect(result.valid).toBe(true);
+    await fs.rm(repoRoot, { recursive: true, force: true });
+  });
 });

package/apps/control-plane/test/feature-deletion-service.spec.ts

@@ -9,6 +9,7 @@ vi.mock('../src/core/git.js', () => ({
 
 import { runGit } from '../src/core/git.js';
 import { FeatureDeletionService } from '../src/application/services/feature-deletion-service.js';
+import type { FeatureDeletionServicePort } from '../src/application/services/feature-deletion-service.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import type { RuntimeSessionsSnapshot } from '../src/core/runtime-sessions.js';
 
@@ -409,7 +410,7 @@ describe('FeatureDeletionService readLockResourcesFromIndex and normalizeFeature
       locksRelease: vi.fn(async () => {})
     };
 
-    const service = new FeatureDeletionService(port);
+    const service = new FeatureDeletionService(port as unknown as FeatureDeletionServicePort);
     const result = await service.featureDelete('feature_lock_lease', {
       dryRun: false,
       confirm: true,

package/apps/control-plane/test/feature-lifecycle.spec.ts

@@ -25,7 +25,7 @@ function makePort(overrides: Partial<FeatureLifecycleServicePort> = {}): Feature
     repoEnsureWorktree: vi.fn(async () => ({ data: { worktree_path_abs: `/tmp/worktrees/f1` } })),
     makeDefaultState: vi.fn(() => ({ feature_id: 'f1', status: 'planning', version: 0 })),
     writeState: vi.fn(async () => {}),
-    withIndexLock: vi.fn(async (op: () => Promise<unknown>) => await op()),
+    withIndexLock: vi.fn(async (op: () => Promise<unknown>) => await op()) as unknown as <T>(operation: () => Promise<T>) => Promise<T>,
     readIndex: vi.fn(async () => ({ active: [], blocked: [], version: 0, updated_at: '' })),
     writeIndex: vi.fn(async () => {}),
     featureStateGet: vi.fn(async () => ({ data: { front_matter: { version: 1, status: 'planning' }, body: '' } })),

package/apps/control-plane/test/helpers.ts

@@ -4,10 +4,30 @@ import path from 'node:path';
 import { stableHash } from '../src/core/fs.js';
 import { runCommand } from '../src/core/git.js';
 
+async function copyTemplateSubtree(templateRoot, tempRoot, dirName) {
+  const sourceDir = path.join(templateRoot, dirName);
+  const destinationDir = path.join(tempRoot, dirName);
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      await fs.cp(sourceDir, destinationDir, {
+        recursive: true,
+        filter: (entryPath) => !path.basename(entryPath).startsWith('.tmp-tools.md-')
+      });
+      return;
+    } catch (error) {
+      const errno = error as NodeJS.ErrnoException;
+      if (errno?.code !== 'ENOENT' || attempt === 2) {
+        throw error;
+      }
+    }
+  }
+}
+
 export async function makeTempRepo(templateRoot) {
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-test-'));
-  await fs.cp(path.join(templateRoot, 'agentic'), path.join(tempRoot, 'agentic'), { recursive: true });
-  await fs.cp(path.join(templateRoot, 'apps'), path.join(tempRoot, 'apps'), { recursive: true });
+  await copyTemplateSubtree(templateRoot, tempRoot, 'agentic');
+  await copyTemplateSubtree(templateRoot, tempRoot, 'apps');
   await fs.writeFile(path.join(tempRoot, 'README.md'), '# temp repo\n', 'utf8');
 
   // Runtime artifacts are generated under .aop and should not come from the template copy.