agentic-orchestrator 0.1.6 → 0.1.7

package/apps/control-plane/test/incremental-gates.spec.ts

@@ -6,12 +6,15 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 const runGateModeMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../src/core/gates.js', () => ({
-  runGateMode: runGateModeMock
+  runGateMode: runGateModeMock,
 }));
 
 import { GateService } from '../src/application/services/gate-service.js';
 import type { GateServicePort } from '../src/application/services/gate-service.js';
-import { interpolateGateCommands, isIncrementalMode } from '../src/application/services/gate-interpolation-service.js';
+import {
+  interpolateGateCommands,
+  isIncrementalMode,
+} from '../src/application/services/gate-interpolation-service.js';
 
 describe('incremental gate execution', () => {
   let tempDir: string;
@@ -39,22 +42,36 @@ describe('incremental gate execution', () => {
       evidence_path: path.join(tempDir, 'evidence.json'),
       latest_path: path.join(tempDir, 'latest.json'),
       coverage: null,
-      thresholds: {}
+      thresholds: {},
     });
 
     const profile = {
       modes: {
-        full: [{ name: 'test_full', cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'], timeout_seconds: 60 }]
+        full: [
+          {
+            name: 'test_full',
+            cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'],
+            timeout_seconds: 60,
+          },
+        ],
       },
-      thresholds: {}
+      thresholds: {},
     };
 
     const port: GateServicePort = buildPort(tempDir, { profiles: { default: profile } });
     const service = new GateService(port);
     await service.gatesRun('feature-abc', 'default', 'full');
 
-    const callArgs = runGateModeMock.mock.calls[0][0] as { profile: { modes: { full: Array<{ cmd: string[] }> } } };
-    expect(callArgs.profile.modes.full[0].cmd).toEqual(['npx', 'vitest', 'run', '--changed', '{base_branch}']);
+    const callArgs = runGateModeMock.mock.calls[0][0] as {
+      profile: { modes: { full: Array<{ cmd: string[] }> } };
+    };
+    expect(callArgs.profile.modes.full[0].cmd).toEqual([
+      'npx',
+      'vitest',
+      'run',
+      '--changed',
+      '{base_branch}',
+    ]);
   });
 
   it('GIVEN feature_id in command WHEN interpolateGateCommands called THEN feature_id substituted correctly', () => {
@@ -78,7 +95,11 @@ describe('incremental gate execution', () => {
   it('GIVEN gate run in fast mode with base_branch command WHEN GateService runs THEN command has base_branch interpolated', async () => {
     const evidenceFile = path.join(tempDir, 'gate-fast-123.json');
     const latestFile = path.join(tempDir, 'latest-fast.json');
-    const initialEvidence = JSON.stringify({ feature_id: 'feature-123', mode: 'fast', overall: 'pass' });
+    const initialEvidence = JSON.stringify({
+      feature_id: 'feature-123',
+      mode: 'fast',
+      overall: 'pass',
+    });
     await fs.writeFile(evidenceFile, initialEvidence, 'utf8');
     await fs.writeFile(latestFile, initialEvidence, 'utf8');
 
@@ -88,14 +109,20 @@ describe('incremental gate execution', () => {
       evidence_path: evidenceFile,
       latest_path: latestFile,
       coverage: null,
-      thresholds: {}
+      thresholds: {},
     });
 
     const profile = {
       modes: {
-        fast: [{ name: 'test_incremental', cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'], timeout_seconds: 60 }]
+        fast: [
+          {
+            name: 'test_incremental',
+            cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'],
+            timeout_seconds: 60,
+          },
+        ],
       },
-      thresholds: {}
+      thresholds: {},
     };
 
     const port: GateServicePort = buildPort(tempDir, { profiles: { default: profile } });
@@ -103,11 +130,22 @@ describe('incremental gate execution', () => {
     await service.gatesRun('feature-123', 'default', 'fast');
 
     expect(runGateModeMock).toHaveBeenCalledOnce();
-    const callArgs = runGateModeMock.mock.calls[0][0] as { profile: { modes: { fast: Array<{ cmd: string[] }> } } };
-    expect(callArgs.profile.modes.fast[0].cmd).toEqual(['npx', 'vitest', 'run', '--changed', 'main']);
+    const callArgs = runGateModeMock.mock.calls[0][0] as {
+      profile: { modes: { fast: Array<{ cmd: string[] }> } };
+    };
+    expect(callArgs.profile.modes.fast[0].cmd).toEqual([
+      'npx',
+      'vitest',
+      'run',
+      '--changed',
+      'main',
+    ]);
 
     // Verify evidence files were augmented with incremental metadata
-    const updatedEvidence = JSON.parse(await fs.readFile(evidenceFile, 'utf8')) as Record<string, unknown>;
+    const updatedEvidence = JSON.parse(await fs.readFile(evidenceFile, 'utf8')) as Record<
+      string,
+      unknown
+    >;
     expect(updatedEvidence['skipped_reason']).toBe('incremental_mode');
     expect(updatedEvidence['base_branch']).toBe('main');
   });
@@ -122,16 +160,17 @@ function buildPort(tempDir: string, gatesConfig: Record<string, unknown>): GateS
       execution: {
         retry_policy: { transient_max_retries: 0, transient_error_codes: [] },
         env_allowlist: [],
-        default_step_timeout_seconds: 60
+        default_step_timeout_seconds: 60,
       },
-      testing: { coverage: { minimums: { line: 0, branch: 0 }, targets: { line: 1, branch: 1 } } }
-    }),
-    readState: (_featureId: string) => Promise.resolve({
-      frontMatter: { status: 'building', version: 1, gate_profile: 'default', gates: {} }
+      testing: { coverage: { minimums: { line: 0, branch: 0 }, targets: { line: 1, branch: 1 } } },
     }),
+    readState: (_featureId: string) =>
+      Promise.resolve({
+        frontMatter: { status: 'building', version: 1, gate_profile: 'default', gates: {} },
+      }),
     updateState: vi.fn().mockResolvedValue({}),
     worktreePath: () => tempDir,
     logsPath: () => tempDir,
-    evidencePath: () => tempDir
+    evidencePath: () => tempDir,
   };
 }

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

@@ -8,13 +8,19 @@ const execFileMock = vi.hoisted(() => vi.fn());
 
 vi.mock('node:child_process', () => ({
   execFile: (...args: unknown[]) => {
-    const cb = args[args.length - 1] as (err: null | Error, result?: { stdout: string; stderr: string }) => void;
-    const promise = execFileMock(...args.slice(0, -1)) as Promise<{ stdout: string; stderr: string }>;
+    const cb = args[args.length - 1] as (
+      err: null | Error,
+      result?: { stdout: string; stderr: string },
+    ) => void;
+    const promise = execFileMock(...args.slice(0, -1)) as Promise<{
+      stdout: string;
+      stderr: string;
+    }>;
     void promise.then(
       (result) => cb(null, result),
-      (err: Error) => cb(err)
+      (err: Error) => cb(err),
     );
-  }
+  },
 }));
 
 import { InitCommandHandler } from '../src/cli/init-command-handler.js';
@@ -46,7 +52,7 @@ describe('InitCommandHandler', () => {
     await fs.writeFile(
       path.join(cwd, '.git', 'config'),
       `[core]\n  repositoryformatversion = 0\n[remote "origin"]\n  url = https://github.com/example/repo.git\n  fetch = +refs/heads/*:refs/remotes/origin/*\n`,
-      'utf8'
+      'utf8',
     );
 
     // Mock git symbolic-ref to return origin/main
@@ -57,47 +63,68 @@ describe('InitCommandHandler', () => {
 
     expect(result.ok).toBe(true);
     expect(result.data.command).toBe('init');
-    expect(result.data.created).toContain('agentic/orchestrator/policy.yaml');
-    expect(result.data.created).toContain('agentic/orchestrator/gates.yaml');
-    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('config/agentic/orchestrator/policy.yaml');
+    expect(result.data.created).toContain('config/agentic/orchestrator/gates.yaml');
+    expect(result.data.created).toContain('config/agentic/orchestrator/agents.yaml');
+    expect(result.data.created).toContain('config/agentic/orchestrator/adapters.yaml');
+    expect(result.data.created).toContain('config/agentic/orchestrator/prompts/planner.system.md');
     expect(result.data.skipped).toHaveLength(0);
     expect(result.data.updated).toHaveLength(0);
     expect(result.data.validation_warnings).toHaveLength(0);
 
     // Verify files were created
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('base_branch: main');
     // 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');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'gates.yaml'),
+      'utf8',
+    );
     expect(gatesContent).toContain('version: 1');
     expect(gatesContent).toContain('profiles:');
 
-    const agentsContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'agents.yaml'), 'utf8');
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', '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');
+    const adaptersContent = await fs.readFile(
+      path.join(cwd, 'config', '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')
+      fs.readFile(
+        path.join(cwd, 'config', 'agentic', 'orchestrator', 'prompts', 'planner.system.md'),
+        'utf8',
+      ),
     ).resolves.toContain('planner');
-    await expect(fs.stat(path.join(cwd, 'agentic', 'orchestrator', 'schemas'))).rejects.toThrow();
+    await expect(
+      fs.stat(path.join(cwd, 'config', 'agentic', 'orchestrator', 'schemas')),
+    ).rejects.toThrow();
   });
 
   it('GIVEN_existing_config_WHEN_init_without_force_THEN_skips_existing_files', async () => {
     // Pre-create the orchestrator directory and policy.yaml
-    const orchestratorDir = path.join(cwd, 'agentic', 'orchestrator');
+    const orchestratorDir = path.join(cwd, 'config', 'agentic', 'orchestrator');
     await fs.mkdir(orchestratorDir, { recursive: true });
-    await fs.writeFile(path.join(orchestratorDir, 'policy.yaml'), 'version: 1\n# existing\n', 'utf8');
+    await fs.writeFile(
+      path.join(orchestratorDir, 'policy.yaml'),
+      'version: 1\n# existing\n',
+      'utf8',
+    );
 
     execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
 
@@ -105,9 +132,9 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    expect(result.data.skipped).toContain('agentic/orchestrator/policy.yaml');
-    expect(result.data.created).not.toContain('agentic/orchestrator/policy.yaml');
-    expect(result.data.updated).not.toContain('agentic/orchestrator/policy.yaml');
+    expect(result.data.skipped).toContain('config/agentic/orchestrator/policy.yaml');
+    expect(result.data.created).not.toContain('config/agentic/orchestrator/policy.yaml');
+    expect(result.data.updated).not.toContain('config/agentic/orchestrator/policy.yaml');
 
     // Verify file was NOT overwritten
     const content = await fs.readFile(path.join(orchestratorDir, 'policy.yaml'), 'utf8');
@@ -116,9 +143,13 @@ describe('InitCommandHandler', () => {
 
   it('GIVEN_existing_config_WHEN_init_with_force_THEN_overwrites_files', async () => {
     // Pre-create the orchestrator directory and policy.yaml
-    const orchestratorDir = path.join(cwd, 'agentic', 'orchestrator');
+    const orchestratorDir = path.join(cwd, 'config', 'agentic', 'orchestrator');
     await fs.mkdir(orchestratorDir, { recursive: true });
-    await fs.writeFile(path.join(orchestratorDir, 'policy.yaml'), 'version: 1\n# existing\n', 'utf8');
+    await fs.writeFile(
+      path.join(orchestratorDir, 'policy.yaml'),
+      'version: 1\n# existing\n',
+      'utf8',
+    );
 
     execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
 
@@ -126,8 +157,8 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true, force: true });
 
     expect(result.ok).toBe(true);
-    expect(result.data.updated).toContain('agentic/orchestrator/policy.yaml');
-    expect(result.data.skipped).not.toContain('agentic/orchestrator/policy.yaml');
+    expect(result.data.updated).toContain('config/agentic/orchestrator/policy.yaml');
+    expect(result.data.skipped).not.toContain('config/agentic/orchestrator/policy.yaml');
 
     // Verify file WAS overwritten with generated content (lean policy by default)
     const content = await fs.readFile(path.join(orchestratorDir, 'policy.yaml'), 'utf8');
@@ -144,11 +175,14 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    expect(result.data.created).toContain('agentic/orchestrator/policy.yaml');
+    expect(result.data.created).toContain('config/agentic/orchestrator/policy.yaml');
     expect(result.data.validation_warnings).toHaveLength(0);
 
     // Should default to main branch
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('base_branch: main');
   });
 
@@ -156,7 +190,7 @@ describe('InitCommandHandler', () => {
     await fs.writeFile(
       path.join(cwd, 'package.json'),
       JSON.stringify({ devDependencies: { jest: '^29.0.0' } }),
-      'utf8'
+      'utf8',
     );
     execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
 
@@ -164,20 +198,30 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'gates.yaml'),
+      'utf8',
+    );
     expect(gatesContent).toContain('"npx"');
     expect(gatesContent).toContain('"jest"');
   });
 
   it('GIVEN_pyproject_toml_WHEN_init_THEN_generates_pytest_gate_commands', async () => {
-    await fs.writeFile(path.join(cwd, 'pyproject.toml'), '[tool.poetry]\nname = "myproject"\n', 'utf8');
+    await fs.writeFile(
+      path.join(cwd, 'pyproject.toml'),
+      '[tool.poetry]\nname = "myproject"\n',
+      'utf8',
+    );
     execFileMock.mockRejectedValue(new Error('not git'));
 
     const handler = new InitCommandHandler(cwd);
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'gates.yaml'),
+      'utf8',
+    );
     expect(gatesContent).toContain('"pytest"');
   });
 
@@ -189,7 +233,10 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'gates.yaml'),
+      'utf8',
+    );
     expect(gatesContent).toContain('"mvn"');
   });
 
@@ -201,7 +248,10 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'gates.yaml'),
+      'utf8',
+    );
     expect(gatesContent).toContain('"./gradlew"');
   });
 
@@ -210,7 +260,7 @@ describe('InitCommandHandler', () => {
     await fs.writeFile(
       path.join(cwd, '.git', 'config'),
       '[core]\n  repositoryformatversion = 0\n',
-      'utf8'
+      'utf8',
     );
     execFileMock.mockResolvedValue({ stdout: 'origin/develop\n', stderr: '' });
 
@@ -218,7 +268,10 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('base_branch: develop');
   });
 
@@ -231,7 +284,10 @@ describe('InitCommandHandler', () => {
     const result = await handler.execute({ auto: true });
 
     expect(result.ok).toBe(true);
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('base_branch: master');
   });
 
@@ -261,7 +317,7 @@ describe('InitCommandHandler', () => {
       '4500',
       'desktop,slack',
       'jest',
-      'https://hooks.slack.example/webhook'
+      'https://hooks.slack.example/webhook',
     ]);
     const handler = new InitCommandHandler(cwd, prompts.factory);
     const result = await handler.execute({ auto: false });
@@ -270,7 +326,10 @@ describe('InitCommandHandler', () => {
     expect(prompts.factory).toHaveBeenCalledTimes(1);
     expect(prompts.close).toHaveBeenCalledTimes(1);
 
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('base_branch: release');
     expect(policyContent).toContain('max_parallel_gate_runs: 4');
     expect(policyContent).toContain('port: 4500');
@@ -278,15 +337,24 @@ describe('InitCommandHandler', () => {
     expect(policyContent).toContain('enabled: true');
     expect(policyContent).toContain('webhook: "https://hooks.slack.example/webhook"');
 
-    const gatesContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'gates.yaml'), 'utf8');
+    const gatesContent = await fs.readFile(
+      path.join(cwd, 'config', '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');
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', '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');
+    const adaptersContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'adapters.yaml'),
+      'utf8',
+    );
     expect(adaptersContent).toContain('activity-detector: claude-jsonl');
     expect(adaptersContent).toContain('scm-provider: github');
   });
@@ -306,7 +374,7 @@ describe('InitCommandHandler validation branches', () => {
   });
 
   it('GIVEN_skipped_file_WHEN_validation_loop_runs_THEN_skipped_rel_is_not_validated', async () => {
-    const orchestratorDir = path.join(cwd, 'agentic', 'orchestrator');
+    const orchestratorDir = path.join(cwd, 'config', 'agentic', 'orchestrator');
     await fs.mkdir(orchestratorDir, { recursive: true });
     // Pre-create policy.yaml so it gets skipped (no --force)
     await fs.writeFile(path.join(orchestratorDir, 'policy.yaml'), '# existing\n', 'utf8');
@@ -317,7 +385,7 @@ describe('InitCommandHandler validation branches', () => {
 
     expect(result.ok).toBe(true);
     // policy.yaml was skipped, so the validation loop skipped it too (no error about it)
-    expect(result.data.skipped).toContain('agentic/orchestrator/policy.yaml');
+    expect(result.data.skipped).toContain('config/agentic/orchestrator/policy.yaml');
     // Validation warnings should be empty (skipped file is not validated)
     expect(result.data.validation_warnings).toHaveLength(0);
   });
@@ -327,7 +395,7 @@ describe('InitCommandHandler validation branches', () => {
     const { SchemaRegistry } = await import('../src/core/schemas.js');
     const validateSpy = vi.spyOn(SchemaRegistry.prototype, 'validate').mockResolvedValue({
       valid: false,
-      errors: [{ message: 'test-schema-error' } as any]
+      errors: [{ message: 'test-schema-error' } as any],
     });
 
     const handler = new InitCommandHandler(cwd);
@@ -342,9 +410,9 @@ describe('InitCommandHandler validation branches', () => {
   it('GIVEN_schema_registry_throws_WHEN_init_runs_THEN_adds_catch_validation_warning', async () => {
     execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
     const { SchemaRegistry } = await import('../src/core/schemas.js');
-    const validateSpy = vi.spyOn(SchemaRegistry.prototype, 'validate').mockRejectedValue(
-      new Error('schema-load-failure')
-    );
+    const validateSpy = vi
+      .spyOn(SchemaRegistry.prototype, 'validate')
+      .mockRejectedValue(new Error('schema-load-failure'));
 
     const handler = new InitCommandHandler(cwd);
     const result = await handler.execute({ auto: true });
@@ -356,19 +424,27 @@ describe('InitCommandHandler validation branches', () => {
   });
 
   it('GIVEN_skipped_non_policy_files_WHEN_validation_loop_runs_THEN_skipped_rels_are_not_validated', async () => {
-    const orchestratorDir = path.join(cwd, 'agentic', 'orchestrator');
+    const orchestratorDir = path.join(cwd, 'config', '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');
+    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');
+    expect(result.data.skipped).toContain('config/agentic/orchestrator/gates.yaml');
+    expect(result.data.skipped).toContain('config/agentic/orchestrator/agents.yaml');
     // Skipped files are not validated — no errors from their existing (partial) content
     expect(result.data.validation_warnings).toHaveLength(0);
   });
@@ -400,13 +476,16 @@ describe('InitCommandHandler codex activity detector branch', () => {
       '3',
       '3000',
       'none',
-      'vitest'
+      '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');
+    const adaptersContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'adapters.yaml'),
+      'utf8',
+    );
     expect(adaptersContent).toContain('activity-detector: codex-rpc');
   });
 });
@@ -438,13 +517,16 @@ describe('InitCommandHandler webhook channel branch', () => {
       '3000',
       'webhook',
       'jest',
-      'https://example.com/my-webhook'
+      'https://example.com/my-webhook',
     ]);
     const handler = new InitCommandHandler(cwd, prompts.factory);
     const result = await handler.execute({ auto: false });
 
     expect(result.ok).toBe(true);
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('url: "https://example.com/my-webhook"');
   });
 });
@@ -475,13 +557,16 @@ describe('InitCommandHandler parseNotificationChannels none branch', () => {
       '3',
       '3000',
       'none',
-      'jest'
+      'jest',
     ]);
     const handler = new InitCommandHandler(cwd, prompts.factory);
     const result = await handler.execute({ auto: false });
 
     expect(result.ok).toBe(true);
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     expect(policyContent).toContain('notifications:');
   });
 });
@@ -505,8 +590,9 @@ describe('InitCommandHandler loadTemplateFiles non-file entry', () => {
     execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
 
     const readdirSpy = vi.spyOn(fs, 'readdir').mockImplementation(async (dirPath, opts) => {
-      const originalReaddir = (await vi.importActual<typeof FsPromises>('node:fs/promises')).readdir;
-      const entries = await (originalReaddir)(dirPath, opts as never);
+      const originalReaddir = (await vi.importActual<typeof FsPromises>('node:fs/promises'))
+        .readdir;
+      const entries = await originalReaddir(dirPath, opts as never);
       const fakeDir = {
         name: 'subdir',
         isFile: () => false,
@@ -517,7 +603,7 @@ describe('InitCommandHandler loadTemplateFiles non-file entry', () => {
         isSocket: () => false,
         isSymbolicLink: () => false,
         parentPath: String(dirPath),
-        path: String(dirPath)
+        path: String(dirPath),
       };
       return [...entries, fakeDir] as never;
     });
@@ -553,16 +639,19 @@ describe('InitCommandHandler parseInteger out-of-range and parseFramework fallba
       'custom',
       'local-default',
       'github',
-      '0',    // out of range (min=1) → parseInteger returns fallback 3
+      '0', // out of range (min=1) → parseInteger returns fallback 3
       '3000',
       'none',
-      'vitest'
+      'vitest',
     ]);
     const handler = new InitCommandHandler(cwd, prompts.factory);
     const result = await handler.execute({ auto: false });
 
     expect(result.ok).toBe(true);
-    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     // Falls back to default 3
     expect(policyContent).toContain('max_parallel_gate_runs: 3');
   });
@@ -580,7 +669,7 @@ describe('InitCommandHandler parseInteger out-of-range and parseFramework fallba
       '3',
       '3000',
       'none',
-      'unknown_framework'  // not vitest/jest/pytest/maven/gradle → parseFramework returns fallback
+      'unknown_framework', // not vitest/jest/pytest/maven/gradle → parseFramework returns fallback
     ]);
     const handler = new InitCommandHandler(cwd, prompts.factory);
     const result = await handler.execute({ auto: false });
@@ -611,7 +700,10 @@ describe('InitCommandHandler lean vs advanced policy', () => {
     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');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     // Lean policy contains common controls
     expect(policyContent).toContain('worktree:');
     expect(policyContent).toContain('base_branch:');
@@ -638,7 +730,10 @@ describe('InitCommandHandler lean vs advanced policy', () => {
     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');
+    const policyContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+      'utf8',
+    );
     // Full policy contains advanced controls
     expect(policyContent).toContain('commit_policy:');
     expect(policyContent).toContain('patch_policy:');