agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -8,20 +8,26 @@ 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';
 import { HelpCommandHandler } from '../src/cli/help-command-handler.js';
 
 function makePromptFactory(responses: string[]) {
-  const question = vi.fn(async () => responses.shift() ?? '');
+  const question = vi.fn(async (_query: string) => responses.shift() ?? '');
   const close = vi.fn();
   const factory = vi.fn(() => ({ question, close }));
   return { factory, question, close };
@@ -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,69 @@ 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');
+    expect(agentsContent).not.toContain('provider_config_env:');
 
-    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 +133,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 +144,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 +158,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 +176,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 +191,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 +199,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 +234,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 +249,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 +261,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 +269,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 +285,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 +318,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 +327,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,18 +338,191 @@ 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');
+    expect(agentsContent).not.toContain('provider_config_env:');
 
-    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');
   });
+
+  it('GIVEN_interactive_local_cli_mode_WHEN_init_runs_THEN_provider_env_prompt_is_skipped_and_agents_yaml_omits_provider_config_env', 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',
+      'yes',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    expect(
+      prompts.question.mock.calls.some((call) =>
+        String(call[0]).includes('Provider config env var name'),
+      ),
+    ).toBe(false);
+
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'agents.yaml'),
+      'utf8',
+    );
+    expect(agentsContent).not.toContain('provider_config_env:');
+  });
+
+  it('GIVEN_api_backed_mode_with_existing_env_var_WHEN_init_runs_THEN_agents_yaml_uses_that_env_var', 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: '' });
+    process.env.GEMINI_API_KEY = 'existing-key';
+
+    const prompts = makePromptFactory([
+      'main',
+      'gemini',
+      'gemini-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest',
+      'no',
+      'GEMINI_API_KEY',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false }).finally(() => {
+      delete process.env.GEMINI_API_KEY;
+    });
+
+    expect(result.ok).toBe(true);
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'agents.yaml'),
+      'utf8',
+    );
+    expect(agentsContent).toContain('provider_config_env: GEMINI_API_KEY');
+  });
+
+  it('GIVEN_api_backed_mode_with_env_var_in_dotenv_WHEN_init_runs_THEN_agents_yaml_uses_that_env_var_without_bootstrap_prompt', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(path.join(cwd, '.git', 'config'), '[core]\n', 'utf8');
+    await fs.writeFile(path.join(cwd, '.env'), 'GEMINI_API_KEY=dotenv-key\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const prompts = makePromptFactory([
+      'main',
+      'gemini',
+      'gemini-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest',
+      'no',
+      'GEMINI_API_KEY',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    expect(
+      prompts.question.mock.calls.some((call) =>
+        String(call[0]).includes('Paste provider key to store in AOP_PROVIDER_CONFIG_ENV'),
+      ),
+    ).toBe(false);
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'agents.yaml'),
+      'utf8',
+    );
+    expect(agentsContent).toContain('provider_config_env: GEMINI_API_KEY');
+  });
+
+  it('GIVEN_api_backed_mode_with_missing_env_var_WHEN_init_runs_THEN_bootstraps_AOP_provider_env_in_dotenv', 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',
+      'gemini',
+      'gemini-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest',
+      'no',
+      'GEMINI_API_KEY',
+      'bootstrap-secret',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.next_steps).toContain(
+      'Stored provider credential in .env as AOP_PROVIDER_CONFIG_ENV.',
+    );
+
+    const agentsContent = await fs.readFile(
+      path.join(cwd, 'config', 'agentic', 'orchestrator', 'agents.yaml'),
+      'utf8',
+    );
+    expect(agentsContent).toContain('provider_config_env: AOP_PROVIDER_CONFIG_ENV');
+
+    const envContent = await fs.readFile(path.join(cwd, '.env'), 'utf8');
+    expect(envContent).toContain('AOP_PROVIDER_CONFIG_ENV=bootstrap-secret');
+  });
+
+  it('GIVEN_existing_AOP_provider_env_in_dotenv_WHEN_init_bootstraps_again_THEN_replaces_existing_value_without_duplication', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(path.join(cwd, '.git', 'config'), '[core]\n', 'utf8');
+    await fs.writeFile(path.join(cwd, '.env'), 'FOO=bar\nAOP_PROVIDER_CONFIG_ENV=old\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const prompts = makePromptFactory([
+      'main',
+      'gemini',
+      'gemini-default',
+      'github',
+      '3',
+      '3000',
+      'none',
+      'vitest',
+      'no',
+      'MISSING_ENV_VAR',
+      'new-secret',
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    const envContent = await fs.readFile(path.join(cwd, '.env'), 'utf8');
+    expect(envContent).toContain('FOO=bar');
+    expect(envContent).toContain('AOP_PROVIDER_CONFIG_ENV=new-secret');
+    expect((envContent.match(/AOP_PROVIDER_CONFIG_ENV=/g) ?? []).length).toBe(1);
+  });
 });
 
 describe('InitCommandHandler validation branches', () => {
@@ -306,7 +539,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 +550,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 +560,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 +575,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 +589,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 +641,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 +682,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 +722,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 +755,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 +768,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 +804,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 +834,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 +865,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 +895,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:');