agentic-orchestrator 0.1.2 → 0.1.4

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

@@ -0,0 +1,560 @@
+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';
+
+// ── hoisted mocks ─────────────────────────────────────────────────────────────
+
+const ensureLoadedMock = vi.hoisted(() => vi.fn(async () => undefined));
+const createToolingRuntimeMock = vi.hoisted(() => vi.fn(async () => ({ runtime: 'ok' })));
+const resolveToolClientMock = vi.hoisted(() => vi.fn());
+const toolCallMock = vi.hoisted(() => vi.fn(async () => ({ ok: true, data: {} })));
+const readlineQuestionMock = vi.hoisted(() => vi.fn(async () => ''));
+const readlineCloseMock = vi.hoisted(() => vi.fn());
+
+vi.mock('node:readline/promises', () => ({
+  default: {
+    createInterface: vi.fn(() => ({
+      question: readlineQuestionMock,
+      close: readlineCloseMock
+    }))
+  }
+}));
+
+vi.mock('../src/core/kernel.js', () => {
+  class AopKernel {
+    private readonly repoRoot: string;
+
+    constructor(repoRoot: string) {
+      this.repoRoot = repoRoot;
+    }
+
+    async ensureLoaded() {
+      await ensureLoadedMock();
+    }
+
+    getRepoRoot() {
+      return this.repoRoot;
+    }
+
+    getAgentsConfig() {
+      return {};
+    }
+
+    getRbacPolicy() {
+      return {};
+    }
+
+    getPolicySnapshot() {
+      return {};
+    }
+
+    setProvider() {
+      // no-op for CLI tests
+    }
+  }
+
+  return { AopKernel };
+});
+
+vi.mock('../src/mcp/runtime-factory.js', () => ({
+  createToolingRuntime: createToolingRuntimeMock,
+  resolveToolClient: resolveToolClientMock
+}));
+
+vi.mock('../src/cli/init-command-handler.js', () => ({
+  InitCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({
+      ok: true,
+      data: {
+        command: 'init',
+        created: [],
+        updated: [],
+        skipped: [],
+        validation_warnings: [],
+        next_steps: []
+      }
+    }))
+  }))
+}));
+
+vi.mock('../src/cli/dashboard-command-handler.js', () => ({
+  DashboardCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { message: 'started', port: 3000 } }))
+  }))
+}));
+
+vi.mock('../src/cli/run-command-handler.js', () => ({
+  RunCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { status: 'running' } }))
+  }))
+}));
+
+vi.mock('../src/cli/resume-command-handler.js', () => ({
+  ResumeCommandHandler: vi.fn().mockImplementation(() => ({
+    execute: vi.fn(async () => ({ ok: true, data: { resumed: false } }))
+  }))
+}));
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function asJsonWrites(spy: ReturnType<typeof vi.spyOn>): unknown[] {
+  return spy.mock.calls.flatMap((call) => {
+    try {
+      const arg = call[0];
+      if (typeof arg === 'string') {
+        return [JSON.parse(arg)];
+      }
+      return [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+async function writeMultiProjectYaml(dir: string, content: string): Promise<void> {
+  const configDir = path.join(dir, 'agentic', 'orchestrator');
+  await fs.mkdir(configDir, { recursive: true });
+  await fs.writeFile(path.join(configDir, 'multi-project.yaml'), content, 'utf8');
+}
+
+async function writeSchemaFile(dir: string): Promise<void> {
+  const schemasDir = path.join(dir, 'agentic', 'orchestrator', 'schemas');
+  await fs.mkdir(schemasDir, { recursive: true });
+  const repoRoot = path.resolve(import.meta.dirname, '../../../');
+  const srcSchema = path.join(repoRoot, 'agentic', 'orchestrator', 'schemas', 'multi-project.schema.json');
+  const destSchema = path.join(schemasDir, 'multi-project.schema.json');
+  await fs.copyFile(srcSchema, destSchema);
+}
+
+// ── tests ─────────────────────────────────────────────────────────────────────
+
+describe('bootstrap runCli', () => {
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockClear();
+    ensureLoadedMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    stdoutSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  it('GIVEN_stop_command_WHEN_executed_THEN_returns_stop_not_implemented_yet', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['stop'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({ ok: true, data: { status: 'stop_not_implemented_yet' } });
+  });
+
+  it('GIVEN_delete_command_with_feature_id_and_yes_WHEN_executed_THEN_calls_toolClient', async () => {
+    toolCallMock.mockResolvedValueOnce({ ok: true, data: { deleted: true } });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['delete', '--feature-id', 'feat_x', '--yes'], {
+      cwd: '/tmp',
+      env: process.env
+    });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalled();
+    expect(writes[0]).toMatchObject({ ok: true, data: { command: 'delete' } });
+  });
+
+  it('GIVEN_retry_command_with_feature_id_no_force_WHEN_executed_THEN_runs_gate_retry_without_reset', async () => {
+    toolCallMock
+      .mockResolvedValueOnce({ ok: true, data: { front_matter: { version: 1, status: 'qa' } } })
+      .mockResolvedValueOnce({ ok: true, data: { overall: 'pass' } });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['retry', '--feature-id', 'feat_x'], {
+      cwd: '/tmp',
+      env: process.env
+    });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: { feature_id: 'feat_x', retry_count_reset: false, retry_executed: true }
+    });
+    expect(toolCallMock).toHaveBeenCalled();
+  });
+
+  it('GIVEN_send_command_with_feature_id_and_message_WHEN_executed_THEN_calls_toolClient_and_returns_ok', async () => {
+    toolCallMock.mockResolvedValueOnce({ ok: true, data: { queued: true } });
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['send', '--feature-id', 'feat_x', '--message', 'hello'], {
+      cwd: '/tmp',
+      env: process.env
+    });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalled();
+    expect(writes[0]).toMatchObject({ ok: true, data: { command: 'send' } });
+  });
+
+  it('GIVEN_attach_command_without_feature_id_WHEN_executed_THEN_returns_exit_code_1', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['attach'], { cwd: '/tmp', env: process.env });
+    // attach without feature_id should fail with an error
+    expect(code).toBe(1);
+  });
+
+  it('GIVEN_cleanup_command_dry_run_WHEN_executed_THEN_returns_would_clean_and_cleaned', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['cleanup', '--dry-run'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: expect.objectContaining({ would_clean: expect.any(Array), cleaned: expect.any(Array) })
+    });
+  });
+
+  it('GIVEN_unknown_command_WHEN_executed_THEN_returns_exit_code_1_with_error', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['unknown-command'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: expect.objectContaining({ message: expect.stringContaining('unknown-command') })
+    });
+  });
+
+  it('GIVEN_init_command_WHEN_executed_THEN_returns_ok', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['init'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({ ok: true, data: { command: 'init' } });
+  });
+
+  it('GIVEN_dashboard_command_WHEN_executed_THEN_returns_ok', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['dashboard'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({ ok: true, data: { port: 3000 } });
+  });
+
+  it('GIVEN_run_command_WHEN_executed_THEN_returns_ok', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['run'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({ ok: true, data: { status: 'running' } });
+  });
+
+  it('GIVEN_resume_command_WHEN_executed_THEN_returns_ok', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['resume'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({ ok: true, data: { resumed: false } });
+  });
+
+  it('GIVEN_ensureLoaded_throws_WHEN_run_command_executed_THEN_returns_exit_code_1', async () => {
+    ensureLoadedMock.mockRejectedValueOnce(
+      Object.assign(new Error('config load failed'), { code: 'CONFIG_LOAD_ERROR' })
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['run'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({ ok: false, error: expect.objectContaining({ message: 'config load failed' }) });
+  });
+
+  it('GIVEN_project_flag_with_no_multi_project_yaml_WHEN_executed_THEN_returns_exit_code_1', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // /tmp has no multi-project.yaml
+    const code = await runCli(['status', '--project', 'alpha'], { cwd: '/tmp', env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: expect.objectContaining({ message: expect.stringContaining('multi-project.yaml') })
+    });
+  });
+});
+
+describe('bootstrap runCli status --all with multi-project yaml', () => {
+  let tmpDir: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-bootstrap-'));
+    await writeSchemaFile(tmpDir);
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockResolvedValue({ ok: true, data: { features: [] } });
+    ensureLoadedMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    vi.clearAllMocks();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('GIVEN_multi_project_yaml_with_2_projects_WHEN_status_all_THEN_aggregates_both_project_statuses', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: proj1
+    path: ${proj1}
+  - name: proj2
+    path: ${proj2}
+`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--all'], { cwd: tmpDir, env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        projects: expect.arrayContaining([
+          expect.objectContaining({ name: 'proj1' }),
+          expect.objectContaining({ name: 'proj2' })
+        ])
+      }
+    });
+  });
+
+  it('GIVEN_multi_project_yaml_where_one_project_errors_WHEN_status_all_THEN_aggregate_includes_error_entry', async () => {
+    const projGood = path.join(tmpDir, 'proj-good');
+    await fs.mkdir(projGood, { recursive: true });
+
+    await writeMultiProjectYaml(
+      tmpDir,
+      `
+version: "1.0"
+projects:
+  - name: proj-good
+    path: ${projGood}
+  - name: proj-bad
+    path: /nonexistent/path/that/will/fail
+`
+    );
+
+    // First project succeeds, second causes ensureLoaded to fail
+    ensureLoadedMock
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(Object.assign(new Error('project load error'), { code: 'CONFIG_LOAD_ERROR' }));
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--all'], { cwd: tmpDir, env: process.env });
+
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    const aggregate = writes[0] as { ok: boolean; data: { projects: Array<{ name: string; status: unknown }> } };
+    expect(aggregate.ok).toBe(true);
+    expect(aggregate.data.projects).toHaveLength(2);
+    const badProject = aggregate.data.projects.find((p) => p.name === 'proj-bad');
+    expect(badProject?.status).toMatchObject({ ok: false });
+  });
+});
+
+describe('bootstrap multi-project selection branches', () => {
+  let tmpDir: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-bootstrap-sel-'));
+    await writeSchemaFile(tmpDir);
+    resolveToolClientMock.mockReturnValue({ call: toolCallMock });
+    toolCallMock.mockResolvedValue({ ok: true, data: { features: [] } });
+    ensureLoadedMock.mockClear();
+    createToolingRuntimeMock.mockClear();
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    vi.clearAllMocks();
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('GIVEN_single_project_multi_yaml_WHEN_status_no_project_flag_THEN_auto_selects_only_project', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    await fs.mkdir(proj1, { recursive: true });
+    await writeMultiProjectYaml(tmpDir, `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`);
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_multi_project_yaml_where_cwd_matches_project_path_WHEN_status_THEN_auto_selects_cwd_project', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // cwd is inside proj1 → selectProjectByCwd should match proj1
+    const code = await runCli(['status'], { cwd: proj1, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_multi_project_yaml_with_default_project_WHEN_status_and_cwd_no_match_THEN_uses_default', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\ndefaults:\n  default_project: proj1\n`
+    );
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    // cwd is tmpDir itself (not a project path) → no cwd match → uses default_project
+    const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_multi_project_yaml_no_default_and_no_tty_WHEN_status_THEN_returns_exit_code_1', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+    );
+
+    // Mock stdin/stdout to simulate non-TTY environment
+    const origStdinIsTTY = process.stdin.isTTY;
+    const origStdoutIsTTY = process.stdout.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true });
+
+    try {
+      const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+      // cwd is tmpDir itself (no project match, no default, non-TTY) → exit code 1
+      const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+      expect(code).toBe(1);
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+    }
+  });
+
+  it('GIVEN_project_flag_and_project_not_found_WHEN_run_THEN_returns_exit_code_1', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    await fs.mkdir(proj1, { recursive: true });
+    await writeMultiProjectYaml(tmpDir, `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n`);
+
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['status', '--project', 'nonexistent'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(1);
+  });
+
+  it('GIVEN_help_command_WHEN_run_THEN_prints_help_and_returns_0', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['help'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+    const helpText = stdoutSpy.mock.calls.map((c) => c[0]).join('');
+    expect(helpText).toContain('Commands:');
+  });
+
+  it('GIVEN_help_command_with_subcommand_WHEN_run_THEN_prints_command_detail', async () => {
+    const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+    const code = await runCli(['help', 'run'], { cwd: tmpDir, env: process.env });
+    expect(code).toBe(0);
+  });
+
+  it('GIVEN_tty_with_multiple_projects_WHEN_user_selects_valid_project_THEN_returns_0', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+    );
+
+    // Simulate TTY and user entering '1' to select first project
+    readlineQuestionMock.mockResolvedValueOnce('1');
+    const origStdinIsTTY = process.stdin.isTTY;
+    const origStdoutIsTTY = process.stdout.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+
+    try {
+      const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+      // cwd doesn't match any project path, no default → TTY → prompts user
+      const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+      expect(code).toBe(0);
+      expect(readlineQuestionMock).toHaveBeenCalled();
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+      readlineQuestionMock.mockReset();
+    }
+  });
+
+  it('GIVEN_tty_with_multiple_projects_WHEN_user_enters_invalid_number_THEN_returns_1', async () => {
+    const proj1 = path.join(tmpDir, 'proj1');
+    const proj2 = path.join(tmpDir, 'proj2');
+    await fs.mkdir(proj1, { recursive: true });
+    await fs.mkdir(proj2, { recursive: true });
+    await writeMultiProjectYaml(
+      tmpDir,
+      `version: "1.0"\nprojects:\n  - name: proj1\n    path: ${proj1}\n  - name: proj2\n    path: ${proj2}\n`
+    );
+
+    // Simulate TTY and user entering 'abc' (invalid number)
+    readlineQuestionMock.mockResolvedValueOnce('abc');
+    const origStdinIsTTY = process.stdin.isTTY;
+    const origStdoutIsTTY = process.stdout.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true, configurable: true });
+
+    try {
+      const { runCli } = await import('../src/interfaces/cli/bootstrap.js');
+      const code = await runCli(['status'], { cwd: tmpDir, env: process.env });
+      // Invalid selection → null returned → exit code 1
+      expect(code).toBe(1);
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: origStdinIsTTY, configurable: true });
+      Object.defineProperty(process.stdout, 'isTTY', { value: origStdoutIsTTY, configurable: true });
+      readlineQuestionMock.mockReset();
+    }
+  });
+});