agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,137 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const runGateModeMock = vi.hoisted(() => vi.fn());
+
+vi.mock('../src/core/gates.js', () => ({
+  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';
+
+describe('incremental gate execution', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-incremental-gates-'));
+    runGateModeMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN fast mode with {base_branch} command WHEN interpolateGateCommands called THEN base_branch substituted', () => {
+    const cmd = ['npx', 'vitest', 'run', '--changed', '{base_branch}'];
+    const result = interpolateGateCommands(cmd, { base_branch: 'main', feature_id: 'feat-1' });
+    expect(result).toEqual(['npx', 'vitest', 'run', '--changed', 'main']);
+  });
+
+  it('GIVEN full mode with {base_branch} command WHEN gatesRun is called THEN command passed through unchanged', async () => {
+    runGateModeMock.mockResolvedValue({
+      overall: 'pass',
+      coverage_status: 'na',
+      evidence_path: path.join(tempDir, 'evidence.json'),
+      latest_path: path.join(tempDir, 'latest.json'),
+      coverage: null,
+      thresholds: {}
+    });
+
+    const profile = {
+      modes: {
+        full: [{ name: 'test_full', cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'], timeout_seconds: 60 }]
+      },
+      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}']);
+  });
+
+  it('GIVEN feature_id in command WHEN interpolateGateCommands called THEN feature_id substituted correctly', () => {
+    const cmd = ['scripts/test.sh', '--feature', '{feature_id}'];
+    const result = interpolateGateCommands(cmd, { base_branch: 'main', feature_id: 'my-feature' });
+    expect(result).toEqual(['scripts/test.sh', '--feature', 'my-feature']);
+  });
+
+  it('GIVEN isIncrementalMode with fast THEN returns true', () => {
+    expect(isIncrementalMode('fast')).toBe(true);
+  });
+
+  it('GIVEN isIncrementalMode with full THEN returns false', () => {
+    expect(isIncrementalMode('full')).toBe(false);
+  });
+
+  it('GIVEN isIncrementalMode with merge THEN returns false', () => {
+    expect(isIncrementalMode('merge')).toBe(false);
+  });
+
+  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' });
+    await fs.writeFile(evidenceFile, initialEvidence, 'utf8');
+    await fs.writeFile(latestFile, initialEvidence, 'utf8');
+
+    runGateModeMock.mockResolvedValue({
+      overall: 'pass',
+      coverage_status: 'na',
+      evidence_path: evidenceFile,
+      latest_path: latestFile,
+      coverage: null,
+      thresholds: {}
+    });
+
+    const profile = {
+      modes: {
+        fast: [{ name: 'test_incremental', cmd: ['npx', 'vitest', 'run', '--changed', '{base_branch}'], timeout_seconds: 60 }]
+      },
+      thresholds: {}
+    };
+
+    const port: GateServicePort = buildPort(tempDir, { profiles: { default: profile } });
+    const service = new GateService(port);
+    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']);
+
+    // Verify evidence files were augmented with incremental metadata
+    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');
+  });
+});
+
+function buildPort(tempDir: string, gatesConfig: Record<string, unknown>): GateServicePort {
+  return {
+    getRepoRoot: () => '/repo',
+    getGatesConfig: () => gatesConfig,
+    getPolicySnapshot: () => ({
+      worktree: { base_branch: 'main' },
+      execution: {
+        retry_policy: { transient_max_retries: 0, transient_error_codes: [] },
+        env_allowlist: [],
+        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: {} }
+    }),
+    updateState: vi.fn().mockResolvedValue({}),
+    worktreePath: () => tempDir,
+    logsPath: () => tempDir,
+    evidencePath: () => tempDir
+  };
+}

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

@@ -0,0 +1,506 @@
+import fs from 'node:fs/promises';
+import type * as FsPromises from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+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 }>;
+    void promise.then(
+      (result) => cb(null, result),
+      (err: Error) => cb(err)
+    );
+  }
+}));
+
+import { InitCommandHandler } from '../src/cli/init-command-handler.js';
+
+function makePromptFactory(responses: string[]) {
+  const question = vi.fn(async () => responses.shift() ?? '');
+  const close = vi.fn();
+  const factory = vi.fn(() => ({ question, close }));
+  return { factory, question, close };
+}
+
+describe('InitCommandHandler', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_git_repo_with_remote_WHEN_auto_init_THEN_generates_valid_config_files', async () => {
+    // Create .git/config with a remote URL
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    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'
+    );
+
+    // Mock git symbolic-ref to return origin/main
+    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.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('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);
+
+    // 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');
+    expect(policyContent).toContain('notifications:');
+
+    const gatesContent = await fs.readFile(path.join(cwd, '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');
+    expect(agentsContent).toContain('version: 1');
+    expect(agentsContent).toContain('roles:');
+
+    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"');
+  });
+
+  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');
+    await fs.mkdir(orchestratorDir, { recursive: true });
+    await fs.writeFile(path.join(orchestratorDir, 'policy.yaml'), 'version: 1\n# existing\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/policy.yaml');
+    expect(result.data.created).not.toContain('agentic/orchestrator/policy.yaml');
+    expect(result.data.updated).not.toContain('agentic/orchestrator/policy.yaml');
+
+    // Verify file was NOT overwritten
+    const content = await fs.readFile(path.join(orchestratorDir, 'policy.yaml'), 'utf8');
+    expect(content).toContain('# existing');
+  });
+
+  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');
+    await fs.mkdir(orchestratorDir, { recursive: true });
+    await fs.writeFile(path.join(orchestratorDir, 'policy.yaml'), 'version: 1\n# existing\n', 'utf8');
+
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    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');
+
+    // Verify file WAS overwritten with generated content
+    const content = await fs.readFile(path.join(orchestratorDir, 'policy.yaml'), 'utf8');
+    expect(content).not.toContain('# existing');
+    expect(content).toContain('framework: vitest');
+  });
+
+  it('GIVEN_non_git_directory_WHEN_init_THEN_uses_defaults', async () => {
+    // No .git directory — git detection should fail gracefully
+    execFileMock.mockRejectedValue(new Error('not a git repository'));
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.created).toContain('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');
+    expect(policyContent).toContain('base_branch: main');
+  });
+
+  it('GIVEN_jest_dependency_in_package_json_WHEN_init_THEN_generates_jest_gate_commands', async () => {
+    await fs.writeFile(
+      path.join(cwd, 'package.json'),
+      JSON.stringify({ devDependencies: { jest: '^29.0.0' } }),
+      '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);
+    const gatesContent = await fs.readFile(path.join(cwd, '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');
+    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');
+    expect(gatesContent).toContain('"pytest"');
+  });
+
+  it('GIVEN_pom_xml_WHEN_init_THEN_generates_maven_gate_commands', async () => {
+    await fs.writeFile(path.join(cwd, 'pom.xml'), '<project></project>', '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');
+    expect(gatesContent).toContain('"mvn"');
+  });
+
+  it('GIVEN_build_gradle_WHEN_init_THEN_generates_gradle_gate_commands', async () => {
+    await fs.writeFile(path.join(cwd, 'build.gradle'), 'plugins {}', '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');
+    expect(gatesContent).toContain('"./gradlew"');
+  });
+
+  it('GIVEN_git_config_without_remote_section_WHEN_init_THEN_uses_null_remote_url', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(
+      path.join(cwd, '.git', 'config'),
+      '[core]\n  repositoryformatversion = 0\n',
+      'utf8'
+    );
+    execFileMock.mockResolvedValue({ stdout: 'origin/develop\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    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');
+    expect(policyContent).toContain('base_branch: develop');
+  });
+
+  it('GIVEN_git_symbolic_ref_returns_no_slash_WHEN_init_THEN_uses_full_ref_as_branch', async () => {
+    await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+    await fs.writeFile(path.join(cwd, '.git', 'config'), '[core]\n', 'utf8');
+    execFileMock.mockResolvedValue({ stdout: 'master\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    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');
+    expect(policyContent).toContain('base_branch: master');
+  });
+
+  it('GIVEN_auto_mode_WHEN_init_THEN_does_not_open_interactive_prompt', async () => {
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+    const prompts = makePromptFactory([]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(prompts.factory).not.toHaveBeenCalled();
+    expect(prompts.question).not.toHaveBeenCalled();
+    expect(prompts.close).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_non_auto_mode_WHEN_init_THEN_uses_prompt_values_for_policy_and_gates', 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([
+      'release',
+      '4',
+      '4500',
+      'desktop,slack',
+      'jest',
+      'https://hooks.slack.example/webhook'
+    ]);
+    const handler = new InitCommandHandler(cwd, prompts.factory);
+    const result = await handler.execute({ auto: false });
+
+    expect(result.ok).toBe(true);
+    expect(prompts.factory).toHaveBeenCalledTimes(1);
+    expect(prompts.close).toHaveBeenCalledTimes(1);
+
+    const policyContent = await fs.readFile(path.join(cwd, 'agentic', 'orchestrator', 'policy.yaml'), 'utf8');
+    expect(policyContent).toContain('base_branch: release');
+    expect(policyContent).toContain('max_parallel_gate_runs: 4');
+    expect(policyContent).toContain('port: 4500');
+    expect(policyContent).toContain('notifications:');
+    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');
+    expect(gatesContent).toContain('"npx"');
+    expect(gatesContent).toContain('"jest"');
+  });
+});
+
+describe('InitCommandHandler validation branches', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-val-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_skipped_file_WHEN_validation_loop_runs_THEN_skipped_rel_is_not_validated', async () => {
+    const orchestratorDir = path.join(cwd, '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');
+    execFileMock.mockResolvedValue({ stdout: 'origin/main\n', stderr: '' });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    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');
+    // Validation warnings should be empty (skipped file is not validated)
+    expect(result.data.validation_warnings).toHaveLength(0);
+  });
+
+  it('GIVEN_schema_registry_validates_to_invalid_WHEN_init_runs_THEN_adds_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').mockResolvedValue({
+      valid: false,
+      errors: [{ message: 'test-schema-error' } as any]
+    });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.validation_warnings.length).toBeGreaterThan(0);
+    expect(result.data.validation_warnings[0]).toContain('test-schema-error');
+    validateSpy.mockRestore();
+  });
+
+  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 handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    expect(result.ok).toBe(true);
+    expect(result.data.validation_warnings.length).toBeGreaterThan(0);
+    expect(result.data.validation_warnings[0]).toContain('Failed to validate');
+    validateSpy.mockRestore();
+  });
+});
+
+describe('InitCommandHandler webhook channel branch', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-webhook-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_auto_false_with_webhook_channel_WHEN_init_THEN_prompts_for_webhook_url', 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',
+      '3',
+      '3000',
+      'webhook',
+      'jest',
+      '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');
+    expect(policyContent).toContain('url: "https://example.com/my-webhook"');
+  });
+});
+
+describe('InitCommandHandler parseNotificationChannels none branch', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-none-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_auto_false_with_none_channel_WHEN_init_THEN_no_channels_enabled', 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',
+      '3',
+      '3000',
+      'none',
+      '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');
+    expect(policyContent).toContain('notifications:');
+  });
+});
+
+describe('InitCommandHandler loadTemplateFiles non-file entry', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-tmpl-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_template_dir_contains_directory_entry_WHEN_auto_init_THEN_skips_non_file_entries', 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 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 fakeDir = {
+        name: 'subdir',
+        isFile: () => false,
+        isDirectory: () => true,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false,
+        isSymbolicLink: () => false,
+        parentPath: String(dirPath),
+        path: String(dirPath)
+      };
+      return [...entries, fakeDir] as never;
+    });
+
+    const handler = new InitCommandHandler(cwd);
+    const result = await handler.execute({ auto: true });
+
+    readdirSpy.mockRestore();
+    expect(result.ok).toBe(true);
+  });
+});
+
+describe('InitCommandHandler parseInteger out-of-range and parseFramework fallback', () => {
+  let cwd: string;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-init-parse-'));
+    execFileMock.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.rm(cwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('GIVEN_out_of_range_maxParallelGateRuns_WHEN_init_THEN_falls_back_to_default', 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',
+      '0',    // out of range (min=1) → parseInteger returns fallback 3
+      '3000',
+      'none',
+      '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');
+    // Falls back to default 3
+    expect(policyContent).toContain('max_parallel_gate_runs: 3');
+  });
+
+  it('GIVEN_unrecognized_framework_WHEN_init_THEN_falls_back_to_default_framework', 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',
+      '3',
+      '3000',
+      'none',
+      '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 });
+
+    expect(result.ok).toBe(true);
+  });
+});