tmux-team 3.0.0-alpha.1 → 3.0.0-alpha.2

package/README.md

@@ -80,6 +80,24 @@ eval "$(tmux-team completion bash)"
 /plugin install tmux-team@tmux-team
 ```
 
+### Agent Skills (Optional)
+
+Install tmux-team as a native skill for your AI coding agent:
+
+```bash
+# Install for Claude Code (user-wide)
+tmux-team install-skill claude
+
+# Install for OpenAI Codex (user-wide)
+tmux-team install-skill codex
+
+# Install to project directory instead
+tmux-team install-skill claude --local
+tmux-team install-skill codex --local
+```
+
+See [skills/README.md](./skills/README.md) for detailed instructions.
+
 ---
 
 ## ⌨️ Quick Start
@@ -133,6 +151,7 @@ Once the plugin is installed, coordinate directly from your Claude Code session:
 | `init` | Create `tmux-team.json` in current directory |
 | `config [show/set/clear]` | View/modify settings |
 | `preamble [show/set/clear]` | Manage agent preambles |
+| `install-skill <agent>` | Install skill for Claude/Codex (--local/--user) |
 | `completion [zsh\|bash]` | Output shell completion script |
 
 ---
@@ -221,7 +240,7 @@ Use the CLI to manage preambles:
 
 ```bash
 tmux-team preamble show gemini      # View current preamble
-tmux-team preamble set gemini "..." # Set preamble
+tmux-team preamble set gemini "Be concise" # Set preamble
 tmux-team preamble clear gemini     # Remove preamble
 ```
 
@@ -264,7 +283,7 @@ tmux-team config clear <key>           # Clear a config value
 
 ```bash
 tmux-team preamble show <agent>        # Show agent's preamble
-tmux-team preamble set <agent> "..."   # Set agent's preamble
+tmux-team preamble set <agent> "text"  # Set agent's preamble
 tmux-team preamble clear <agent>       # Clear agent's preamble
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-team",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.2",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {
@@ -42,7 +42,8 @@
   ],
   "files": [
     "bin",
-    "src"
+    "src",
+    "skills"
   ],
   "dependencies": {
     "tsx": "^4.7.0"

package/skills/README.md

@@ -0,0 +1,101 @@
+# Agent Skills Installation
+
+tmux-team provides pre-built skills for popular AI coding agents.
+
+## Quick Install
+
+Use the CLI to install skills automatically:
+
+```bash
+# Install for Claude Code (user-wide)
+tmux-team install-skill claude
+
+# Install for OpenAI Codex (user-wide)
+tmux-team install-skill codex
+
+# Install to project directory (local scope)
+tmux-team install-skill claude --local
+tmux-team install-skill codex --local
+```
+
+## Claude Code
+
+Claude Code uses slash commands stored in `~/.claude/commands/` (user) or `.claude/commands/` (local).
+
+### Manual Install
+
+```bash
+mkdir -p ~/.claude/commands
+cp skills/claude/team.md ~/.claude/commands/team.md
+```
+
+### Usage
+
+```bash
+# In Claude Code, use the slash command:
+/team talk codex "Review this PR"
+
+# Or invoke implicitly - Claude will recognize when to use it
+```
+
+## OpenAI Codex CLI
+
+Codex uses skills stored in `~/.codex/skills/<skill-name>/` (user) or `.codex/skills/<skill-name>/` (local).
+
+### Manual Install
+
+```bash
+mkdir -p ~/.codex/skills/tmux-team
+cp skills/codex/SKILL.md ~/.codex/skills/tmux-team/SKILL.md
+```
+
+### Enable Skills (Required)
+
+Skills require the feature flag:
+
+```bash
+codex --enable skills
+```
+
+Or set in your config to enable by default.
+
+### Usage
+
+```bash
+# Explicit invocation
+$tmux-team talk codex "Review this PR"
+
+# Implicit - Codex auto-selects when you mention other agents
+"Ask the codex agent to review the authentication code"
+```
+
+## Gemini CLI
+
+Gemini CLI doesn't have a native skill system yet. Use the preamble feature instead:
+
+```json
+{
+  "gemini": {
+    "pane": "%2",
+    "preamble": "You can communicate with other agents using tmux-team CLI. Run `tmux-team help` to learn more."
+  }
+}
+```
+
+Save this to `tmux-team.json` in your project root.
+
+## Verify Installation
+
+After installation, verify the skill is recognized:
+
+**Claude Code:**
+```
+/help
+# Should show: /team - Talk to peer agents...
+```
+
+**Codex:**
+```
+/skills
+# Should show: tmux-team
+```

package/skills/claude/team.md

@@ -0,0 +1,46 @@
+---
+allowed-tools: Bash(tmux-team:*)
+description: Talk to peer agents in different tmux panes
+---
+
+Execute this tmux-team command: `tmux-team $ARGUMENTS`
+
+You are working in a multi-agent tmux environment.
+Use the tmux-team CLI to communicate with other agents.
+
+## Commands
+
+```bash
+# Send message to an agent
+tmux-team talk codex "your message"
+tmux-team talk gemini "your message"
+tmux-team talk all "broadcast message"
+
+# Send with delay (useful for rate limiting)
+tmux-team talk codex "message" --delay 5
+
+# Send and wait for response (blocks until agent replies)
+tmux-team talk codex "message" --wait --timeout 120
+
+# Read agent response (default: 100 lines)
+tmux-team check codex
+tmux-team check gemini 200
+
+# List all configured agents
+tmux-team list
+```
+
+## Workflow
+
+1. Send message: `tmux-team talk codex "Review this code"`
+2. Wait 5-15 seconds (or use `--wait` flag)
+3. Read response: `tmux-team check codex`
+4. If response is cut off: `tmux-team check codex 200`
+
+## Notes
+
+- `talk` automatically sends Enter key after the message
+- `talk` automatically filters exclamation marks for Gemini (TTY issue)
+- 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

@@ -0,0 +1,46 @@
+---
+name: tmux-team
+description: Communicate with other AI agents in tmux panes. Use when you need to talk to codex, claude, gemini, or other agents.
+---
+
+When invoked, execute the tmux-team command with the provided arguments.
+
+You are working in a multi-agent tmux environment.
+Use the tmux-team CLI to communicate with other agents.
+
+## Commands
+
+```bash
+# Send message to an agent
+tmux-team talk codex "your message"
+tmux-team talk gemini "your message"
+tmux-team talk all "broadcast message"
+
+# Send with delay (useful for rate limiting)
+tmux-team talk codex "message" --delay 5
+
+# Send and wait for response (blocks until agent replies)
+tmux-team talk codex "message" --wait --timeout 120
+
+# Read agent response (default: 100 lines)
+tmux-team check codex
+tmux-team check gemini 200
+
+# List all configured agents
+tmux-team list
+```
+
+## Workflow
+
+1. Send message: `tmux-team talk codex "Review this code"`
+2. Wait 5-15 seconds (or use `--wait` flag)
+3. Read response: `tmux-team check codex`
+4. If response is cut off: `tmux-team check codex 200`
+
+## Notes
+
+- `talk` automatically sends Enter key after the message
+- `talk` automatically filters exclamation marks for Gemini (TTY issue)
+- 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.ts

@@ -19,6 +19,7 @@ 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';
 
 // ─────────────────────────────────────────────────────────────
 // Argument parsing
@@ -210,6 +211,24 @@ 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);
+        }
+        break;
+
       default:
         ctx.ui.error(`Unknown command: ${command}. Run 'tmux-team help' for usage.`);
         ctx.exit(ExitCodes.ERROR);

package/src/commands/help.ts

@@ -42,6 +42,7 @@ ${colors.yellow('COMMANDS')}
   ${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('help')}                        Show this help message
 

package/src/commands/install-skill.ts

@@ -0,0 +1,148 @@
+// ─────────────────────────────────────────────────────────────
+// install-skill command - install tmux-team skills for AI agents
+// ─────────────────────────────────────────────────────────────
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import type { Context } from '../types.js';
+import { ExitCodes } from '../context.js';
+
+type AgentType = 'claude' | 'codex';
+type Scope = 'user' | 'local';
+
+interface SkillConfig {
+  sourceFile: string;
+  userDir: string;
+  localDir: string;
+  targetFile: string;
+}
+
+function getCodexHome(): string {
+  return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+}
+
+const SKILL_CONFIGS: Record<AgentType, SkillConfig> = {
+  claude: {
+    sourceFile: 'skills/claude/team.md',
+    userDir: path.join(os.homedir(), '.claude', 'commands'),
+    localDir: '.claude/commands',
+    targetFile: 'team.md',
+  },
+  codex: {
+    sourceFile: 'skills/codex/SKILL.md',
+    userDir: path.join(getCodexHome(), 'skills', 'tmux-team'),
+    localDir: '.codex/skills/tmux-team',
+    targetFile: 'SKILL.md',
+  },
+};
+
+const SUPPORTED_AGENTS = Object.keys(SKILL_CONFIGS) as AgentType[];
+
+function findPackageRoot(): string {
+  // Get current file's directory (ES modules don't have __dirname)
+  const currentFile = fileURLToPath(import.meta.url);
+  let dir = path.dirname(currentFile);
+
+  // Try to find the package root by looking for package.json
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // Fallback: assume we're in src/commands
+  return path.resolve(path.dirname(currentFile), '..', '..');
+}
+
+function exitWithError(ctx: Context, error: string, hint?: string): never {
+  if (ctx.flags.json) {
+    ctx.ui.json({ success: false, error, hint });
+  } else {
+    ctx.ui.error(error);
+    if (hint) ctx.ui.info(hint);
+  }
+  ctx.exit(ExitCodes.ERROR);
+}
+
+export function cmdInstallSkill(ctx: Context, agent?: string, scope: string = 'user'): void {
+  // Validate agent
+  if (!agent) {
+    exitWithError(
+      ctx,
+      'Usage: tmux-team install-skill <agent> [--local|--user]',
+      `Supported agents: ${SUPPORTED_AGENTS.join(', ')}`
+    );
+  }
+
+  const agentLower = agent.toLowerCase() as AgentType;
+  if (!SUPPORTED_AGENTS.includes(agentLower)) {
+    exitWithError(
+      ctx,
+      `Unknown agent: ${agent}`,
+      `Supported agents: ${SUPPORTED_AGENTS.join(', ')}`
+    );
+  }
+
+  // Validate scope
+  const scopeLower = scope.toLowerCase() as Scope;
+  if (scopeLower !== 'user' && scopeLower !== 'local') {
+    exitWithError(ctx, `Invalid scope: ${scope}. Use 'user' or 'local'.`);
+  }
+
+  const config = SKILL_CONFIGS[agentLower];
+  const pkgRoot = findPackageRoot();
+  const sourcePath = path.join(pkgRoot, config.sourceFile);
+
+  // Check source file exists
+  if (!fs.existsSync(sourcePath)) {
+    exitWithError(
+      ctx,
+      `Skill file not found: ${sourcePath}`,
+      'Make sure tmux-team is properly installed.'
+    );
+  }
+
+  // Determine target directory
+  const targetDir = scopeLower === 'user' ? config.userDir : path.resolve(config.localDir);
+  const targetPath = path.join(targetDir, config.targetFile);
+
+  // Check if already exists
+  if (fs.existsSync(targetPath) && !ctx.flags.force) {
+    exitWithError(ctx, `Skill already exists: ${targetPath}`, 'Use --force to overwrite.');
+  }
+
+  // Create directory if needed
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    if (ctx.flags.verbose) {
+      ctx.ui.info(`Created directory: ${targetDir}`);
+    }
+  }
+
+  // Copy file
+  fs.copyFileSync(sourcePath, targetPath);
+
+  if (ctx.flags.json) {
+    ctx.ui.json({
+      success: true,
+      agent: agentLower,
+      scope: scopeLower,
+      path: targetPath,
+    });
+  } else {
+    ctx.ui.success(`Installed ${agentLower} skill to ${targetPath}`);
+
+    // Show usage hint
+    if (agentLower === 'claude') {
+      ctx.ui.info('Usage: /team talk codex "message"');
+    } else if (agentLower === 'codex') {
+      ctx.ui.info('Enable skills: codex --enable skills');
+      ctx.ui.info('Usage: $tmux-team or implicit invocation');
+    }
+  }
+}

package/src/commands/talk.test.ts

@@ -443,6 +443,12 @@ describe('cmdTalk - --wait mode', () => {
     }
   });
 
+  // Helper: generate mock capture output with proper marker structure
+  // The end marker must appear TWICE: once in instruction, once from "agent"
+  function mockCompleteResponse(nonce: string, response: string): string {
+    return `{tmux-team-start:${nonce}}\nHello\n\n[IMPORTANT: When your response is complete, print exactly: {tmux-team-end:${nonce}}]\n${response}\n{tmux-team-end:${nonce}}`;
+  }
+
   it('appends nonce instruction to message', async () => {
     const tmux = createMockTmux();
     // Set up capture to return the nonce marker immediately
@@ -450,10 +456,10 @@ describe('cmdTalk - --wait mode', () => {
     tmux.capture = () => {
       captureCount++;
       if (captureCount === 1) return ''; // Baseline
-      // Return marker on second capture
+      // Return marker on second capture - must include instruction AND agent's end marker
       const sent = tmux.sends[0]?.message || '';
       const match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      return match ? `Response here {tmux-team-end:${match[1]}}` : '';
+      return match ? mockCompleteResponse(match[1], 'Response here') : '';
     };
 
     const ctx = createContext({
@@ -492,7 +498,7 @@ describe('cmdTalk - --wait mode', () => {
       const sent = tmux.sends[0]?.message || '';
       const match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (match) {
-        return `baseline content\n\nAgent response here\n\n{tmux-team-end:${match[1]}}`;
+        return mockCompleteResponse(match[1], 'Agent response here');
       }
       return 'baseline content';
     };
@@ -563,14 +569,15 @@ describe('cmdTalk - --wait mode', () => {
     const oldContent = 'Previous conversation\nOld content here';
 
     tmux.capture = () => {
-      // Simulate scrollback with old content, start marker, response, and end marker
+      // Simulate scrollback with old content, then our instruction (with end marker), response, and agent's end marker
       const sent = tmux.sends[0]?.message || '';
       const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (startMatch && endMatch) {
         // Start and end markers should have the same nonce
         expect(startMatch[1]).toBe(endMatch[1]);
-        return `${oldContent}\n\n{tmux-team-start:${startMatch[1]}}\nMessage content here\n\nNew response content\n\n{tmux-team-end:${endMatch[1]}}`;
+        // Must include end marker TWICE: once in instruction, once from "agent"
+        return `${oldContent}\n\n{tmux-team-start:${startMatch[1]}}\nMessage content here\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\nNew response content\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return oldContent;
     };
@@ -610,7 +617,7 @@ describe('cmdTalk - --wait mode', () => {
       if (captureCount === 1) return '';
       const sent = tmux.sends[0]?.message || '';
       const match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      return match ? `Done {tmux-team-end:${match[1]}}` : '';
+      return match ? mockCompleteResponse(match[1], 'Done') : '';
     };
 
     const paths = createTestPaths(testDir);
@@ -673,22 +680,22 @@ describe('cmdTalk - --wait mode', () => {
     // Create mock tmux that returns markers for each agent after a delay
     const tmux = createMockTmux();
     let captureCount = 0;
-    const markersByPane: Record<string, string> = {};
+    const noncesByPane: Record<string, string> = {};
 
-    // Mock send to capture the marker for each pane
+    // Mock send to capture the nonce for each pane
     tmux.send = (pane: string, msg: string) => {
       const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (match) {
-        markersByPane[pane] = match[0];
+        noncesByPane[pane] = match[1];
       }
     };
 
-    // Mock capture to return the marker after first poll
+    // Mock capture to return complete response after first poll
     tmux.capture = (pane: string) => {
       captureCount++;
-      // Return marker on second capture for each pane
-      if (captureCount > 3 && markersByPane[pane]) {
-        return `Response from agent\n${markersByPane[pane]}`;
+      // Return complete response on second capture for each pane
+      if (captureCount > 3 && noncesByPane[pane]) {
+        return mockCompleteResponse(noncesByPane[pane], 'Response from agent');
       }
       return 'working...';
     };
@@ -722,19 +729,19 @@ describe('cmdTalk - --wait mode', () => {
 
   it('handles partial timeout in wait mode with all target', async () => {
     const tmux = createMockTmux();
-    const markersByPane: Record<string, string> = {};
+    const noncesByPane: Record<string, string> = {};
 
     tmux.send = (pane: string, msg: string) => {
       const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (match) {
-        markersByPane[pane] = match[0];
+        noncesByPane[pane] = match[1];
       }
     };
 
     // Only pane 10.1 responds, 10.2 times out
     tmux.capture = (pane: string) => {
-      if (pane === '10.1' && markersByPane[pane]) {
-        return `Response from codex\n${markersByPane[pane]}`;
+      if (pane === '10.1' && noncesByPane[pane]) {
+        return mockCompleteResponse(noncesByPane[pane], 'Response from codex');
       }
       return 'still working...';
     };
@@ -789,11 +796,11 @@ describe('cmdTalk - --wait mode', () => {
       }
     };
 
-    // Return markers immediately
+    // Return complete response immediately
     tmux.capture = (pane: string) => {
       const idx = pane === '10.1' ? 0 : 1;
       if (nonces[idx]) {
-        return `Response\n{tmux-team-end:${nonces[idx]}}`;
+        return mockCompleteResponse(nonces[idx], 'Response');
       }
       return '';
     };
@@ -861,12 +868,13 @@ describe('cmdTalk - nonce collision handling', () => {
         }
         return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
       }
-      // Finally, new end marker appears
+      // Finally, new end marker appears - must have TWO occurrences of new end marker
       const sent = tmux.sends[0]?.message || '';
       const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (startMatch && endMatch) {
-        return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}\n\n{tmux-team-start:${startMatch[1]}}\nNew question asked\n\nNew response\n\n{tmux-team-end:${endMatch[1]}}`;
+        // Old markers in scrollback + new instruction (with end marker) + response + agent's end marker
+        return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}\n\n{tmux-team-start:${startMatch[1]}}\nNew question asked\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\nNew response\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
     };
@@ -916,10 +924,10 @@ describe('cmdTalk - JSON output contract', () => {
 
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        return `{tmux-team-start:${startMatch[1]}}\nMessage\n\nResponse\n\n{tmux-team-end:${endMatch[1]}}`;
+      if (endMatch) {
+        // Must have TWO end markers: one in instruction, one from "agent"
+        return `{tmux-team-start:${endMatch[1]}}\nMessage\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\nResponse\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return '';
     };
@@ -988,6 +996,140 @@ describe('cmdTalk - JSON output contract', () => {
     expect(output).toHaveProperty('startMarker');
     expect(output).toHaveProperty('endMarker');
   });
+
+  it('captures partialResponse on timeout when agent started responding', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    // Simulate agent started responding but didn't finish (no end marker)
+    tmux.capture = () =>
+      '{tmux-team-start:abcd}\nHello\n\n[IMPORTANT: When your response is complete, print exactly: {tmux-team-end:abcd}]\nThis is partial content\nStill writing...';
+
+    const ctx = createContext({
+      tmux,
+      ui,
+      paths: createTestPaths(testDir),
+      flags: { wait: true, json: true, timeout: 0.05 },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
+    });
+
+    try {
+      await cmdTalk(ctx, 'claude', 'Hello');
+    } catch {
+      // Expected timeout
+    }
+
+    const output = ui.jsonOutput[0] as Record<string, unknown>;
+    expect(output).toHaveProperty('status', 'timeout');
+    expect(output).toHaveProperty('partialResponse');
+    expect(output.partialResponse).toContain('This is partial content');
+    expect(output.partialResponse).toContain('Still writing...');
+  });
+
+  it('returns null partialResponse when nothing captured', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    // Nothing meaningful in the capture
+    tmux.capture = () => 'random scrollback content';
+
+    const ctx = createContext({
+      tmux,
+      ui,
+      paths: createTestPaths(testDir),
+      flags: { wait: true, json: true, timeout: 0.05 },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
+    });
+
+    try {
+      await cmdTalk(ctx, 'claude', 'Hello');
+    } catch {
+      // Expected timeout
+    }
+
+    const output = ui.jsonOutput[0] as Record<string, unknown>;
+    expect(output).toHaveProperty('status', 'timeout');
+    expect(output.partialResponse).toBeNull();
+  });
+
+  it('captures partialResponse in broadcast timeout', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+    const markersByPane: Record<string, string> = {};
+
+    tmux.send = (pane: string, msg: string) => {
+      const match = msg.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (match) markersByPane[pane] = match[1];
+    };
+
+    // codex completes, gemini times out with partial response
+    tmux.capture = (pane: string) => {
+      if (pane === '10.1') {
+        const nonce = markersByPane['10.1'];
+        return `{tmux-team-start:${nonce}}\nMsg\n\n[IMPORTANT: print {tmux-team-end:${nonce}}]\nResponse\n{tmux-team-end:${nonce}}`;
+      }
+      // gemini has partial response
+      const nonce = markersByPane['10.2'];
+      return `{tmux-team-start:${nonce}}\nMsg\n\n[IMPORTANT: print {tmux-team-end:${nonce}}]\nPartial gemini output...`;
+    };
+
+    const paths = createTestPaths(testDir);
+    const ctx = createContext({
+      ui,
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 0.1, json: true },
+      config: {
+        defaults: {
+          timeout: 0.1,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
+    });
+
+    try {
+      await cmdTalk(ctx, 'all', 'Hello');
+    } catch {
+      // Expected timeout exit
+    }
+
+    const result = ui.jsonOutput[0] as {
+      results: Array<{
+        agent: string;
+        status: string;
+        response?: string;
+        partialResponse?: string;
+      }>;
+    };
+    const codexResult = result.results.find((r) => r.agent === 'codex');
+    const geminiResult = result.results.find((r) => r.agent === 'gemini');
+
+    expect(codexResult?.status).toBe('completed');
+    expect(codexResult?.response).toContain('Response');
+
+    expect(geminiResult?.status).toBe('timeout');
+    expect(geminiResult?.partialResponse).toContain('Partial gemini output');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────
@@ -1007,17 +1149,22 @@ describe('cmdTalk - start/end marker extraction', () => {
     }
   });
 
+  // Helper: generate mock capture output with proper marker structure
+  // The end marker must appear TWICE: once in instruction, once from "agent"
+  function mockResponse(nonce: string, response: string): string {
+    return `{tmux-team-start:${nonce}}\nContent\n\n[IMPORTANT: print {tmux-team-end:${nonce}}]\n${response}\n{tmux-team-end:${nonce}}`;
+  }
+
   it('includes both start and end markers in sent message', async () => {
     const tmux = createMockTmux();
     const ui = createMockUI();
 
-    // Return markers immediately to complete
+    // Return complete response immediately
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        return `${startMatch[0]}\nContent\nResponse\n${endMatch[0]}`;
+      if (endMatch) {
+        return mockResponse(endMatch[1], 'Response');
       }
       return '';
     };
@@ -1048,11 +1195,10 @@ describe('cmdTalk - start/end marker extraction', () => {
 
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        // Simulate scrollback with content before start marker, message, and response
-        return `Old garbage\nMore old stuff\n{tmux-team-start:${startMatch[1]}}\nThe original message\n\nThis is the actual response\n\n{tmux-team-end:${endMatch[1]}}\nContent after marker`;
+      if (endMatch) {
+        // Simulate scrollback with content before start marker, then proper instruction + response
+        return `Old garbage\nMore old stuff\n{tmux-team-start:${endMatch[1]}}\nThe original message\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\nThis is the actual response\n\n{tmux-team-end:${endMatch[1]}}\nContent after marker`;
       }
       return 'Old garbage\nMore old stuff';
     };
@@ -1085,10 +1231,9 @@ Line 4 final`;
 
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        return `{tmux-team-start:${startMatch[1]}}\nMessage\n\n${multilineResponse}\n\n{tmux-team-end:${endMatch[1]}}`;
+      if (endMatch) {
+        return `{tmux-team-start:${endMatch[1]}}\nMessage\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\n${multilineResponse}\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return '';
     };
@@ -1114,11 +1259,10 @@ Line 4 final`;
 
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        // Just markers with message, agent printed end marker immediately
-        return `{tmux-team-start:${startMatch[1]}}\nMessage here\n{tmux-team-end:${endMatch[1]}}`;
+      if (endMatch) {
+        // Agent printed end marker immediately with no content
+        return `{tmux-team-start:${endMatch[1]}}\nMessage here\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\n{tmux-team-end:${endMatch[1]}}`;
       }
       return '';
     };
@@ -1145,11 +1289,10 @@ Line 4 final`;
 
     tmux.capture = () => {
       const sent = tmux.sends[0]?.message || '';
-      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (startMatch && endMatch) {
-        // Start marker followed by newline, then content
-        return `Old stuff\n{tmux-team-start:${startMatch[1]}}\nActual response content\n{tmux-team-end:${endMatch[1]}}`;
+      if (endMatch) {
+        // Start marker followed by newline, then instruction and content
+        return `Old stuff\n{tmux-team-start:${endMatch[1]}}\nMessage\n\n[IMPORTANT: print {tmux-team-end:${endMatch[1]}}]\nActual response content\n{tmux-team-end:${endMatch[1]}}`;
       }
       return 'Old stuff';
     };
@@ -1182,10 +1325,11 @@ Line 4 final`;
       if (startMatch && endMatch) {
         if (captureCount < 3) {
           // First few captures: old markers in history, new start marker sent but not end yet
-          return `{tmux-team-start:old1}\nOld message\nOld response\n{tmux-team-end:old1}\n\n{tmux-team-start:${startMatch[1]}}\nNew message pending`;
+          // (only ONE end marker in instruction = still waiting)
+          return `{tmux-team-start:old1}\nOld message\nOld response\n{tmux-team-end:old1}\n\n{tmux-team-start:${startMatch[1]}}\nNew message\n[When done: {tmux-team-end:${endMatch[1]}}]`;
         }
-        // Finally, new end marker appears
-        return `{tmux-team-start:old1}\nOld message\nOld response\n{tmux-team-end:old1}\n\n{tmux-team-start:${startMatch[1]}}\nNew message\n\nNew actual response\n\n{tmux-team-end:${endMatch[1]}}`;
+        // Finally, new end marker appears (TWO occurrences = complete)
+        return `{tmux-team-start:old1}\nOld message\nOld response\n{tmux-team-end:old1}\n\n{tmux-team-start:${startMatch[1]}}\nNew message\n[When done: {tmux-team-end:${endMatch[1]}}]\n\nNew actual response\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return '';
     };
@@ -1219,7 +1363,8 @@ Line 4 final`;
       const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
       const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
       if (startMatch && endMatch) {
-        return `${lotsOfContent}\n{tmux-team-start:${startMatch[1]}}\nMessage\n\nThe actual response\n\n{tmux-team-end:${endMatch[1]}}`;
+        // TWO end markers: one in instruction, one from "agent" response
+        return `${lotsOfContent}\n{tmux-team-start:${startMatch[1]}}\nMessage\n[When done: {tmux-team-end:${endMatch[1]}}]\n\nThe actual response\n\n{tmux-team-end:${endMatch[1]}}`;
       }
       return lotsOfContent;
     };

package/src/commands/talk.ts

@@ -32,6 +32,41 @@ function renderWaitLine(agent: string, elapsedSeconds: number): string {
   return `⏳ Waiting for ${agent}... (${s}s)`;
 }
 
+/**
+ * Extract partial response from output when end marker is not found.
+ * Used to capture whatever the agent wrote before timeout.
+ */
+function extractPartialResponse(
+  output: string,
+  startMarker: string,
+  _endMarker: string
+): string | null {
+  // Look for instruction end pattern `}]` (the instruction ends with `{end}]`)
+  const instructionEndPattern = '}]';
+  const instructionEndIndex = output.lastIndexOf(instructionEndPattern);
+
+  let responseStart = 0;
+  if (instructionEndIndex !== -1) {
+    // Find the first newline after the instruction's closing `}]`
+    responseStart = output.indexOf('\n', instructionEndIndex + 2);
+    if (responseStart !== -1) responseStart += 1;
+    else responseStart = instructionEndIndex + 2;
+  } else {
+    // Fallback: try to find newline after start marker
+    const startMarkerIndex = output.lastIndexOf(startMarker);
+    if (startMarkerIndex !== -1) {
+      responseStart = output.indexOf('\n', startMarkerIndex);
+      if (responseStart !== -1) responseStart += 1;
+      else return null; // Can't find response start
+    } else {
+      return null; // Start marker not found
+    }
+  }
+
+  const partial = output.slice(responseStart).trim();
+  return partial || null;
+}
+
 // ─────────────────────────────────────────────────────────────
 // Types for broadcast wait mode
 // ─────────────────────────────────────────────────────────────
@@ -45,6 +80,7 @@ interface AgentWaitState {
   endMarker: string;
   status: 'pending' | 'completed' | 'timeout' | 'error';
   response?: string;
+  partialResponse?: string | null;
   error?: string;
   elapsedMs?: number;
 }
@@ -251,8 +287,22 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
       const elapsedSeconds = (Date.now() - startedAt) / 1000;
       if (elapsedSeconds >= timeoutSeconds) {
         clearActiveRequest(ctx.paths, target, requestId);
+
+        // Capture partial response on timeout
+        let partialResponse: string | null = null;
+        try {
+          const output = tmux.capture(pane, captureLines);
+          const extracted = extractPartialResponse(output, startMarker, endMarker);
+          if (extracted) partialResponse = extracted;
+        } catch {
+          // Ignore capture errors on timeout
+        }
+
+        if (isTTY) {
+          process.stdout.write('\r' + ' '.repeat(80) + '\r');
+        }
+
         if (flags.json) {
-          // Single JSON output with error field (don't call ui.error separately)
           ui.json({
             target,
             pane,
@@ -262,13 +312,17 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
             nonce,
             startMarker,
             endMarker,
+            partialResponse,
           });
           exit(ExitCodes.TIMEOUT);
         }
-        if (isTTY) {
-          process.stdout.write('\r' + ' '.repeat(80) + '\r');
-        }
+
         ui.error(`Timed out waiting for ${target} after ${Math.floor(timeoutSeconds)}s.`);
+        if (partialResponse) {
+          console.log();
+          console.log(colors.yellow(`─── Partial response from ${target} (${pane}) ───`));
+          console.log(partialResponse);
+        }
         exit(ExitCodes.TIMEOUT);
       }
 
@@ -277,7 +331,7 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
           process.stdout.write('\r' + renderWaitLine(target, elapsedSeconds));
         } else {
           const now = Date.now();
-          if (now - lastNonTtyLogAt >= 5000) {
+          if (now - lastNonTtyLogAt >= 30000) {
             lastNonTtyLogAt = now;
             console.error(
               `[tmux-team] Waiting for ${target} (${Math.floor(elapsedSeconds)}s elapsed)`
@@ -297,9 +351,16 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
         exit(ExitCodes.ERROR);
       }
 
-      // Find end marker (use lastIndexOf because the marker appears in the instruction AND agent's response)
-      const endMarkerIndex = output.lastIndexOf(endMarker);
-      if (endMarkerIndex === -1) continue;
+      // Find end marker - it appears once in our instruction and again when agent prints it
+      // We need TWO occurrences: one in instruction + one from agent = complete
+      // Only ONE occurrence means it's just in instruction = still waiting
+      const firstEndMarkerIndex = output.indexOf(endMarker);
+      const lastEndMarkerIndex = output.lastIndexOf(endMarker);
+      if (firstEndMarkerIndex === -1 || firstEndMarkerIndex === lastEndMarkerIndex) {
+        // No marker or only one (in instruction) - still waiting
+        continue;
+      }
+      const endMarkerIndex = lastEndMarkerIndex;
 
       // Find the end of our instruction by looking for `}]` pattern (the instruction ends with `{end}]`)
       // This is more reliable than looking for newline after start marker because
@@ -467,6 +528,16 @@ async function cmdTalkAllWait(
           state.status = 'timeout';
           state.error = `Timed out after ${Math.floor(timeoutSeconds)}s`;
           state.elapsedMs = Math.floor(elapsedSeconds * 1000);
+
+          // Capture partial response on timeout
+          try {
+            const output = tmux.capture(state.pane, captureLines);
+            const extracted = extractPartialResponse(output, state.startMarker, state.endMarker);
+            if (extracted) state.partialResponse = extracted;
+          } catch {
+            // Ignore capture errors on timeout
+          }
+
           clearActiveRequest(paths, state.agent, state.requestId);
           if (!flags.json) {
             console.log(
@@ -482,7 +553,7 @@ async function cmdTalkAllWait(
       // Progress logging (non-TTY)
       if (!flags.json && !isTTY) {
         const now = Date.now();
-        if (now - lastLogAt >= 5000) {
+        if (now - lastLogAt >= 30000) {
           lastLogAt = now;
           const pending = pendingAgents()
             .map((s) => s.agent)
@@ -511,9 +582,16 @@ async function cmdTalkAllWait(
           continue;
         }
 
-        // Find end marker (use lastIndexOf because the marker appears in the instruction AND agent's response)
-        const endMarkerIndex = output.lastIndexOf(state.endMarker);
-        if (endMarkerIndex === -1) continue;
+        // Find end marker - it appears once in our instruction and again when agent prints it
+        // We need TWO occurrences: one in instruction + one from agent = complete
+        // Only ONE occurrence means it's just in instruction = still waiting
+        const firstEndMarkerIndex = output.indexOf(state.endMarker);
+        const lastEndMarkerIndex = output.lastIndexOf(state.endMarker);
+        if (firstEndMarkerIndex === -1 || firstEndMarkerIndex === lastEndMarkerIndex) {
+          // No marker or only one (in instruction) - still waiting
+          continue;
+        }
+        const endMarkerIndex = lastEndMarkerIndex;
 
         // Find the end of our instruction by looking for `}]` pattern (the instruction ends with `{end}]`)
         // This is more reliable than looking for newline after start marker because
@@ -602,6 +680,7 @@ function outputBroadcastResults(
         endMarker: s.endMarker,
         status: s.status,
         response: s.response,
+        partialResponse: s.partialResponse,
         error: s.error,
         elapsedMs: s.elapsedMs,
       })),
@@ -623,6 +702,10 @@ function outputBroadcastResults(
       console.log(colors.cyan(`─── Response from ${state.agent} (${state.pane}) ───`));
       console.log(state.response);
       console.log();
+    } else if (state.status === 'timeout' && state.partialResponse) {
+      console.log(colors.yellow(`─── Partial response from ${state.agent} (${state.pane}) ───`));
+      console.log(state.partialResponse);
+      console.log();
     }
   }
 }