tmux-team 3.2.4 → 4.0.0-beta.0

package/README.md

@@ -16,60 +16,86 @@ npm install -g tmux-team
 
 ```bash
 # 1. Install for your AI agent
-tmux-team install claude   # or: tmux-team install codex
+tmt install claude   # or: tmt install codex
 
-# 2. Run the setup wizard (auto-detects panes)
-tmux-team setup
+# 2. Go to working folder and initialize
+tmt init
 
-# 3. Talk to agents
-tmux-team talk codex "Review this code" --wait
+# 3. Register agents (run inside each agent's pane)
+tmt this claude      # registers current pane as "claude"
+tmt this codex       # registers current pane as "codex"
+
+# 4. Talk to agents
+tmt talk codex "Review this code"    # waits for response by default
+
+# 5. Update or remove an agent
+tmt update codex --pane 2.3
+tmt rm codex
 ```
 
-The `--wait` flag blocks until the agent responds, returning the response directly.
+> **Tip:** Most AI agents support `!` to run bash commands. From inside Claude Code, Codex, or Gemini CLI, you can run `!tmt this myname` to quickly register that pane.
+
+## Cross-Folder Collaboration
+
+Agents don't need to be in the same folder to collaborate. You can add an agent from one project to another:
+
+```bash
+# In project-a folder, add an agent that's running in project-b
+tmt add codex-reviewer 5.1    # Use the pane ID from the other project
+```
+
+Find pane IDs with: `tmux display-message -p "#{pane_id}"`
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `install [claude\|codex]` | Install tmux-team for an AI agent |
-| `setup` | Interactive wizard to configure agents |
-| `talk <agent> "msg" --wait` | Send message and wait for response |
-| `talk all "msg" --wait` | Broadcast to all agents |
-| `check <agent> [lines]` | Read agent's pane output (fallback if --wait times out) |
+| `this <name> [remark]` | Register current pane as an agent |
+| `talk <agent> "msg"` | Send message and wait for response |
+| `talk all "msg"` | Broadcast to all agents |
+| `check <agent> [lines]` | Read agent's pane output |
 | `list` | Show configured agents |
 | `learn` | Show educational guide |
 
-**Options for `talk --wait`:**
+**Options for `talk`:**
 - `--timeout <seconds>` - Max wait time (default: 180s)
 - `--lines <number>` - Lines to capture from response (default: 100)
 
-Run `tmux-team help` for all commands and options.
+Run `tmt help` for all commands and options.
 
-## Managing Your Team
+## Message Delivery
 
-Configuration lives in `tmux-team.json` in your project root.
+tmux-team uses tmux buffers + paste, then waits briefly before sending Enter. This avoids shell history expansion and handles paste-safety windows in CLIs like Gemini.
+
+**Config:** `pasteEnterDelayMs` (default: 500)
 
-**Create** - Run the setup wizard to auto-detect agents:
 ```bash
-tmux-team setup
+tmt config set pasteEnterDelayMs 500
 ```
 
-**Read** - List configured agents:
+## Managing Your Team
+
+Configuration lives in `tmux-team.json` in your project root.
+
+**List** - Show configured agents:
 ```bash
-tmux-team list
+tmt ls
 ```
 
-**Update** - Edit `tmux-team.json` directly or re-run setup:
+**Edit** - Modify `tmux-team.json` directly:
 ```json
 {
-  "codex": { "pane": "%1", "remark": "Code reviewer" },
-  "gemini": { "pane": "%2", "remark": "Documentation" }
+  "$config": { "pasteEnterDelayMs": 500 },
+  "codex": { "pane": "1.1", "remark": "Code reviewer" },
+  "gemini": { "pane": "1.2", "remark": "Documentation" }
 }
 ```
 
-**Delete** - Remove an agent entry from `tmux-team.json` or delete the file entirely.
-
-Find pane IDs: `tmux display-message -p "#{pane_id}"`
+**Remove** - Delete an agent:
+```bash
+tmt rm codex
+```
 
 ## Claude Code Plugin
 
@@ -88,8 +114,8 @@ Run this once when starting a session. Claude will understand how to coordinate
 
 **`/team`** - Talk to other agents
 ```
-/team talk codex "Review my authentication changes" --wait
-/team talk all "I'm starting the database migration" --wait
+/team talk codex "Review my authentication changes"
+/team talk all "I'm starting the database migration"
 /team list
 ```
 Use this to delegate tasks, ask for reviews, or broadcast updates.
@@ -97,8 +123,8 @@ Use this to delegate tasks, ask for reviews, or broadcast updates.
 ## Learn More
 
 ```bash
-tmux-team learn   # Comprehensive guide
-tmux-team help    # All commands and options
+tmt learn   # Comprehensive guide
+tmt help    # All commands and options
 ```
 
 ## License

package/package.json

@@ -1,25 +1,12 @@
 {
   "name": "tmux-team",
-  "version": "3.2.4",
+  "version": "4.0.0-beta.0",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {
     "tmux-team": "./bin/tmux-team",
     "tmt": "./bin/tmux-team"
   },
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "tmt": "./bin/tmux-team",
-    "test": "pnpm test:run",
-    "test:watch": "vitest",
-    "test:run": "vitest run --coverage && node scripts/check-coverage.mjs --threshold 95",
-    "lint": "oxlint src/",
-    "lint:fix": "oxlint src/ --fix",
-    "format": "prettier --write src/",
-    "format:check": "prettier --check src/",
-    "type:check": "tsc --noEmit",
-    "check": "pnpm type:check && pnpm lint && pnpm format:check"
-  },
   "keywords": [
     "tmux",
     "cli",
@@ -37,7 +24,6 @@
   "engines": {
     "node": ">=18"
   },
-  "packageManager": "pnpm@9.15.4",
   "os": [
     "darwin",
     "linux"
@@ -57,5 +43,18 @@
     "prettier": "^3.7.4",
     "typescript": "^5.3.0",
     "vitest": "^1.2.0"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "tmt": "./bin/tmux-team",
+    "test": "pnpm test:run",
+    "test:watch": "vitest",
+    "test:run": "vitest run --coverage && node scripts/check-coverage.mjs --threshold 90 --branches 85",
+    "lint": "oxlint src/",
+    "lint:fix": "oxlint src/ --fix",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "type:check": "tsc --noEmit",
+    "check": "pnpm type:check && pnpm lint && pnpm format:check"
   }
-}
+}

package/skills/README.md

@@ -29,7 +29,7 @@ tmux-team install claude
 tmux-team install codex
 ```
 
-After installation, run `tmux-team setup` to configure your agents interactively.
+After installation, run `tmux-team add <name> <pane>` to register your agents, or use `tmux-team this <name>` inside each agent's tmux pane.
 
 ## Claude Code
 

package/skills/claude/team.md

@@ -39,8 +39,8 @@ tmux-team list
 
 ## Notes
 
-- `talk` automatically sends Enter key after the message
-- `talk` automatically filters exclamation marks for Gemini (TTY issue)
+- `talk` sends via tmux buffer paste, then waits briefly before Enter
+- Control the delay with `pasteEnterDelayMs` in config (default: 500)
 - Use `--delay` instead of sleep (safer for tool whitelists)
 - Use `--wait` for synchronous request-response patterns
 - Run `tmux-team help` for full CLI documentation

package/skills/codex/SKILL.md

@@ -39,8 +39,8 @@ tmux-team list
 
 ## Notes
 
-- `talk` automatically sends Enter key after the message
-- `talk` automatically filters exclamation marks for Gemini (TTY issue)
+- `talk` sends via tmux buffer paste, then waits briefly before Enter
+- Control the delay with `pasteEnterDelayMs` in config (default: 500)
 - Use `--delay` instead of sleep (safer for tool whitelists)
 - Use `--wait` for synchronous request-response patterns
 - Run `tmux-team help` for full CLI documentation

package/src/cli.test.ts

@@ -16,7 +16,7 @@ function makeStubContext(): Context {
     config: {
       mode: 'polling',
       preambleMode: 'always',
-      defaults: { timeout: 180, pollInterval: 1, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 },
+      defaults: { timeout: 180, pollInterval: 1, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 },
       agents: {},
       paneRegistry: {},
     },
@@ -160,4 +160,430 @@ describe('cli', () => {
     expect(errSpy).toHaveBeenCalledWith(JSON.stringify({ error: 'boom' }));
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
+
+  it('routes install command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'install', 'claude'];
+
+    const ctx = makeStubContext();
+    const installSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/install.js', () => ({ cmdInstall: installSpy }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    // allow async to resolve
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(installSpy).toHaveBeenCalledWith(ctx, 'claude');
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('routes preamble command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'preamble', 'show'];
+
+    const ctx = makeStubContext();
+    const preambleSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/preamble.js', () => ({ cmdPreamble: preambleSpy }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(preambleSpy).toHaveBeenCalledWith(ctx, ['show']);
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('routes this command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'this', 'myagent', 'remark'];
+
+    const ctx = makeStubContext();
+    const thisSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/this.js', () => ({ cmdThis: thisSpy }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(thisSpy).toHaveBeenCalledWith(ctx, 'myagent', 'remark');
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('errors when this command is missing name', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'this'];
+
+    const ctx = makeStubContext();
+    const exitSpy = vi.fn();
+    ctx.exit = exitSpy as any;
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/this.js', () => ({ cmdThis: vi.fn() }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalledWith('Usage: tmux-team this <name> [remark]');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('routes update command with --pane and --remark flags', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'update', 'codex', '--pane', '2.0', '--remark', 'updated'];
+
+    const ctx = makeStubContext();
+    const updateSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/update.js', () => ({ cmdUpdate: updateSpy }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(updateSpy).toHaveBeenCalledWith(ctx, 'codex', { pane: '2.0', remark: 'updated' });
+  });
+
+  it('routes init command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'init'];
+
+    const ctx = makeStubContext();
+    const initSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/init.js', () => ({ cmdInit: initSpy }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(initSpy).toHaveBeenCalledWith(ctx);
+  });
+
+  it('routes list command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'list'];
+
+    const ctx = makeStubContext();
+    const listSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/list.js', () => ({ cmdList: listSpy }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(listSpy).toHaveBeenCalledWith(ctx);
+  });
+
+  it('routes ls alias to list command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'ls'];
+
+    const ctx = makeStubContext();
+    const listSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/list.js', () => ({ cmdList: listSpy }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(listSpy).toHaveBeenCalledWith(ctx);
+  });
+
+  it('routes add command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'add', 'myagent', '1.0', 'remark'];
+
+    const ctx = makeStubContext();
+    const addSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/add.js', () => ({ cmdAdd: addSpy }));
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(addSpy).toHaveBeenCalledWith(ctx, 'myagent', '1.0', 'remark');
+  });
+
+  it('routes config command', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'config', 'get', 'mode'];
+
+    const ctx = makeStubContext();
+    const configSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/config.js', () => ({ cmdConfig: configSpy }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(configSpy).toHaveBeenCalledWith(ctx, ['get', 'mode']);
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('parses --timeout flag with seconds', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'talk', 'claude', 'hi', '--timeout', '30'];
+
+    const ctx = makeStubContext();
+    const talkSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: (opts: any) => {
+        ctx.flags = opts.flags;
+        return ctx;
+      },
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/talk.js', () => ({ cmdTalk: talkSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.flags.timeout).toBe(30);
+  });
+
+  it('parses --timeout flag with ms suffix', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'talk', 'claude', 'hi', '--timeout', '500ms'];
+
+    const ctx = makeStubContext();
+    const talkSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: (opts: any) => {
+        ctx.flags = opts.flags;
+        return ctx;
+      },
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/talk.js', () => ({ cmdTalk: talkSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.flags.timeout).toBe(0.5);
+  });
+
+  it('parses --lines flag', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'talk', 'claude', 'hi', '--wait', '--lines', '50'];
+
+    const ctx = makeStubContext();
+    const talkSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: (opts: any) => {
+        ctx.flags = opts.flags;
+        return ctx;
+      },
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/talk.js', () => ({ cmdTalk: talkSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.flags.lines).toBe(50);
+  });
+
+  it('parses --no-preamble flag', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'talk', 'claude', 'hi', '--no-preamble'];
+
+    const ctx = makeStubContext();
+    const talkSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: (opts: any) => {
+        ctx.flags = opts.flags;
+        return ctx;
+      },
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/talk.js', () => ({ cmdTalk: talkSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.flags.noPreamble).toBe(true);
+  });
+
+  it('routes check command with lines argument', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'check', 'claude', '50'];
+
+    const ctx = makeStubContext();
+    const checkSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/check.js', () => ({ cmdCheck: checkSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(checkSpy).toHaveBeenCalledWith(ctx, 'claude', 50);
+  });
+
+  it('routes update command with --pane= syntax', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'update', 'claude', '--pane=2.0'];
+
+    const ctx = makeStubContext();
+    const updateSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/update.js', () => ({ cmdUpdate: updateSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(updateSpy).toHaveBeenCalledWith(ctx, 'claude', { pane: '2.0' });
+  });
+
+  it('routes update command with --remark= syntax', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'update', 'claude', '--remark=new remark'];
+
+    const ctx = makeStubContext();
+    const updateSpy = vi.fn();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    vi.doMock('./commands/update.js', () => ({ cmdUpdate: updateSpy }));
+    vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(updateSpy).toHaveBeenCalledWith(ctx, 'claude', { remark: 'new remark' });
+  });
+
+  it('errors on talk with missing arguments', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'talk', 'claude']; // missing message
+
+    const ctx = makeStubContext();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('errors on add with missing arguments', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'add', 'claude']; // missing pane
+
+    const ctx = makeStubContext();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('errors on update with missing arguments', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'update']; // missing name
+
+    const ctx = makeStubContext();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('errors on remove with missing arguments', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'remove']; // missing name
+
+    const ctx = makeStubContext();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('errors on check with missing arguments', async () => {
+    vi.resetModules();
+    process.argv = ['node', 'cli', 'check']; // missing target
+
+    const ctx = makeStubContext();
+    vi.doMock('./context.js', () => ({
+      createContext: () => ctx,
+      ExitCodes: { SUCCESS: 0, ERROR: 1 },
+    }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+    await import('./cli.js');
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(ctx.ui.error).toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
 });