tmux-team 3.2.4 → 3.3.0

package/README.md

@@ -16,60 +16,75 @@ 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
+```
+
+> **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
 ```
 
-The `--wait` flag blocks until the agent responds, returning the response directly.
+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
 
 Configuration lives in `tmux-team.json` in your project root.
 
-**Create** - Run the setup wizard to auto-detect agents:
-```bash
-tmux-team setup
-```
-
-**Read** - List configured agents:
+**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" }
+  "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 +103,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 +112,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,6 +1,6 @@
 {
   "name": "tmux-team",
-  "version": "3.2.4",
+  "version": "3.3.0",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {

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/src/cli.test.ts

@@ -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);
+  });
 });

package/src/cli.ts

@@ -20,8 +20,8 @@ import { cmdCompletion } from './commands/completion.js';
 import { cmdConfig } from './commands/config.js';
 import { cmdPreamble } from './commands/preamble.js';
 import { cmdInstall } from './commands/install.js';
-import { cmdSetup } from './commands/setup.js';
 import { cmdLearn } from './commands/learn.js';
+import { cmdThis } from './commands/this.js';
 
 // ─────────────────────────────────────────────────────────────
 // Argument parsing
@@ -147,7 +147,7 @@ function main(): void {
   const ctx = createContext({ argv, flags });
 
   // Warn if not in tmux for commands that require it
-  const TMUX_REQUIRED_COMMANDS = ['talk', 'send', 'check', 'read', 'setup'];
+  const TMUX_REQUIRED_COMMANDS = ['talk', 'send', 'check', 'read', 'this'];
   if (!process.env.TMUX && TMUX_REQUIRED_COMMANDS.includes(command)) {
     ctx.ui.warn('Not running inside tmux. Some features may not work.');
   }
@@ -202,6 +202,14 @@ function main(): void {
         cmdRemove(ctx, args[0]);
         break;
 
+      case 'this':
+        if (args.length < 1) {
+          ctx.ui.error('Usage: tmux-team this <name> [remark]');
+          ctx.exit(ExitCodes.ERROR);
+        }
+        cmdThis(ctx, args[0], args[1]);
+        break;
+
       case 'talk':
       case 'send':
         if (args.length < 2) {
@@ -232,10 +240,6 @@ function main(): void {
         await cmdInstall(ctx, args[0]);
         break;
 
-      case 'setup':
-        await cmdSetup(ctx);
-        break;
-
       case 'learn':
         cmdLearn();
         break;