tmux-team 3.3.0 → 4.0.0-beta.1

package/README.md

@@ -64,6 +64,16 @@ Find pane IDs with: `tmux display-message -p "#{pane_id}"`
 
 Run `tmt help` for all commands and options.
 
+## Message Delivery
+
+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)
+
+```bash
+tmt config set pasteEnterDelayMs 500
+```
+
 ## Managing Your Team
 
 Configuration lives in `tmux-team.json` in your project root.
@@ -76,6 +86,7 @@ tmt ls
 **Edit** - Modify `tmux-team.json` directly:
 ```json
 {
+  "$config": { "pasteEnterDelayMs": 500 },
   "codex": { "pane": "1.1", "remark": "Code reviewer" },
   "gemini": { "pane": "1.2", "remark": "Documentation" }
 }
@@ -86,28 +97,125 @@ tmt ls
 tmt rm codex
 ```
 
-## Claude Code Plugin
+---
+
+## Shared Teams
+
+> *Work on different folders but talk to the same team of agents.*
+
+By default, `tmux-team.json` is local to each folder. The `--team` flag lets agents across different folders share a team:
+
+```bash
+# Initialize a shared team
+tmt init --team myproject
+
+# Register agents from ANY folder
+cd ~/code/frontend && tmt this claude --team myproject
+cd ~/code/backend && tmt this codex --team myproject
+cd ~/code/infra && tmt this gemini --team myproject
+
+# Now talk to them from anywhere
+tmt talk codex "What's the user API schema?" --team myproject
+tmt talk all "Starting deploy - heads up" --team myproject
+```
+
+> **Tip:** Most AI coding agents (Claude Code, Codex, Gemini CLI) support `!` to run shell commands. Agents can register themselves without leaving the session:
+> ```
+> !tmt this claude --team myproject
+> ```
+
+### When to use shared teams
+
+**Single project** (default) — agents work in the same folder:
+```bash
+tmt init
+tmt this claude
+tmt add codex 1.1
+```
+
+**Shared team** — agents work across folders but collaborate:
+```bash
+tmt init --team acme-app
+tmt this frontend-claude --team acme-app   # from ~/acme/frontend
+tmt this backend-codex --team acme-app     # from ~/acme/backend
+```
+
+### Multi-team coordination
+
+For large systems, create team hierarchies where leaders coordinate sub-teams:
+
+```mermaid
+flowchart
+
+A["you (claude)"]
+A2["codex"]
+A3["gemini"]
+B["backend-lead"]
+B2["codex"]
+C["infra-lead"]
+C2["codex"]
+
+subgraph your-team
+  A <--> A2
+  A <--> A3
+end
+
+A e1@<--> B
+A e2@<--> C
+
+e1@{ animate: true }
+e2@{ animate: true }
+
+subgraph backend-team
+  B <--> B2
+end
+
+subgraph infra-team
+  C <--> C2
+end
+```
+
+---
+
+## Using /team in Claude Code
+
+The `/team` command lets Claude talk to other AI agents directly. Install the plugin:
 
 ```
 /plugin marketplace add wkh237/tmux-team
 /plugin install tmux-team
 ```
 
-Gives you two slash commands:
+### /team Commands
+
+| Command | What it does |
+|---------|--------------|
+| `/team list` | Show all registered agents |
+| `/team talk <agent> "msg"` | Send a message and wait for response |
+| `/team talk all "msg"` | Broadcast to all agents |
+
+### Real-World Examples
 
-**`/learn`** - Teach Claude how to use tmux-team
+**Code review delegation:**
 ```
-/learn
+/team talk codex "Review my changes in src/auth/ for security issues"
 ```
-Run this once when starting a session. Claude will understand how to coordinate with other agents.
 
-**`/team`** - Talk to other agents
+**Cross-agent coordination:**
 ```
-/team talk codex "Review my authentication changes"
-/team talk all "I'm starting the database migration"
-/team list
+/team talk all "Starting database migration - hold off on API changes"
 ```
-Use this to delegate tasks, ask for reviews, or broadcast updates.
+
+**Ask a specialist:**
+```
+/team talk gemini "What's the best practice for rate limiting in GCP?"
+```
+
+### Tips
+
+- `/team talk` waits for the agent to respond before continuing
+- Use `/team list` to see who's available
+- Run `/learn` once per session to teach Claude the full tmux-team workflow
 
 ## Learn More
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-team",
-  "version": "3.3.0",
+  "version": "4.0.0-beta.1",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
     "tmt": "./bin/tmux-team",
     "test": "pnpm test:run",
     "test:watch": "vitest",
-    "test:run": "vitest run --coverage && node scripts/check-coverage.mjs --threshold 95",
+    "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/",

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: {},
     },

package/src/cli.ts

@@ -59,6 +59,10 @@ function parseArgs(argv: string[]): { command: string; args: string[]; flags: Fl
       flags.lines = parseInt(argv[++i], 10) || 100;
     } else if (arg === '--no-preamble') {
       flags.noPreamble = true;
+    } else if (arg === '--team') {
+      flags.team = argv[++i];
+    } else if (arg.startsWith('--team=')) {
+      flags.team = arg.slice(7);
     } else if (arg.startsWith('--pane=')) {
       // Handled in update command
       positional.push(arg);

package/src/commands/add.ts

@@ -5,16 +5,25 @@
 import fs from 'fs';
 import type { Context, PaneEntry } from '../types.js';
 import { ExitCodes } from '../exits.js';
-import { loadLocalConfigFile, saveLocalConfigFile } from '../config.js';
+import { loadLocalConfigFile, saveLocalConfigFile, ensureTeamsDir } from '../config.js';
 
 export function cmdAdd(ctx: Context, name: string, pane: string, remark?: string): void {
   const { ui, config, paths, flags, exit } = ctx;
 
+  // Ensure teams directory exists if using --team
+  if (flags.team) {
+    ensureTeamsDir(paths.globalDir);
+  }
+
   // Create config file if it doesn't exist
   if (!fs.existsSync(paths.localConfig)) {
     fs.writeFileSync(paths.localConfig, '{}\n');
     if (!flags.json) {
-      ui.info(`Created ${paths.localConfig}`);
+      if (flags.team) {
+        ui.info(`Created shared team "${flags.team}"`);
+      } else {
+        ui.info(`Created ${paths.localConfig}`);
+      }
     }
   }
 
@@ -35,8 +44,12 @@ export function cmdAdd(ctx: Context, name: string, pane: string, remark?: string
   saveLocalConfigFile(paths, localConfig);
 
   if (flags.json) {
-    ui.json({ added: name, pane, remark });
+    ui.json({ added: name, pane, remark, team: flags.team });
   } else {
-    ui.success(`Added agent '${name}' at pane ${pane}`);
+    if (flags.team) {
+      ui.success(`Added agent '${name}' to team "${flags.team}" at pane ${pane}`);
+    } else {
+      ui.success(`Added agent '${name}' at pane ${pane}`);
+    }
   }
 }

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

@@ -54,7 +54,7 @@ function createCtx(
   const baseConfig: ResolvedConfig = {
     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: {},
     ...overrides?.config,
@@ -355,7 +355,9 @@ describe('basic commands', () => {
   it('cmdConfig clear errors on invalid key', () => {
     const ctx = createCtx(testDir);
     expect(() => cmdConfig(ctx, ['clear', 'invalidkey'])).toThrow(`exit(${ExitCodes.ERROR})`);
-    expect(ctx.ui.error).toHaveBeenCalledWith('Invalid key: invalidkey. Valid keys: mode, preambleMode, preambleEvery');
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      'Invalid key: invalidkey. Valid keys: mode, preambleMode, preambleEvery, pasteEnterDelayMs'
+    );
   });
 
   it('cmdCompletion prints scripts', () => {

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

@@ -34,7 +34,14 @@ function createCtx(
   const config: ResolvedConfig = {
     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: {},
     ...configOverrides,

package/src/commands/config.ts

@@ -14,11 +14,11 @@ import {
 } from '../config.js';
 
 type EnumConfigKey = 'mode' | 'preambleMode';
-type NumericConfigKey = 'preambleEvery';
+type NumericConfigKey = 'preambleEvery' | 'pasteEnterDelayMs';
 type ConfigKey = EnumConfigKey | NumericConfigKey;
 
 const ENUM_KEYS: EnumConfigKey[] = ['mode', 'preambleMode'];
-const NUMERIC_KEYS: NumericConfigKey[] = ['preambleEvery'];
+const NUMERIC_KEYS: NumericConfigKey[] = ['preambleEvery', 'pasteEnterDelayMs'];
 const VALID_KEYS: ConfigKey[] = [...ENUM_KEYS, ...NUMERIC_KEYS];
 
 const VALID_VALUES: Record<EnumConfigKey, string[]> = {
@@ -56,6 +56,7 @@ function showConfig(ctx: Context): void {
         mode: ctx.config.mode,
         preambleMode: ctx.config.preambleMode,
         preambleEvery: ctx.config.defaults.preambleEvery,
+        pasteEnterDelayMs: ctx.config.defaults.pasteEnterDelayMs,
         defaults: ctx.config.defaults,
       },
       sources: {
@@ -71,6 +72,12 @@ function showConfig(ctx: Context): void {
             : globalConfig.defaults?.preambleEvery !== undefined
               ? 'global'
               : 'default',
+        pasteEnterDelayMs:
+          localSettings?.pasteEnterDelayMs !== undefined
+            ? 'local'
+            : globalConfig.defaults?.pasteEnterDelayMs !== undefined
+              ? 'global'
+              : 'default',
       },
       paths: {
         global: ctx.paths.globalConfig,
@@ -93,6 +100,12 @@ function showConfig(ctx: Context): void {
       : globalConfig.defaults?.preambleEvery !== undefined
         ? '(global)'
         : '(default)';
+  const pasteEnterDelaySource =
+    localSettings?.pasteEnterDelayMs !== undefined
+      ? '(local)'
+      : globalConfig.defaults?.pasteEnterDelayMs !== undefined
+        ? '(global)'
+        : '(default)';
 
   ctx.ui.info('Current configuration:\n');
   ctx.ui.table(
@@ -101,6 +114,11 @@ function showConfig(ctx: Context): void {
       ['mode', ctx.config.mode, modeSource],
       ['preambleMode', ctx.config.preambleMode, preambleSource],
       ['preambleEvery', String(ctx.config.defaults.preambleEvery), preambleEverySource],
+      [
+        'pasteEnterDelayMs',
+        String(ctx.config.defaults.pasteEnterDelayMs),
+        pasteEnterDelaySource,
+      ],
       ['defaults.timeout', String(ctx.config.defaults.timeout), '(global)'],
       ['defaults.pollInterval', String(ctx.config.defaults.pollInterval), '(global)'],
       ['defaults.captureLines', String(ctx.config.defaults.captureLines), '(global)'],
@@ -157,10 +175,24 @@ function setConfig(ctx: Context, key: string, value: string, global: boolean): v
           captureLines: 100,
           maxCaptureLines: 2000,
           preambleEvery: parseInt(value, 10),
+          pasteEnterDelayMs: 500,
         };
       } else {
         globalConfig.defaults.preambleEvery = parseInt(value, 10);
       }
+    } else if (key === 'pasteEnterDelayMs') {
+      if (!globalConfig.defaults) {
+        globalConfig.defaults = {
+          timeout: 180,
+          pollInterval: 1,
+          captureLines: 100,
+          maxCaptureLines: 2000,
+          preambleEvery: 3,
+          pasteEnterDelayMs: parseInt(value, 10),
+        };
+      } else {
+        globalConfig.defaults.pasteEnterDelayMs = parseInt(value, 10);
+      }
     }
     saveGlobalConfig(ctx.paths, globalConfig);
     ctx.ui.success(`Set ${key}=${value} in global config`);
@@ -172,6 +204,8 @@ function setConfig(ctx: Context, key: string, value: string, global: boolean): v
       updateLocalSettings(ctx.paths, { preambleMode: value as 'always' | 'disabled' });
     } else if (key === 'preambleEvery') {
       updateLocalSettings(ctx.paths, { preambleEvery: parseInt(value, 10) });
+    } else if (key === 'pasteEnterDelayMs') {
+      updateLocalSettings(ctx.paths, { pasteEnterDelayMs: parseInt(value, 10) });
     }
     ctx.ui.success(`Set ${key}=${value} in local config (repo override)`);
   }

package/src/commands/help.ts

@@ -64,6 +64,7 @@ ${colors.yellow('OPTIONS')}
   ${colors.green('--json')}                      Output in JSON format
   ${colors.green('--verbose')}                   Show detailed output
   ${colors.green('--force')}                     Skip warnings
+  ${colors.green('--team')} <name>               Use shared team (cross-folder)
 
 ${colors.yellow('TALK OPTIONS')}
   ${colors.green('--delay')} <seconds>           Wait before sending
@@ -90,6 +91,7 @@ ${colors.yellow('EXAMPLES')}${
 ${colors.yellow('CONFIG')}
   Local:  ./tmux-team.json (pane registry + $config override)
   Global: ~/.config/tmux-team/config.json (settings)
+  Teams:  ~/.config/tmux-team/teams/<name>.json (shared teams)
 
 ${colors.yellow('CHANGE MODE')}
   tmux-team config set mode wait            ${colors.dim('Enable wait mode (local)')}

package/src/commands/init.ts

@@ -1,14 +1,20 @@
 // ─────────────────────────────────────────────────────────────
-// init command - create tmux-team.json
+// init command - create tmux-team.json or shared team config
 // ─────────────────────────────────────────────────────────────
 
 import fs from 'fs';
 import type { Context } from '../types.js';
 import { ExitCodes } from '../exits.js';
+import { ensureTeamsDir } from '../config.js';
 
 export function cmdInit(ctx: Context): void {
   const { ui, paths, flags, exit } = ctx;
 
+  // Ensure teams directory exists if using --team
+  if (flags.team) {
+    ensureTeamsDir(paths.globalDir);
+  }
+
   if (fs.existsSync(paths.localConfig)) {
     ui.error(`${paths.localConfig} already exists. Remove it first if you want to reinitialize.`);
     exit(ExitCodes.ERROR);
@@ -17,8 +23,12 @@ export function cmdInit(ctx: Context): void {
   fs.writeFileSync(paths.localConfig, '{}\n');
 
   if (flags.json) {
-    ui.json({ created: paths.localConfig });
+    ui.json({ created: paths.localConfig, team: flags.team });
   } else {
-    ui.success(`Created ${paths.localConfig}`);
+    if (flags.team) {
+      ui.success(`Created shared team "${flags.team}" at ${paths.localConfig}`);
+    } else {
+      ui.success(`Created ${paths.localConfig}`);
+    }
   }
 }

package/src/commands/install.test.ts

@@ -26,7 +26,7 @@ function createCtx(testDir: string, overrides?: Partial<{ flags: Partial<Flags>
   const config: ResolvedConfig = {
     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: {},
   };

package/src/commands/learn.ts

@@ -17,8 +17,8 @@ ${colors.yellow('WHAT IS TMUX-TEAM?')}
 ${colors.yellow('CORE CONCEPT')}
 
   Each agent runs in its own tmux pane. When you talk to another agent:
-  1. Your message is sent to their pane via tmux send-keys
-  2. They see it as if a human typed it
+  1. Your message is pasted via a tmux buffer
+  2. tmux-team waits briefly, then sends Enter to submit
   3. You read their response by capturing their pane output
 
 ${colors.yellow('ESSENTIAL COMMANDS')}
@@ -59,7 +59,7 @@ ${colors.yellow('CONFIGURATION')}
   Config file: ${colors.cyan('./tmux-team.json')}
 
   {
-    "$config": { "mode": "wait" },
+    "$config": { "mode": "wait", "pasteEnterDelayMs": 500 },
     "codex": { "pane": "%1", "remark": "Code reviewer" },
     "gemini": { "pane": "%2", "remark": "Documentation" }
   }

package/src/commands/list.ts

@@ -9,16 +9,24 @@ export function cmdList(ctx: Context): void {
   const agents = Object.entries(config.paneRegistry);
 
   if (flags.json) {
-    ui.json(config.paneRegistry);
+    ui.json({ team: flags.team, agents: config.paneRegistry });
     return;
   }
 
   if (agents.length === 0) {
-    ui.info("No agents configured. Use 'tmux-team add <name> <pane>' to add one.");
+    if (flags.team) {
+      ui.info(`No agents in team "${flags.team}". Use 'tmt this <name> --team ${flags.team}' to add one.`);
+    } else {
+      ui.info("No agents configured. Use 'tmux-team add <name> <pane>' to add one.");
+    }
     return;
   }
 
   console.log();
+  if (flags.team) {
+    console.log(`Team: ${flags.team}`);
+    console.log();
+  }
   ui.table(
     ['NAME', 'PANE', 'REMARK'],
     agents.map(([name, data]) => [name, data.pane, data.remark || '-'])

package/src/commands/preamble.test.ts

@@ -48,7 +48,7 @@ function createDefaultConfig(): ResolvedConfig {
       pollInterval: 1,
       captureLines: 100,
       maxCaptureLines: 2000,
-      preambleEvery: 3,
+      preambleEvery: 3, pasteEnterDelayMs: 500,
     },
     agents: {},
     paneRegistry: {

package/src/commands/talk.test.ts

@@ -81,6 +81,7 @@ function createDefaultConfig(): ResolvedConfig {
       captureLines: 100,
       maxCaptureLines: 2000,
       preambleEvery: 3,
+      pasteEnterDelayMs: 500,
     },
     agents: {},
     paneRegistry: {
@@ -238,7 +239,7 @@ describe('buildMessage (via cmdTalk)', () => {
         pollInterval: 0.1,
         captureLines: 100,
         maxCaptureLines: 2000,
-        preambleEvery: 3,
+        preambleEvery: 3, pasteEnterDelayMs: 500,
       },
     };
 
@@ -276,6 +277,7 @@ describe('buildMessage (via cmdTalk)', () => {
         captureLines: 100,
         maxCaptureLines: 2000,
         preambleEvery: 1,
+        pasteEnterDelayMs: 500,
       },
     };
 
@@ -300,6 +302,7 @@ describe('buildMessage (via cmdTalk)', () => {
         captureLines: 100,
         maxCaptureLines: 2000,
         preambleEvery: 0,
+        pasteEnterDelayMs: 500,
       },
     };
 
@@ -425,14 +428,14 @@ describe('cmdTalk - basic send', () => {
     }
   });
 
-  it('removes exclamation marks for gemini agent', async () => {
+  it('preserves exclamation marks for gemini agent', async () => {
     const tmux = createMockTmux();
     const ctx = createContext({ tmux, paths: createTestPaths(testDir) });
 
     await cmdTalk(ctx, 'gemini', 'Hello! This is exciting!');
 
     expect(tmux.sends).toHaveLength(1);
-    expect(tmux.sends[0].message).toBe('Hello This is exciting');
+    expect(tmux.sends[0].message).toBe('Hello! This is exciting!');
   });
 
   it('exits with error for unknown agent', async () => {
@@ -548,7 +551,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -592,7 +595,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -623,7 +626,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -671,7 +674,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -707,7 +710,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -736,7 +739,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -758,22 +761,19 @@ describe('cmdTalk - --wait mode', () => {
     // Create mock tmux that returns markers for each agent after a delay
     const tmux = createMockTmux();
     let captureCount = 0;
-    const noncesByPane: Record<string, string> = {};
-
-    // Mock send to capture the nonce for each pane
-    tmux.send = (pane: string, msg: string) => {
-      const match = msg.match(INSTRUCTION_NONCE_REGEX);
-      if (match) {
-        noncesByPane[pane] = match[1];
-      }
+    const getNonceForPane = (pane: string): string | undefined => {
+      const sent = tmux.sends.find((s) => s.pane === pane)?.message ?? '';
+      const match = String(sent).match(INSTRUCTION_NONCE_REGEX);
+      return match?.[1];
     };
 
     // Mock capture to return complete response after first poll
     tmux.capture = (pane: string) => {
       captureCount++;
       // Return complete response on second capture for each pane
-      if (captureCount > 3 && noncesByPane[pane]) {
-        return mockCompleteResponse(noncesByPane[pane], 'Response from agent');
+      const nonce = getNonceForPane(pane);
+      if (captureCount > 3 && nonce) {
+        return mockCompleteResponse(nonce, 'Response from agent');
       }
       return 'working...';
     };
@@ -791,7 +791,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.05,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -808,19 +808,17 @@ describe('cmdTalk - --wait mode', () => {
 
   it('handles partial timeout in wait mode with all target', async () => {
     const tmux = createMockTmux();
-    const noncesByPane: Record<string, string> = {};
-
-    tmux.send = (pane: string, msg: string) => {
-      const match = msg.match(INSTRUCTION_NONCE_REGEX);
-      if (match) {
-        noncesByPane[pane] = match[1];
-      }
+    const getNonceForPane = (pane: string): string | undefined => {
+      const sent = tmux.sends.find((s) => s.pane === pane)?.message ?? '';
+      const match = String(sent).match(INSTRUCTION_NONCE_REGEX);
+      return match?.[1];
     };
 
     // Only pane 10.1 responds with end marker, 10.2 never has end marker
     tmux.capture = (pane: string) => {
-      if (pane === '10.1' && noncesByPane[pane]) {
-        return mockCompleteResponse(noncesByPane[pane], 'Response from codex');
+      const nonce = getNonceForPane(pane);
+      if (pane === '10.1' && nonce) {
+        return mockCompleteResponse(nonce, 'Response from codex');
       }
       // gemini has no end marker - still typing
       return 'still working...';
@@ -839,7 +837,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -868,18 +866,15 @@ describe('cmdTalk - --wait mode', () => {
 
   it('uses unique nonces per agent in broadcast', async () => {
     const tmux = createMockTmux();
-    const nonces: string[] = [];
-
-    tmux.send = (_pane: string, msg: string) => {
-      const match = msg.match(INSTRUCTION_NONCE_REGEX);
-      if (match) {
-        nonces.push(match[1]);
-      }
-    };
+    const getNonces = (): string[] =>
+      tmux.sends
+        .map((s) => String(s.message).match(INSTRUCTION_NONCE_REGEX)?.[1])
+        .filter((nonce): nonce is string => Boolean(nonce));
 
     // Return complete response immediately
     tmux.capture = (pane: string) => {
       const idx = pane === '10.1' ? 0 : 1;
+      const nonces = getNonces();
       if (nonces[idx]) {
         return mockCompleteResponse(nonces[idx], 'Response');
       }
@@ -897,7 +892,7 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -909,6 +904,7 @@ describe('cmdTalk - --wait mode', () => {
     await cmdTalk(ctx, 'all', 'Hello');
 
     // Each agent should have a unique nonce
+    const nonces = getNonces();
     expect(nonces.length).toBe(2);
     expect(nonces[0]).not.toBe(nonces[1]);
   });
@@ -1007,7 +1003,7 @@ describe('cmdTalk - nonce collision handling', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -1062,7 +1058,7 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -1103,7 +1099,7 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -1145,7 +1141,7 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -1182,7 +1178,7 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
       },
     });
@@ -1202,17 +1198,16 @@ describe('cmdTalk - JSON output contract', () => {
   it('handles broadcast with mixed completion and timeout', async () => {
     const tmux = createMockTmux();
     const ui = createMockUI();
-    const markersByPane: Record<string, string> = {};
-
-    tmux.send = (pane: string, msg: string) => {
-      const match = msg.match(INSTRUCTION_NONCE_REGEX);
-      if (match) markersByPane[pane] = match[1];
+    const getNonceForPane = (pane: string): string | undefined => {
+      const sent = tmux.sends.find((s) => s.pane === pane)?.message ?? '';
+      const match = String(sent).match(INSTRUCTION_NONCE_REGEX);
+      return match?.[1];
     };
 
     // codex completes with end marker, gemini has no end marker (still typing)
     tmux.capture = (pane: string) => {
       if (pane === '10.1') {
-        const nonce = markersByPane['10.1'];
+        const nonce = getNonceForPane('10.1');
         const endMarker = `RESPONSE-END-${nonce}`;
         // Complete response with end marker
         return `Response\n${endMarker}`;
@@ -1233,7 +1228,7 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.02,
           captureLines: 100,
           maxCaptureLines: 2000,
-          preambleEvery: 3,
+          preambleEvery: 3, pasteEnterDelayMs: 500,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -1315,7 +1310,7 @@ describe('cmdTalk - end marker detection', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test message');
@@ -1349,7 +1344,7 @@ describe('cmdTalk - end marker detection', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test');
@@ -1383,7 +1378,7 @@ Line 4 final`;
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test');
@@ -1414,7 +1409,7 @@ Line 4 final`;
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test');
@@ -1451,7 +1446,7 @@ Line 4 final`;
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test');
@@ -1487,7 +1482,7 @@ Line 4 final`;
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.5 },
-      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 200, maxCaptureLines: 2000, preambleEvery: 3 } },
+      config: { defaults: { timeout: 0.5, pollInterval: 0.01, captureLines: 200, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 } },
     });
 
     await cmdTalk(ctx, 'claude', 'Test');

package/src/commands/talk.ts

@@ -319,6 +319,7 @@ function buildMessage(message: string, agentName: string, ctx: Context): string
 export async function cmdTalk(ctx: Context, target: string, message: string): Promise<void> {
   const { ui, config, tmux, flags, exit } = ctx;
   const waitEnabled = Boolean(flags.wait) || config.mode === 'wait';
+  const enterDelayMs = config.defaults.pasteEnterDelayMs;
 
   if (target === 'all') {
     const agents = Object.entries(config.paneRegistry);
@@ -357,9 +358,8 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
       for (const [name, data] of targetAgents) {
         try {
-          let msg = buildMessage(message, name, ctx);
-          if (name === 'gemini') msg = msg.replace(/!/g, '');
-          tmux.send(data.pane, msg);
+          const msg = buildMessage(message, name, ctx);
+          tmux.send(data.pane, msg, { enterDelayMs });
           results.push({ agent: name, pane: data.pane, status: 'sent' });
           if (!flags.json) {
             console.log(`${colors.green('→')} Sent to ${colors.cyan(name)} (${data.pane})`);
@@ -399,9 +399,8 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
   if (!waitEnabled) {
     try {
       // Build message with preamble, then apply Gemini filter
-      let msg = buildMessage(message, target, ctx);
-      if (target === 'gemini') msg = msg.replace(/!/g, '');
-      tmux.send(pane, msg);
+      const msg = buildMessage(message, target, ctx);
+      tmux.send(pane, msg, { enterDelayMs });
 
       if (flags.json) {
         ui.json({ target, pane, status: 'sent' });
@@ -462,7 +461,7 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
   process.once('SIGINT', onSigint);
 
   try {
-    const msg = target === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
+    const msg = fullMessage;
 
     if (flags.debug) {
       console.error(`[DEBUG] Starting wait mode for ${target}`);
@@ -470,7 +469,7 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
       console.error(`[DEBUG] Message sent:\n${msg}`);
     }
 
-    tmux.send(pane, msg);
+    tmux.send(pane, msg, { enterDelayMs });
 
     while (true) {
       const elapsedSeconds = (Date.now() - startedAt) / 1000;
@@ -662,6 +661,7 @@ async function cmdTalkAllWait(
   skippedSelf: boolean
 ): Promise<void> {
   const { ui, config, tmux, flags, exit, paths } = ctx;
+  const enterDelayMs = config.defaults.pasteEnterDelayMs;
   const timeoutSeconds = flags.timeout ?? config.defaults.timeout;
   const pollIntervalSeconds = Math.max(0.1, config.defaults.pollInterval);
   const captureLines = config.defaults.captureLines;
@@ -694,11 +694,11 @@ async function cmdTalkAllWait(
     // Note: instruction doesn't contain literal marker to prevent false-positive detection
     const messageWithPreamble = buildMessage(message, name, ctx);
     const fullMessage = `${messageWithPreamble}\n\n${makeEndMarkerInstruction(nonce)}`;
-    const msg = name === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
+    const msg = fullMessage;
 
     try {
       const now = Date.now();
-      tmux.send(data.pane, msg);
+      tmux.send(data.pane, msg, { enterDelayMs });
       setActiveRequest(paths, name, {
         id: requestId,
         nonce,

package/src/commands/this.ts

@@ -12,7 +12,7 @@ export function cmdThis(ctx: Context, name: string, remark?: string): void {
   const currentPaneId = tmux.getCurrentPaneId();
   if (!currentPaneId) {
     ui.error('Not running inside tmux.');
-    exit(ExitCodes.ERROR);
+    return exit(ExitCodes.ERROR);
   }
 
   // Reuse existing add logic

package/src/config.test.ts

@@ -206,6 +206,7 @@ describe('loadConfig', () => {
     expect(config.defaults.timeout).toBe(180);
     expect(config.defaults.pollInterval).toBe(1);
     expect(config.defaults.captureLines).toBe(100);
+    expect(config.defaults.pasteEnterDelayMs).toBe(500);
     expect(config.agents).toEqual({});
     expect(config.paneRegistry).toEqual({});
   });

package/src/config.ts

@@ -17,6 +17,7 @@ import type {
 const CONFIG_FILENAME = 'config.json';
 const LOCAL_CONFIG_FILENAME = 'tmux-team.json';
 const STATE_FILENAME = 'state.json';
+const TEAMS_DIR = 'teams';
 
 // Default configuration values
 const DEFAULT_CONFIG: GlobalConfig = {
@@ -28,6 +29,7 @@ const DEFAULT_CONFIG: GlobalConfig = {
     captureLines: 100,
     maxCaptureLines: 2000, // max lines for final extraction (expandable capture)
     preambleEvery: 3, // inject preamble every N messages
+    pasteEnterDelayMs: 500, // delay after paste before Enter
   },
 };
 
@@ -101,9 +103,37 @@ function findUpward(filename: string, startDir: string): string | null {
   }
 }
 
-export function resolvePaths(cwd: string = process.cwd()): Paths {
+/**
+ * Get the path to a shared team config file.
+ */
+export function getTeamConfigPath(globalDir: string, teamName: string): string {
+  return path.join(globalDir, TEAMS_DIR, `${teamName}.json`);
+}
+
+/**
+ * Ensure the teams directory exists.
+ */
+export function ensureTeamsDir(globalDir: string): void {
+  const teamsDir = path.join(globalDir, TEAMS_DIR);
+  if (!fs.existsSync(teamsDir)) {
+    fs.mkdirSync(teamsDir, { recursive: true });
+  }
+}
+
+export function resolvePaths(cwd: string = process.cwd(), teamName?: string): Paths {
   const globalDir = resolveGlobalDir();
 
+  // If team name is specified, use the shared team config
+  if (teamName) {
+    const teamConfig = getTeamConfigPath(globalDir, teamName);
+    return {
+      globalDir,
+      globalConfig: path.join(globalDir, CONFIG_FILENAME),
+      localConfig: teamConfig,
+      stateFile: path.join(globalDir, STATE_FILENAME),
+    };
+  }
+
   // Search up for local config (like .git discovery)
   const localConfigPath =
     findUpward(LOCAL_CONFIG_FILENAME, cwd) ?? path.join(cwd, LOCAL_CONFIG_FILENAME);
@@ -180,6 +210,9 @@ export function loadConfig(paths: Paths): ResolvedConfig {
       if (localSettings.preambleEvery !== undefined) {
         config.defaults.preambleEvery = localSettings.preambleEvery;
       }
+      if (localSettings.pasteEnterDelayMs !== undefined) {
+        config.defaults.pasteEnterDelayMs = localSettings.pasteEnterDelayMs;
+      }
     }
 
     // Build pane registry and agents config from local entries

package/src/context.test.ts

@@ -18,7 +18,7 @@ describe('createContext', () => {
     const config: ResolvedConfig = {
       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: {},
     };

package/src/context.ts

@@ -17,7 +17,7 @@ export interface CreateContextOptions {
 export function createContext(options: CreateContextOptions): Context {
   const { argv, flags, cwd = process.cwd() } = options;
 
-  const paths = resolvePaths(cwd);
+  const paths = resolvePaths(cwd, flags.team);
   const config = loadConfig(paths);
   const ui = createUI(flags.json);
   const tmux = createTmux();

package/src/tmux.test.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// Tmux Wrapper Tests - send-keys, capture-pane
+// Tmux Wrapper Tests - buffer paste, capture-pane
 // ─────────────────────────────────────────────────────────────
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
@@ -23,68 +23,70 @@ describe('createTmux', () => {
   });
 
   describe('send', () => {
-    it('calls tmux send-keys with pane ID and message', () => {
+    it('uses buffer paste and then sends Enter', () => {
       const tmux = createTmux();
 
-      tmux.send('1.0', 'Hello world');
+      tmux.send('1.0', 'Hello world', { enterDelayMs: 0 });
 
       expect(mockedExecSync).toHaveBeenCalledWith(
-        'tmux send-keys -t "1.0" "Hello world"',
+        expect.stringContaining('tmux set-buffer -b "tmt-'),
         expect.any(Object)
       );
-    });
-
-    it('sends Enter key after message', () => {
-      const tmux = createTmux();
-
-      tmux.send('1.0', 'Hello');
-
-      expect(mockedExecSync).toHaveBeenCalledTimes(2);
-      expect(mockedExecSync).toHaveBeenNthCalledWith(
-        2,
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('tmux paste-buffer -b "tmt-'),
+        expect.any(Object)
+      );
+      expect(mockedExecSync).toHaveBeenCalledWith(
         'tmux send-keys -t "1.0" Enter',
         expect.any(Object)
       );
     });
 
-    it('escapes special characters in message', () => {
+    it('adds a trailing newline to the buffer payload', () => {
       const tmux = createTmux();
 
-      tmux.send('1.0', 'Hello "world" with \'quotes\'');
+      tmux.send('1.0', 'Line 1\nLine 2', { enterDelayMs: 0 });
 
       expect(mockedExecSync).toHaveBeenCalledWith(
-        expect.stringContaining('"Hello \\"world\\" with \'quotes\'"'),
+        expect.stringContaining('"Line 1\\nLine 2\\n"'),
         expect.any(Object)
       );
     });
 
-    it('handles newlines in message', () => {
+    it('escapes special characters in message', () => {
       const tmux = createTmux();
 
-      tmux.send('1.0', 'Line 1\nLine 2');
+      tmux.send('1.0', 'Hello "world" with \'quotes\'', { enterDelayMs: 0 });
 
-      // JSON.stringify escapes newlines as \n
       expect(mockedExecSync).toHaveBeenCalledWith(
-        expect.stringContaining('"Line 1\\nLine 2"'),
+        expect.stringContaining('"Hello \\"world\\" with \'quotes\'\\n"'),
         expect.any(Object)
       );
     });
 
-    it('throws when pane does not exist', () => {
-      const error = new Error("can't find pane: 99.99");
+    it('falls back to send-keys when buffer paste fails', () => {
+      const error = new Error('set-buffer failed');
       mockedExecSync.mockImplementationOnce(() => {
         throw error;
       });
-
       const tmux = createTmux();
 
-      expect(() => tmux.send('99.99', 'Hello')).toThrow("can't find pane: 99.99");
+      tmux.send('1.0', 'Hello', { enterDelayMs: 0 });
+
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        'tmux send-keys -t "1.0" "Hello"',
+        expect.any(Object)
+      );
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        'tmux send-keys -t "1.0" Enter',
+        expect.any(Object)
+      );
     });
 
     it('uses pipe stdio to suppress output', () => {
       const tmux = createTmux();
 
-      tmux.send('1.0', 'Hello');
+      tmux.send('1.0', 'Hello', { enterDelayMs: 0 });
 
       expect(mockedExecSync).toHaveBeenCalledWith(expect.any(String), { stdio: 'pipe' });
     });
@@ -236,9 +238,13 @@ describe('createTmux', () => {
       mockedExecSync.mockReturnValue('');
       const tmux = createTmux();
 
-      tmux.send('1.2', 'Hello');
+      tmux.send('1.2', 'Hello', { enterDelayMs: 0 });
       tmux.capture('1.2', 100);
 
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('tmux paste-buffer -b "tmt-'),
+        expect.any(Object)
+      );
       expect(mockedExecSync).toHaveBeenCalledWith(
         expect.stringContaining('-t "1.2"'),
         expect.any(Object)
@@ -249,9 +255,13 @@ describe('createTmux', () => {
       mockedExecSync.mockReturnValue('');
       const tmux = createTmux();
 
-      tmux.send('main:1.2', 'Hello');
+      tmux.send('main:1.2', 'Hello', { enterDelayMs: 0 });
       tmux.capture('main:1.2', 100);
 
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('tmux paste-buffer -b "tmt-'),
+        expect.any(Object)
+      );
       expect(mockedExecSync).toHaveBeenCalledWith(
         expect.stringContaining('-t "main:1.2"'),
         expect.any(Object)
@@ -263,11 +273,11 @@ describe('createTmux', () => {
       const tmux = createTmux();
 
       // Malicious pane ID attempt
-      tmux.send('1.0; rm -rf /', 'Hello');
+      tmux.send('1.0; rm -rf /', 'Hello', { enterDelayMs: 0 });
 
       // Should be quoted and treated as literal string
       expect(mockedExecSync).toHaveBeenCalledWith(
-        'tmux send-keys -t "1.0; rm -rf /" "Hello"',
+        expect.stringContaining('-t "1.0; rm -rf /"'),
         expect.any(Object)
       );
     });

package/src/tmux.ts

@@ -1,8 +1,9 @@
 // ─────────────────────────────────────────────────────────────
-// Pure tmux wrapper - send-keys, capture-pane, pane detection
+// Pure tmux wrapper - buffer paste, capture-pane, pane detection
 // ─────────────────────────────────────────────────────────────
 
 import { execSync } from 'child_process';
+import crypto from 'crypto';
 import type { Tmux, PaneInfo } from './types.js';
 
 // Known agent patterns for auto-detection
@@ -27,14 +28,54 @@ function detectAgentName(command: string): string | null {
 }
 
 export function createTmux(): Tmux {
+  function sleepMs(ms: number): void {
+    if (ms <= 0) return;
+    const buffer = new SharedArrayBuffer(4);
+    const view = new Int32Array(buffer);
+    Atomics.wait(view, 0, 0, ms);
+  }
+
+  function ensureTrailingNewline(message: string): string {
+    return message.endsWith('\n') ? message : `${message}\n`;
+  }
+
+  function escapeExclamation(message: string): string {
+    // Escape "!" to avoid shell history expansion issues
+    return message.replace(/!/g, '\\!');
+  }
+
+  function makeBufferName(): string {
+    const nonce = crypto.randomBytes(4).toString('hex');
+    return `tmt-${process.pid}-${Date.now()}-${nonce}`;
+  }
+
   return {
-    send(paneId: string, message: string): void {
-      execSync(`tmux send-keys -t "${paneId}" ${JSON.stringify(message)}`, {
-        stdio: 'pipe',
-      });
-      execSync(`tmux send-keys -t "${paneId}" Enter`, {
-        stdio: 'pipe',
-      });
+    send(paneId: string, message: string, options?: { enterDelayMs?: number }): void {
+      const enterDelayMs = Math.max(0, options?.enterDelayMs ?? 500);
+      const bufferName = makeBufferName();
+      const escaped = escapeExclamation(message);
+      const payload = ensureTrailingNewline(escaped);
+
+      try {
+        execSync(`tmux set-buffer -b "${bufferName}" -- ${JSON.stringify(payload)}`, {
+          stdio: 'pipe',
+        });
+        execSync(`tmux paste-buffer -b "${bufferName}" -d -t "${paneId}" -p`, {
+          stdio: 'pipe',
+        });
+        sleepMs(enterDelayMs);
+        execSync(`tmux send-keys -t "${paneId}" Enter`, {
+          stdio: 'pipe',
+        });
+      } catch {
+        // Fallback to legacy send-keys if buffer/paste fails
+        execSync(`tmux send-keys -t "${paneId}" ${JSON.stringify(message)}`, {
+          stdio: 'pipe',
+        });
+        execSync(`tmux send-keys -t "${paneId}" Enter`, {
+          stdio: 'pipe',
+        });
+      }
     },
 
     capture(paneId: string, lines: number): string {

package/src/types.ts

@@ -20,6 +20,7 @@ export interface ConfigDefaults {
   captureLines: number;
   maxCaptureLines: number; // max lines for final extraction (default: 2000)
   preambleEvery: number; // inject preamble every N messages (default: 3)
+  pasteEnterDelayMs: number; // delay after paste before Enter (default: 500)
 }
 
 export interface GlobalConfig {
@@ -32,6 +33,7 @@ export interface LocalSettings {
   mode?: 'polling' | 'wait';
   preambleMode?: 'always' | 'disabled';
   preambleEvery?: number; // local override for preamble frequency
+  pasteEnterDelayMs?: number; // local override for paste-enter delay
 }
 
 export interface LocalConfigFile {
@@ -62,6 +64,7 @@ export interface Flags {
   timeout?: number; // seconds
   lines?: number; // lines to capture before end marker
   noPreamble?: boolean;
+  team?: string; // shared team name for cross-folder collaboration
 }
 
 export interface Paths {
@@ -87,7 +90,7 @@ export interface PaneInfo {
 }
 
 export interface Tmux {
-  send: (paneId: string, message: string) => void;
+  send: (paneId: string, message: string, options?: { enterDelayMs?: number }) => void;
   capture: (paneId: string, lines: number) => string;
   listPanes: () => PaneInfo[];
   getCurrentPaneId: () => string | null;