tmux-team 3.0.0 → 3.1.0

package/src/commands/basic-commands.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { Context, Flags, Paths, ResolvedConfig, Tmux, UI } from '../types.js';
+import { ExitCodes } from '../exits.js';
+
+import { cmdInit } from './init.js';
+import { cmdAdd } from './add.js';
+import { cmdRemove } from './remove.js';
+import { cmdUpdate } from './update.js';
+import { cmdList } from './list.js';
+import { cmdCheck } from './check.js';
+import { cmdPreamble } from './preamble.js';
+import { cmdConfig } from './config.js';
+import { cmdCompletion } from './completion.js';
+import { cmdHelp } from './help.js';
+import { cmdLearn } from './learn.js';
+
+function createMockUI(): UI & { jsonCalls: unknown[] } {
+  return {
+    jsonCalls: [],
+    info: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    table: vi.fn(),
+    json(data: unknown) {
+      (this as any).jsonCalls.push(data);
+    },
+  } as any;
+}
+
+function createMockTmux(): Tmux {
+  return {
+    send: vi.fn(),
+    capture: vi.fn(() => 'captured'),
+    listPanes: vi.fn(() => []),
+    getCurrentPaneId: vi.fn(() => null),
+  };
+}
+
+function createCtx(
+  testDir: string,
+  overrides?: Partial<{ flags: Partial<Flags>; config: Partial<ResolvedConfig> }>
+): Context {
+  const paths: Paths = {
+    globalDir: testDir,
+    globalConfig: path.join(testDir, 'config.json'),
+    localConfig: path.join(testDir, 'tmux-team.json'),
+    stateFile: path.join(testDir, 'state.json'),
+  };
+  const baseConfig: ResolvedConfig = {
+    mode: 'polling',
+    preambleMode: 'always',
+    defaults: { timeout: 180, pollInterval: 1, captureLines: 100, preambleEvery: 3 },
+    agents: {},
+    paneRegistry: {},
+    ...overrides?.config,
+  };
+  const flags: Flags = { json: false, verbose: false, ...(overrides?.flags ?? {}) } as Flags;
+  const ui = createMockUI();
+  const tmux = createMockTmux();
+  return {
+    argv: [],
+    flags,
+    ui,
+    config: baseConfig,
+    tmux,
+    paths,
+    exit: ((code: number) => {
+      const err = new Error(`exit(${code})`);
+      (err as Error & { exitCode: number }).exitCode = code;
+      throw err;
+    }) as any,
+  };
+}
+
+describe('basic commands', () => {
+  let testDir = '';
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmux-team-cmd-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('cmdInit creates tmux-team.json', () => {
+    const ctx = createCtx(testDir);
+    cmdInit(ctx);
+    expect(fs.existsSync(ctx.paths.localConfig)).toBe(true);
+  });
+
+  it('cmdInit errors if tmux-team.json exists', () => {
+    const ctx = createCtx(testDir);
+    fs.writeFileSync(ctx.paths.localConfig, '{}\n');
+    expect(() => cmdInit(ctx)).toThrow(`exit(${ExitCodes.ERROR})`);
+  });
+
+  it('cmdAdd creates config if missing and writes new agent', () => {
+    const ctx = createCtx(testDir);
+    cmdAdd(ctx, 'codex', '1.1', 'review');
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.codex.pane).toBe('1.1');
+    expect(saved.codex.remark).toBe('review');
+  });
+
+  it('cmdAdd errors if agent exists', () => {
+    const ctx = createCtx(testDir, { config: { paneRegistry: { codex: { pane: '1.1' } } } });
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ codex: { pane: '1.1' } }, null, 2));
+    expect(() => cmdAdd(ctx, 'codex', '1.1')).toThrow(`exit(${ExitCodes.ERROR})`);
+  });
+
+  it('cmdRemove deletes agent', () => {
+    const ctx = createCtx(testDir, { config: { paneRegistry: { codex: { pane: '1.1' } } } });
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ codex: { pane: '1.1' } }, null, 2));
+    cmdRemove(ctx, 'codex');
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.codex).toBeUndefined();
+  });
+
+  it('cmdUpdate updates pane and remark; creates entry if missing', () => {
+    const ctx = createCtx(testDir, { config: { paneRegistry: { codex: { pane: '1.1' } } } });
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({}, null, 2));
+    cmdUpdate(ctx, 'codex', { pane: '2.2', remark: 'new' });
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.codex.pane).toBe('2.2');
+    expect(saved.codex.remark).toBe('new');
+  });
+
+  it('cmdList outputs JSON when --json', () => {
+    const ctx = createCtx(testDir, {
+      flags: { json: true },
+      config: { paneRegistry: { claude: { pane: '1.0', remark: 'main' } } },
+    });
+    cmdList(ctx);
+    expect((ctx.ui as any).jsonCalls.length).toBe(1);
+  });
+
+  it('cmdList prints hint when no agents', () => {
+    const ctx = createCtx(testDir);
+    cmdList(ctx);
+    expect(ctx.ui.info).toHaveBeenCalled();
+  });
+
+  it('cmdList prints table when agents exist', () => {
+    const ctx = createCtx(testDir, {
+      config: { paneRegistry: { claude: { pane: '1.0', remark: 'main' } } },
+    });
+    cmdList(ctx);
+    expect(ctx.ui.table).toHaveBeenCalled();
+  });
+
+  it('cmdCheck captures pane output', () => {
+    const ctx = createCtx(testDir, {
+      config: { paneRegistry: { claude: { pane: '1.0' } } },
+    });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    cmdCheck(ctx, 'claude', 10);
+    expect(ctx.tmux.capture).toHaveBeenCalledWith('1.0', 10);
+    expect(logSpy).toHaveBeenCalled();
+  });
+
+  it('cmdCheck errors when agent missing', () => {
+    const ctx = createCtx(testDir);
+    expect(() => cmdCheck(ctx, 'nope')).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
+  });
+
+  it('cmdCheck outputs JSON when --json', () => {
+    const ctx = createCtx(testDir, {
+      flags: { json: true },
+      config: { paneRegistry: { claude: { pane: '1.0' } } },
+    });
+    cmdCheck(ctx, 'claude', 5);
+    expect((ctx.ui as any).jsonCalls.length).toBe(1);
+  });
+
+  it('cmdPreamble set/show/clear updates local config', () => {
+    const ctx = createCtx(testDir, {
+      config: { paneRegistry: { claude: { pane: '1.0' } }, agents: { claude: {} } },
+    });
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ claude: { pane: '1.0' } }, null, 2));
+
+    cmdPreamble(ctx, ['set', 'claude', 'Be', 'concise']);
+    let saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.claude.preamble).toBe('Be concise');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    // show will read from ctx.config.agents; update it to reflect loadConfig behavior
+    ctx.config.agents.claude = { preamble: 'Be concise' };
+    cmdPreamble(ctx, ['show', 'claude']);
+    expect(logSpy).toHaveBeenCalled();
+
+    cmdPreamble(ctx, ['clear', 'claude']);
+    saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.claude.preamble).toBeUndefined();
+  });
+
+  it('cmdPreamble set errors when agent missing', () => {
+    const ctx = createCtx(testDir);
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({}, null, 2));
+    expect(() => cmdPreamble(ctx, ['set', 'nope', 'x'])).toThrow(`exit(${ExitCodes.ERROR})`);
+  });
+
+  it('cmdPreamble clear returns not_set when missing', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ claude: { pane: '1.0' } }, null, 2));
+    cmdPreamble(ctx, ['clear', 'claude']);
+    const out = (ctx.ui as any).jsonCalls[0] as any;
+    expect(out.status).toBe('not_set');
+  });
+
+  it('cmdConfig set/show/clear works for local settings', () => {
+    const ctx = createCtx(testDir);
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({}, null, 2));
+
+    cmdConfig(ctx, ['set', 'mode', 'wait']);
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.$config.mode).toBe('wait');
+
+    cmdConfig(ctx, ['clear', 'mode']);
+    const saved2 = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved2.$config?.mode).toBeUndefined();
+  });
+
+  it('cmdConfig set supports --global', () => {
+    const ctx = createCtx(testDir);
+    cmdConfig(ctx, ['set', 'mode', 'wait', '--global']);
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.globalConfig, 'utf-8'));
+    expect(saved.mode).toBe('wait');
+  });
+
+  it('cmdCompletion prints scripts', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    cmdCompletion('bash');
+    expect(logSpy.mock.calls.join('\n')).toContain('complete -F _tmux_team');
+
+    logSpy.mockClear();
+    cmdCompletion('zsh');
+    expect(logSpy.mock.calls.join('\n')).toContain('#compdef tmux-team');
+  });
+
+  it('cmdHelp/cmdLearn print output', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    cmdHelp({ mode: 'polling', showIntro: true });
+    cmdHelp({ mode: 'wait', timeout: 10 });
+    cmdLearn();
+    expect(logSpy).toHaveBeenCalled();
+  });
+});

package/src/commands/config-command.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { Context, Flags, Paths, ResolvedConfig, Tmux, UI } from '../types.js';
+import { ExitCodes } from '../exits.js';
+import { cmdConfig } from './config.js';
+
+function createMockUI(): UI & { jsonCalls: unknown[] } {
+  return {
+    jsonCalls: [],
+    info: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    table: vi.fn(),
+    json(data: unknown) {
+      (this as any).jsonCalls.push(data);
+    },
+  } as any;
+}
+
+function createCtx(
+  testDir: string,
+  flags?: Partial<Flags>,
+  configOverrides?: Partial<ResolvedConfig>
+): Context {
+  const paths: Paths = {
+    globalDir: path.join(testDir, 'global'),
+    globalConfig: path.join(testDir, 'global', 'config.json'),
+    localConfig: path.join(testDir, 'tmux-team.json'),
+    stateFile: path.join(testDir, 'global', 'state.json'),
+  };
+  const config: ResolvedConfig = {
+    mode: 'polling',
+    preambleMode: 'always',
+    defaults: { timeout: 180, pollInterval: 1, captureLines: 100, preambleEvery: 3 },
+    agents: {},
+    paneRegistry: {},
+    ...configOverrides,
+  };
+  const tmux: Tmux = {
+    send: vi.fn(),
+    capture: vi.fn(),
+    listPanes: vi.fn(() => []),
+    getCurrentPaneId: vi.fn(() => null),
+  };
+  return {
+    argv: [],
+    flags: { json: false, verbose: false, ...(flags ?? {}) } as Flags,
+    ui: createMockUI(),
+    config,
+    tmux,
+    paths,
+    exit: ((code: number) => {
+      const err = new Error(`exit(${code})`);
+      (err as Error & { exitCode: number }).exitCode = code;
+      throw err;
+    }) as any,
+  };
+}
+
+describe('cmdConfig', () => {
+  let testDir = '';
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmux-team-configcmd-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('shows config as JSON when --json', () => {
+    const ctx = createCtx(testDir, { json: true });
+    cmdConfig(ctx, ['show']);
+    expect((ctx.ui as any).jsonCalls.length).toBe(1);
+    const out = (ctx.ui as any).jsonCalls[0] as any;
+    expect(out.resolved).toBeTruthy();
+    expect(out.sources).toBeTruthy();
+    expect(out.paths).toBeTruthy();
+  });
+
+  it('shows config as table in human mode', () => {
+    const ctx = createCtx(testDir);
+    cmdConfig(ctx, ['show']);
+    expect(ctx.ui.table).toHaveBeenCalled();
+  });
+
+  it('rejects invalid keys and values', () => {
+    const ctx = createCtx(testDir);
+    expect(() => cmdConfig(ctx, ['set', 'nope', 'x'])).toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(() => cmdConfig(ctx, ['set', 'mode', 'nope'])).toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(() => cmdConfig(ctx, ['set', 'preambleEvery', '-1'])).toThrow(
+      `exit(${ExitCodes.ERROR})`
+    );
+  });
+
+  it('sets and clears local settings', () => {
+    const ctx = createCtx(testDir);
+    cmdConfig(ctx, ['set', 'preambleMode', 'disabled']);
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.$config.preambleMode).toBe('disabled');
+
+    cmdConfig(ctx, ['clear']);
+    const saved2 = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved2.$config).toBeUndefined();
+  });
+
+  it('sets global settings with -g', () => {
+    const ctx = createCtx(testDir);
+    cmdConfig(ctx, ['set', 'preambleEvery', '5', '-g']);
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.globalConfig, 'utf-8'));
+    expect(saved.defaults.preambleEvery).toBe(5);
+  });
+});

package/src/commands/help.ts

@@ -8,6 +8,7 @@ import { VERSION } from '../version.js';
 export interface HelpConfig {
   mode?: 'polling' | 'wait';
   timeout?: number;
+  showIntro?: boolean;
 }
 
 export function cmdHelp(config?: HelpConfig): void {
@@ -15,17 +16,28 @@ export function cmdHelp(config?: HelpConfig): void {
   const timeout = config?.timeout ?? 180;
   const isWaitMode = mode === 'wait';
 
+  // Show intro highlight when running just `tmux-team` with no args
+  if (config?.showIntro) {
+    console.log(`
+${colors.cyan('┌─────────────────────────────────────────────────────────────┐')}
+${colors.cyan('│')}  ${colors.yellow('New to tmux-team?')} Run ${colors.green('tmux-team learn')} or ${colors.green('tmt learn')}         ${colors.cyan('│')}
+${colors.cyan('│')}  ${colors.dim('tmt is a shorthand alias for tmux-team')}                      ${colors.cyan('│')}
+${colors.cyan('└─────────────────────────────────────────────────────────────┘')}`);
+  }
+
   // Mode indicator with clear explanation
   const modeInfo = isWaitMode
-    ? `${colors.yellow('CURRENT MODE')}: ${colors.green('wait')} (timeout: ${timeout}s)
+    ? `${colors.yellow('CURRENT MODE')}: ${colors.green('wait')} (timeout: ${timeout}s) ${colors.green('✓ recommended')}
   ${colors.dim('→ talk commands will BLOCK until agent responds or timeout')}
   ${colors.dim('→ Response is returned directly, no need to use check command')}`
     : `${colors.yellow('CURRENT MODE')}: ${colors.cyan('polling')}
   ${colors.dim('→ talk commands send and return immediately')}
-  ${colors.dim('→ Use check command to read agent response')}`;
+  ${colors.dim('→ Use check command to read agent response')}
+  ${colors.dim('→')} ${colors.yellow('TIP')}: ${colors.dim('Use --wait or set mode to wait for better token utilization')}`;
 
   console.log(`
 ${colors.cyan('tmux-team')} v${VERSION} - AI agent collaboration in tmux
+${colors.dim('Alias: tmt')}
 
 ${modeInfo}
 
@@ -39,11 +51,13 @@ ${colors.yellow('COMMANDS')}
   ${colors.green('add')} <name> <pane> [remark]  Add a new agent
   ${colors.green('update')} <name> [options]     Update an agent's config
   ${colors.green('remove')} <name>               Remove an agent
+  ${colors.green('install')} [claude|codex]       Install tmux-team for an AI agent
+  ${colors.green('setup')}                       Interactive wizard to configure agents
   ${colors.green('init')}                        Create empty tmux-team.json
   ${colors.green('config')} [show|set|clear]     View/modify settings
   ${colors.green('preamble')} [show|set|clear]   Manage agent preambles
-  ${colors.green('install-skill')} <agent>       Install skill for AI agent
   ${colors.green('completion')}                  Output shell completion script
+  ${colors.green('learn')}                       Show educational guide
   ${colors.green('help')}                        Show this help message
 
 ${colors.yellow('OPTIONS')}
@@ -55,7 +69,9 @@ ${colors.yellow('TALK OPTIONS')}
   ${colors.green('--delay')} <seconds>           Wait before sending
   ${colors.green('--wait')}                      Force wait mode (block until response)
   ${colors.green('--timeout')} <seconds>         Max wait time (current: ${timeout}s)
+  ${colors.green('--lines')} <number>            Lines to capture (default: 100)
   ${colors.green('--no-preamble')}               Skip agent preamble for this message
+  ${colors.green('--debug')}                     Show debug output
 
 ${colors.yellow('EXAMPLES')}${
     isWaitMode

package/src/commands/install.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import type { Context, Flags, Paths, ResolvedConfig, Tmux, UI } from '../types.js';
+import { ExitCodes } from '../exits.js';
+
+function createMockUI(): UI {
+  return {
+    info: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    table: vi.fn(),
+    json: vi.fn(),
+  };
+}
+
+function createCtx(testDir: string, overrides?: Partial<{ flags: Partial<Flags> }>): Context {
+  const paths: Paths = {
+    globalDir: testDir,
+    globalConfig: path.join(testDir, 'config.json'),
+    localConfig: path.join(testDir, 'tmux-team.json'),
+    stateFile: path.join(testDir, 'state.json'),
+  };
+  const config: ResolvedConfig = {
+    mode: 'polling',
+    preambleMode: 'always',
+    defaults: { timeout: 180, pollInterval: 1, captureLines: 100, preambleEvery: 3 },
+    agents: {},
+    paneRegistry: {},
+  };
+  const flags: Flags = { json: false, verbose: false, ...(overrides?.flags ?? {}) } as Flags;
+  const tmux: Tmux = {
+    send: vi.fn(),
+    capture: vi.fn(),
+    listPanes: vi.fn(() => []),
+    getCurrentPaneId: vi.fn(() => null),
+  };
+  return {
+    argv: [],
+    flags,
+    ui: createMockUI(),
+    config,
+    tmux,
+    paths,
+    exit: ((code: number) => {
+      const err = new Error(`exit(${code})`);
+      (err as Error & { exitCode: number }).exitCode = code;
+      throw err;
+    }) as any,
+  };
+}
+
+describe('cmdInstall', () => {
+  let testDir = '';
+  let homeDir = '';
+  const originalHome = process.env.HOME;
+  const originalTmux = process.env.TMUX;
+  const originalCodexHome = process.env.CODEX_HOME;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmux-team-install-'));
+    homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmux-team-home-'));
+    process.env.HOME = homeDir;
+    process.env.CODEX_HOME = path.join(homeDir, '.codex');
+    delete process.env.TMUX;
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    process.env.TMUX = originalTmux;
+    process.env.CODEX_HOME = originalCodexHome;
+    fs.rmSync(testDir, { recursive: true, force: true });
+    fs.rmSync(homeDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('installs claude skill when agent is provided', async () => {
+    vi.resetModules();
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(''),
+        close: () => {},
+      }),
+    }));
+
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir, { flags: { force: true } });
+    await cmdInstall(ctx, 'claude');
+
+    const installed = path.join(homeDir, '.claude', 'commands', 'team.md');
+    expect(fs.existsSync(installed)).toBe(true);
+  });
+
+  it('errors on unknown agent', async () => {
+    vi.resetModules();
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(''),
+        close: () => {},
+      }),
+    }));
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir);
+    await expect(cmdInstall(ctx, 'nope')).rejects.toThrow(`exit(${ExitCodes.ERROR})`);
+  });
+
+  it('prompts when environment is not detected', async () => {
+    vi.resetModules();
+    const answers = ['codex'];
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(answers.shift() ?? ''),
+        close: () => {},
+      }),
+    }));
+
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir, { flags: { force: true } });
+    await cmdInstall(ctx);
+
+    const installed = path.join(homeDir, '.codex', 'skills', 'tmux-team', 'SKILL.md');
+    expect(fs.existsSync(installed)).toBe(true);
+  });
+
+  it('auto-selects detected environment when exactly one is found', async () => {
+    vi.resetModules();
+    fs.mkdirSync(path.join(homeDir, '.claude'), { recursive: true });
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(''),
+        close: () => {},
+      }),
+    }));
+
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir, { flags: { force: true } });
+    await cmdInstall(ctx);
+    expect(fs.existsSync(path.join(homeDir, '.claude', 'commands', 'team.md'))).toBe(true);
+  });
+
+  it('prompts when multiple environments are detected', async () => {
+    vi.resetModules();
+    fs.mkdirSync(path.join(homeDir, '.claude'), { recursive: true });
+    fs.mkdirSync(path.join(homeDir, '.codex'), { recursive: true });
+
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+
+    const answers = ['claude'];
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(answers.shift() ?? ''),
+        close: () => {},
+      }),
+    }));
+
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir, { flags: { force: true } });
+    await cmdInstall(ctx);
+    expect(fs.existsSync(path.join(homeDir, '.claude', 'commands', 'team.md'))).toBe(true);
+  });
+
+  it('fails if skill exists and --force is not set', async () => {
+    vi.resetModules();
+    vi.doMock('node:os', () => ({
+      default: { homedir: () => homeDir },
+      homedir: () => homeDir,
+    }));
+    vi.doMock('node:readline', () => ({
+      createInterface: () => ({
+        question: (_q: string, cb: (a: string) => void) => cb(''),
+        close: () => {},
+      }),
+    }));
+
+    const target = path.join(homeDir, '.claude', 'commands', 'team.md');
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, 'existing');
+
+    const { cmdInstall } = await import('./install.js');
+    const ctx = createCtx(testDir);
+    await expect(cmdInstall(ctx, 'claude')).rejects.toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(ctx.ui.warn).toHaveBeenCalled();
+  });
+});