tmux-team 3.0.1 → 3.1.0

package/src/cli.ts

@@ -19,7 +19,8 @@ import { cmdCheck } from './commands/check.js';
 import { cmdCompletion } from './commands/completion.js';
 import { cmdConfig } from './commands/config.js';
 import { cmdPreamble } from './commands/preamble.js';
-import { cmdInstallSkill } from './commands/install-skill.js';
+import { cmdInstall } from './commands/install.js';
+import { cmdSetup } from './commands/setup.js';
 import { cmdLearn } from './commands/learn.js';
 
 // ─────────────────────────────────────────────────────────────
@@ -42,6 +43,8 @@ function parseArgs(argv: string[]): { command: string; args: string[]; flags: Fl
       flags.json = true;
     } else if (arg === '--verbose' || arg === '-v') {
       flags.verbose = true;
+    } else if (arg === '--debug') {
+      flags.debug = true;
     } else if (arg === '--force' || arg === '-f') {
       flags.force = true;
     } else if (arg === '--config') {
@@ -52,6 +55,8 @@ function parseArgs(argv: string[]): { command: string; args: string[]; flags: Fl
       flags.wait = true;
     } else if (arg === '--timeout') {
       flags.timeout = parseTime(argv[++i]);
+    } else if (arg === '--lines') {
+      flags.lines = parseInt(argv[++i], 10) || 100;
     } else if (arg === '--no-preamble') {
       flags.noPreamble = true;
     } else if (arg.startsWith('--pane=')) {
@@ -123,6 +128,7 @@ function main(): void {
       cmdHelp({ showIntro });
     }
     process.exit(ExitCodes.SUCCESS);
+    return;
   }
 
   if (command === '--version' || command === '-V') {
@@ -134,11 +140,18 @@ function main(): void {
   if (command === 'completion') {
     cmdCompletion(args[0]);
     process.exit(ExitCodes.SUCCESS);
+    return;
   }
 
   // Create context for all other commands
   const ctx = createContext({ argv, flags });
 
+  // Warn if not in tmux for commands that require it
+  const TMUX_REQUIRED_COMMANDS = ['talk', 'send', 'check', 'read', 'setup'];
+  if (!process.env.TMUX && TMUX_REQUIRED_COMMANDS.includes(command)) {
+    ctx.ui.warn('Not running inside tmux. Some features may not work.');
+  }
+
   const run = async (): Promise<void> => {
     switch (command) {
       case 'init':
@@ -215,22 +228,12 @@ function main(): void {
         cmdPreamble(ctx, args);
         break;
 
-      case 'install-skill':
-        {
-          // Parse --local or --user flag
-          let scope = 'user';
-          const filteredArgs: string[] = [];
-          for (const arg of args) {
-            if (arg === '--local') {
-              scope = 'local';
-            } else if (arg === '--user') {
-              scope = 'user';
-            } else {
-              filteredArgs.push(arg);
-            }
-          }
-          cmdInstallSkill(ctx, filteredArgs[0], scope);
-        }
+      case 'install':
+        await cmdInstall(ctx, args[0]);
+        break;
+
+      case 'setup':
+        await cmdSetup(ctx);
         break;
 
       case 'learn':

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

@@ -51,10 +51,11 @@ ${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
@@ -68,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();
+  });
+});