agentic-orchestrator 0.1.4 → 0.1.6

package/apps/control-plane/test/init-wizard.spec.ts

@@ -18,6 +18,7 @@ vi.mock('node:child_process', () => ({
 }));
 
 import { InitCommandHandler } from '../src/cli/init-command-handler.js';
+import { HelpCommandHandler } from '../src/cli/help-command-handler.js';
 
 function makePromptFactory(responses: string[]) {
   const question = vi.fn(async () => responses.shift() ?? '');
@@ -61,7 +62,6 @@ describe('InitCommandHandler', () => {
     expect(result.data.created).toContain('agentic/orchestrator/agents.yaml');
     expect(result.data.created).toContain('agentic/orchestrator/adapters.yaml');
     expect(result.data.created).toContain('agentic/orchestrator/prompts/planner.system.md');
-    expect(result.data.created).toContain('agentic/orchestrator/schemas/state.schema.json');
     expect(result.data.skipped).toHaveLength(0);
     expect(result.data.updated).toHaveLength(0);
     expect(result.data.validation_warnings).toHaveLength(0);
@@ -69,7 +69,8 @@ describe('InitCommandHandler', () => {
     // Verify files were created
     const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
     expect(policyContent).toContain('base_branch: main');
-    expect(policyContent).toContain('framework: vitest');
+    // lean policy does not include advanced fields like testing.framework
+    expect(policyContent).not.toContain('framework: vitest');
     expect(policyContent).toContain('notifications:');
 
     const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
@@ -79,13 +80,17 @@ describe('InitCommandHandler', () => {
     const agentsContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'agents.yaml'), 'utf8');
     expect(agentsContent).toContain('version: 1');
     expect(agentsContent).toContain('roles:');
+    expect(agentsContent).toContain('default_provider: custom');
+    expect(agentsContent).toContain('default_model: local-default');
+
+    const adaptersContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'adapters.yaml'), 'utf8');
+    expect(adaptersContent).toContain('activity-detector: process-heuristic');
+    expect(adaptersContent).toContain('scm-provider: github');
 
     await expect(
       fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'prompts', 'planner.system.md'), 'utf8')
     ).resolves.toContain('planner');
-    await expect(
-      fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'schemas', 'state.schema.json'), 'utf8')
-    ).resolves.toContain('"$schema"');
+    await expect(fs.stat(path.join(cwd, 'agentic', 'orchestrator', 'schemas'))).rejects.toThrow();
   });
 
   it('GIVEN_existing_config_WHEN_init_without_force_THEN_skips_existing_files', async () => {
@@ -124,10 +129,11 @@ describe('InitCommandHandler', () => {
     expect(result.data.updated).toContain('agentic/orchestrator/policy.yaml');
     expect(result.data.skipped).not.toContain('agentic/orchestrator/policy.yaml');
 
-    // Verify file WAS overwritten with generated content
+    // Verify file WAS overwritten with generated content (lean policy by default)
     const content = await fs.readFile(path.join(orchestratorDir, 'policy.yaml'), 'utf8');
     expect(content).not.toContain('# existing');
-    expect(content).toContain('framework: vitest');
+    // lean policy does not include testing.framework
+    expect(content).not.toContain('framework: vitest');
   });
 
   it('GIVEN_non_git_directory_WHEN_init_THEN_uses_defaults', async () => {
@@ -248,6 +254,9 @@ describe('InitCommandHandler', () => {
 
     const prompts = makePromptFactory([
       'release',
+      'claude',
+      'sonnet-4.5',
+      'github',
       '4',
       '4500',
       'desktop,slack',
@@ -272,6 +281,14 @@ describe('InitCommandHandler', () => {
     const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
     expect(gatesContent).toContain('"npx"');
     expect(gatesContent).toContain('"jest"');
+
+    const agentsContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'agents.yaml'), 'utf8');
+    expect(agentsContent).toContain('default_provider: claude');
+    expect(agentsContent).toContain('default_model: sonnet-4.5');
+
+    const adaptersContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'adapters.yaml'), 'utf8');
+    expect(adaptersContent).toContain('activity-detector: claude-jsonl');
+    expect(adaptersContent).toContain('scm-provider: github');
   });
 });
 
@@ -337,6 +354,61 @@ describe('InitCommandHandler validation branches', () => {
     expect(result.data.validation_warnings[0]).toContain('Failed to validate');
     validateSpy.mockRestore();
   });
+
+  it('GIVEN_skipped_non_policy_files_WHEN_validation_loop_runs_THEN_skipped_rels_are_not_validated', async () => {
+    const orchestratorDir = path.join(cwd, 'agentic', 'orchestrator');
+    await fs.mkdir(orchestratorDir, { recursive: true });
+    // Pre-create gates.yaml and agents.yaml so they get skipped (no --force)
+    await fs.writeFile(path.join(orchestratorDir, 'gates.yaml'), 'version: 1\n# existing gates\n', 'utf8');
+    await fs.writeFile(path.join(orchestratorDir, 'agents.yaml'), 'version: 1\n# existing agents\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.skipped).toContain('agentic/orchestrator/gates.yaml');
+    expect(result.data.skipped).toContain('agentic/orchestrator/agents.yaml');
+    // Skipped files are not validated — no errors from their existing (partial) content
+    expect(result.data.validation_warnings).toHaveLength(0);
+  });
+});
+
+describe('InitCommandHandler codex activity detector branch', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-codex-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_codex_provider_WHEN_init_THEN_activity_detector_is_codex_rpc', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(path.join(cwd, '.git', 'config'), '[core]\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const prompts = makePromptFactory([
+      'main',
+      'codex',
+      'codex-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest'
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    const adaptersContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'adapters.yaml'), 'utf8');
+    expect(adaptersContent).toContain('activity-detector: codex-rpc');
+  });
 });
 
 describe('InitCommandHandler webhook channel branch', () => {
@@ -359,6 +431,9 @@ describe('InitCommandHandler webhook channel branch', () => {
 
     const prompts = makePromptFactory([
       'main',
+      'custom',
+      'local-default',
+      'github',
       '3',
       '3000',
       'webhook',
@@ -394,6 +469,9 @@ describe('InitCommandHandler parseNotificationChannels none branch', () => {
 
     const prompts = makePromptFactory([
       'main',
+      'custom',
+      'local-default',
+      'github',
       '3',
       '3000',
       'none',
@@ -472,6 +550,9 @@ describe('InitCommandHandler parseInteger out-of-range and parseFramework fallba
 
     const prompts = makePromptFactory([
       'main',
+      'custom',
+      'local-default',
+      'github',
       '0',    // out of range (min=1) → parseInteger returns fallback 3
       '3000',
       'none',
@@ -493,6 +574,9 @@ describe('InitCommandHandler parseInteger out-of-range and parseFramework fallba
 
     const prompts = makePromptFactory([
       'main',
+      'custom',
+      'local-default',
+      'github',
       '3',
       '3000',
       'none',
@@ -504,3 +588,72 @@ describe('InitCommandHandler parseInteger out-of-range and parseFramework fallba
     expect(result.ok).toBe(true);
   });
 });
+
+describe('InitCommandHandler lean vs advanced policy', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-policy-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_default_init_WHEN_policy_generated_THEN_policy_is_lean_shape', async () => {
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.validation_warnings).toHaveLength(0);
+
+    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    // Lean policy contains common controls
+    expect(policyContent).toContain('worktree:');
+    expect(policyContent).toContain('base_branch:');
+    expect(policyContent).toContain('supervisor:');
+    expect(policyContent).toContain('max_parallel_gate_runs:');
+    expect(policyContent).toContain('dashboard:');
+    expect(policyContent).toContain('merge_policy:');
+    expect(policyContent).toContain('notifications:');
+    // Lean policy does NOT contain advanced fields
+    expect(policyContent).not.toContain('commit_policy:');
+    expect(policyContent).not.toContain('patch_policy:');
+    expect(policyContent).not.toContain('rbac:');
+    expect(policyContent).not.toContain('locks:');
+    expect(policyContent).not.toContain('implementation:');
+    expect(policyContent).not.toContain('testing:');
+  });
+
+  it('GIVEN_advanced_policy_flag_WHEN_policy_generated_THEN_policy_is_full_shape', async () => {
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true, advanced_policy: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.validation_warnings).toHaveLength(0);
+
+    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    // Full policy contains advanced controls
+    expect(policyContent).toContain('commit_policy:');
+    expect(policyContent).toContain('patch_policy:');
+    expect(policyContent).toContain('rbac:');
+    expect(policyContent).toContain('locks:');
+    expect(policyContent).toContain('implementation:');
+    expect(policyContent).toContain('testing:');
+    expect(policyContent).toContain('framework: vitest');
+  });
+
+  it('GIVEN_advanced_policy_flag_WHEN_help_rendered_THEN_flag_is_documented', () => {
+    const handler = new HelpCommandHandler();
+    const result = handler.execute('init');
+
+    expect(result.ok).toBe(true);
+    expect(result.data.help).toContain('--advanced-policy');
+  });
+});

package/apps/control-plane/test/issue-tracker.spec.ts

@@ -507,7 +507,7 @@ describe('issue-tracker-service additional branch coverage', () => {
   it('GIVEN_linear_planning_status_WHEN_updateIssueStatus_THEN_maps_to_backlog', async () => {
     const bodies: string[] = [];
     const runner: HttpRunner = async (_, init) => {
-      bodies.push(init.body ?? '');
+      bodies.push((init.body as string) ?? '');
       // First call: resolveIssueNode → return a valid issue
       if (bodies.length === 1) {
         return {
@@ -529,7 +529,7 @@ describe('issue-tracker-service additional branch coverage', () => {
   it('GIVEN_linear_qa_status_WHEN_updateIssueStatus_THEN_maps_to_in_review', async () => {
     const bodies: string[] = [];
     const runner: HttpRunner = async (_, init) => {
-      bodies.push(init.body ?? '');
+      bodies.push((init.body as string) ?? '');
       if (bodies.length === 1) {
         return {
           status: 200, ok: true,
@@ -642,7 +642,7 @@ describe('Issue tracker additional branch coverage', () => {
   it('GIVEN_linear_with_unknown_status_WHEN_updateIssueStatus_THEN_uses_in_progress_default', async () => {
     const bodies: string[] = [];
     const runner: HttpRunner = async (_, init) => {
-      bodies.push(init.body ?? '');
+      bodies.push((init.body as string) ?? '');
       if (bodies.length === 1) {
         return {
           status: 200, ok: true,

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

@@ -369,3 +369,65 @@ describe('AopKernel', () => {
     expect(branchLookup.code).not.toBe(0);
   });
 });
+
+describe('AopKernel policy composition', () => {
+  it('GIVEN_lean_policy_repo_WHEN_kernel_loads_THEN_runtime_boots_successfully', async () => {
+    const leanRoot = await makeTempRepo(process.cwd());
+    try {
+      // Replace the full policy.yaml with a lean one
+      const leanPolicy = `version: 1
+worktree:
+  base_branch: main
+supervisor:
+  max_parallel_gate_runs: 2
+dashboard:
+  enabled: true
+  port: 3000
+merge_policy:
+  require_user_approval: true
+notifications:
+  enabled: false
+  channels:
+    desktop:
+      enabled: false
+    slack:
+      enabled: false
+      webhook: ""
+      channel: "#aop-alerts"
+    webhook:
+      enabled: false
+      url: ""
+`;
+      await fs.writeFile(path.join(leanRoot, 'agentic', 'orchestrator', 'policy.yaml'), leanPolicy, 'utf8');
+
+      const kernel = new AopKernel(leanRoot);
+      await kernel.ensureLoaded();
+
+      // Kernel should have composed defaults — policy snapshot should contain merged values
+      const snapshot = kernel.getPolicySnapshot() as Record<string, unknown>;
+      expect(snapshot['worktree']).toBeDefined();
+      expect((snapshot['worktree'] as Record<string, unknown>)['base_branch']).toBe('main');
+      // implementation and rbac come from defaults
+      expect(snapshot['implementation']).toBeDefined();
+      expect(snapshot['rbac']).toBeDefined();
+    } finally {
+      await fs.rm(leanRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_full_policy_repo_WHEN_kernel_loads_THEN_runtime_boots_successfully', async () => {
+    // makeTempRepo copies the full policy.yaml from the AOP repo
+    const fullRoot = await makeTempRepo(process.cwd());
+    try {
+      const kernel = new AopKernel(fullRoot);
+      await kernel.ensureLoaded();
+
+      const snapshot = kernel.getPolicySnapshot() as Record<string, unknown>;
+      expect(snapshot['implementation']).toBeDefined();
+      expect(snapshot['rbac']).toBeDefined();
+      expect(snapshot['commit_policy']).toBeDefined();
+    } finally {
+      await fs.rm(fullRoot, { recursive: true, force: true });
+    }
+  });
+});

package/apps/control-plane/test/lock-service.spec.ts

@@ -3,9 +3,10 @@ import { LockService } from '../src/application/services/lock-service.js';
 import type { LockServicePort } from '../src/application/services/lock-service.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
 import { pathExists } from '../src/core/fs.js';
+import type * as FsModule from '../src/core/fs.js';
 
 vi.mock('../src/core/fs.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../src/core/fs.js')>();
+  const actual = await importOriginal<typeof FsModule>();
   return {
     ...actual,
     pathExists: vi.fn(async () => false),
@@ -13,8 +14,7 @@ vi.mock('../src/core/fs.js', async (importOriginal) => {
   };
 });
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyRecord = Record<string, any>;
+type AnyRecord = Record<string, unknown>;
 
 function makeIndex(overrides: Partial<AnyRecord> = {}): AnyRecord {
   return {
@@ -50,7 +50,7 @@ function makePolicy(overrides: Partial<AnyRecord> = {}): AnyRecord {
 function makePort(indexData: AnyRecord, policyData: AnyRecord): LockServicePort {
   let stored = { ...indexData };
   return {
-    withIndexLock: vi.fn(async (fn: () => Promise<unknown>) => fn()),
+    withIndexLock: vi.fn(async (fn: () => Promise<unknown>) => fn()) as unknown as <T>(operation: () => Promise<T>) => Promise<T>,
     readIndex: vi.fn(async () => ({ ...stored })),
     writeIndex: vi.fn(async (idx: AnyRecord) => {
       stored = { ...idx };