tmux-team 2.0.0-alpha.3 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-team",
-  "version": "2.0.0-alpha.3",
+  "version": "2.1.0",
   "description": "CLI tool for AI agent collaboration in tmux - manage cross-pane communication",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -7,7 +7,8 @@ import { createContext, ExitCodes } from './context.js';
 import type { Flags } from './types.js';
 
 // Commands
-import { cmdHelp } from './commands/help.js';
+import { cmdHelp, HelpConfig } from './commands/help.js';
+import { loadConfig, resolvePaths } from './config.js';
 import { cmdInit } from './commands/init.js';
 import { cmdList } from './commands/list.js';
 import { cmdAdd } from './commands/add.js';
@@ -103,9 +104,20 @@ function main(): void {
   const argv = process.argv.slice(2);
   const { command, args, flags } = parseArgs(argv);
 
-  // Help doesn't need context
+  // Help - load config to show current mode/timeout
   if (!command || command === 'help' || command === '--help' || command === '-h') {
-    cmdHelp();
+    try {
+      const paths = resolvePaths();
+      const config = loadConfig(paths);
+      const helpConfig: HelpConfig = {
+        mode: config.mode,
+        timeout: config.defaults.timeout,
+      };
+      cmdHelp(helpConfig);
+    } catch {
+      // Fallback if config can't be loaded
+      cmdHelp();
+    }
     process.exit(ExitCodes.SUCCESS);
   }
 

package/src/commands/config.ts

@@ -155,11 +155,10 @@ function clearConfig(ctx: Context, key?: string): void {
  * Config command entry point.
  */
 export function cmdConfig(ctx: Context, args: string[]): void {
-  const subcommand = args[0];
-
-  // Parse --global flag
+  // Parse --global flag first, then determine subcommand
   const globalFlag = args.includes('--global') || args.includes('-g');
   const filteredArgs = args.filter((a) => a !== '--global' && a !== '-g');
+  const subcommand = filteredArgs[0];
 
   switch (subcommand) {
     case undefined:

package/src/commands/help.ts

@@ -5,10 +5,30 @@
 import { colors } from '../ui.js';
 import { VERSION } from '../version.js';
 
-export function cmdHelp(): void {
+export interface HelpConfig {
+  mode?: 'polling' | 'wait';
+  timeout?: number;
+}
+
+export function cmdHelp(config?: HelpConfig): void {
+  const mode = config?.mode ?? 'polling';
+  const timeout = config?.timeout ?? 180;
+  const isWaitMode = mode === 'wait';
+
+  // Mode indicator with clear explanation
+  const modeInfo = isWaitMode
+    ? `${colors.yellow('CURRENT MODE')}: ${colors.green('wait')} (timeout: ${timeout}s)
+  ${colors.dim('→ talk commands will BLOCK until agent responds or timeout')}
+  ${colors.dim('→ Response is returned directly, no need to use check command')}`
+    : `${colors.yellow('CURRENT MODE')}: ${colors.cyan('polling')}
+  ${colors.dim('→ talk commands send and return immediately')}
+  ${colors.dim('→ Use check command to read agent response')}`;
+
   console.log(`
 ${colors.cyan('tmux-team')} v${VERSION} - AI agent collaboration in tmux
 
+${modeInfo}
+
 ${colors.yellow('USAGE')}
   tmux-team <command> [arguments]
 
@@ -31,36 +51,33 @@ ${colors.yellow('OPTIONS')}
   ${colors.green('--verbose')}                   Show detailed output
   ${colors.green('--force')}                     Skip warnings
 
-${colors.yellow('TALK OPTIONS')} ${colors.dim('(v2)')}
-  ${colors.green('--delay')} <seconds>           Wait before sending (default: seconds)
-  ${colors.green('--wait')}                      Wait for agent response (nonce-based)
-  ${colors.green('--timeout')} <seconds>         Max wait time (default: 60)
+${colors.yellow('TALK OPTIONS')}
+  ${colors.green('--delay')} <seconds>           Wait before sending
+  ${colors.green('--wait')}                      Force wait mode (block until response)
+  ${colors.green('--timeout')} <seconds>         Max wait time (current: ${timeout}s)
   ${colors.green('--no-preamble')}               Skip agent preamble for this message
 
-${colors.yellow('EXAMPLES')}
-  tmux-team talk codex "Please review the PR"
-  tmux-team talk all "Sync meeting in 5 minutes"
-  tmux-team check gemini 50
+${colors.yellow('EXAMPLES')}${
+    isWaitMode
+      ? `
+  ${colors.dim('# Wait mode: commands block until response')}
+  tmux-team talk codex "Review this PR"     ${colors.dim('← blocks, returns response')}
+  tmux-team talk all "Status update"        ${colors.dim('← waits for all agents')}`
+      : `
+  ${colors.dim('# Polling mode: send then check')}
+  tmux-team talk codex "Review this PR"     ${colors.dim('← sends immediately')}
+  tmux-team check codex                     ${colors.dim('← read response later')}`
+  }
   tmux-team list --json
   tmux-team add codex 10.1 "Code review specialist"
-  tmux-team update codex --pane 10.2
-  tmux-team remove codex
 
 ${colors.yellow('CONFIG')}
   Local:  ./tmux-team.json (pane registry + $config override)
   Global: ~/.config/tmux-team/config.json (settings)
 
-${colors.yellow('CONFIG EXAMPLES')}
-  tmux-team config                     Show current settings
-  tmux-team config set mode wait       Set mode in local config (repo override)
-  tmux-team config set mode polling --global  Set mode in global config
-  tmux-team config clear mode          Clear local override for mode
-  tmux-team config clear               Clear all local overrides
-
-${colors.yellow('PREAMBLE EXAMPLES')}
-  tmux-team preamble                   Show all preambles
-  tmux-team preamble show codex        Show preamble for codex
-  tmux-team preamble set codex "You are a code reviewer. Be concise."
-  tmux-team preamble clear codex       Clear preamble for codex
+${colors.yellow('CHANGE MODE')}
+  tmux-team config set mode wait            ${colors.dim('Enable wait mode (local)')}
+  tmux-team config set mode polling         ${colors.dim('Enable polling mode (local)')}
+  tmux-team config set timeout 120          ${colors.dim('Set timeout to 120s')}
 `);
 }

package/src/commands/talk.test.ts

@@ -533,16 +533,144 @@ describe('cmdTalk - --wait mode', () => {
     }
   });
 
-  it('errors when using --wait with all target', async () => {
+  it('supports wait mode with all target (parallel polling)', async () => {
+    // Create mock tmux that returns markers for each agent after a delay
+    const tmux = createMockTmux();
+    let captureCount = 0;
+    const markersByPane: Record<string, string> = {};
+
+    // Mock send to capture the marker 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];
+      }
+    };
+
+    // Mock capture to return the marker 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 'working...';
+    };
+
     const ui = createMockUI();
+    const paths = createTestPaths(testDir);
     const ctx = createContext({
       ui,
-      paths: createTestPaths(testDir),
-      flags: { wait: true },
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 5 },
+      config: {
+        defaults: { timeout: 5, pollInterval: 0.05, captureLines: 100 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
+    });
+
+    await cmdTalk(ctx, 'all', 'Hello');
+
+    // Should have captured both panes
+    expect(captureCount).toBeGreaterThan(2);
+  });
+
+  it('handles partial timeout in wait mode with all target', async () => {
+    const tmux = createMockTmux();
+    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[0];
+      }
+    };
+
+    // 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]}`;
+      }
+      return 'still working...';
+    };
+
+    const ui = createMockUI();
+    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 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
     });
 
-    await expect(cmdTalk(ctx, 'all', 'Hello')).rejects.toThrow('exit(1)');
-    expect(ui.errors[0]).toContain('Wait mode is not supported');
+    try {
+      await cmdTalk(ctx, 'all', 'Hello');
+    } catch {
+      // Expected timeout exit
+    }
+
+    // Should have JSON output with both results
+    expect(ui.jsonOutput.length).toBe(1);
+    const result = ui.jsonOutput[0] as {
+      summary: { completed: number; timeout: number };
+      results: Array<{ agent: string; status: string }>;
+    };
+    expect(result.summary.completed).toBe(1);
+    expect(result.summary.timeout).toBe(1);
+    expect(result.results.find((r) => r.agent === 'codex')?.status).toBe('completed');
+    expect(result.results.find((r) => r.agent === 'gemini')?.status).toBe('timeout');
+  });
+
+  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(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (match) {
+        nonces.push(match[1]);
+      }
+    };
+
+    // Return markers immediately
+    tmux.capture = (pane: string) => {
+      const idx = pane === '10.1' ? 0 : 1;
+      if (nonces[idx]) {
+        return `Response\n{tmux-team-end:${nonces[idx]}}`;
+      }
+      return '';
+    };
+
+    const paths = createTestPaths(testDir);
+    const ctx = createContext({
+      tmux,
+      paths,
+      flags: { wait: true, timeout: 5 },
+      config: {
+        defaults: { timeout: 5, pollInterval: 0.02, captureLines: 100 },
+        paneRegistry: {
+          codex: { pane: '10.1' },
+          gemini: { pane: '10.2' },
+        },
+      },
+    });
+
+    await cmdTalk(ctx, 'all', 'Hello');
+
+    // Each agent should have a unique nonce
+    expect(nonces.length).toBe(2);
+    expect(nonces[0]).not.toBe(nonces[1]);
   });
 });
 

package/src/commands/talk.ts

@@ -2,7 +2,7 @@
 // talk command - send message to agent(s)
 // ─────────────────────────────────────────────────────────────
 
-import type { Context } from '../types.js';
+import type { Context, PaneEntry } from '../types.js';
 import type { WaitResult } from '../types.js';
 import { ExitCodes } from '../exits.js';
 import { colors } from '../ui.js';
@@ -27,6 +27,38 @@ function renderWaitLine(agent: string, elapsedSeconds: number): string {
   return `⏳ Waiting for ${agent}... (${s}s)`;
 }
 
+// ─────────────────────────────────────────────────────────────
+// Types for broadcast wait mode
+// ─────────────────────────────────────────────────────────────
+
+interface AgentWaitState {
+  agent: string;
+  pane: string;
+  requestId: string;
+  nonce: string;
+  marker: string;
+  baseline: string;
+  status: 'pending' | 'completed' | 'timeout' | 'error';
+  response?: string;
+  error?: string;
+  elapsedMs?: number;
+}
+
+interface BroadcastWaitResult {
+  target: 'all';
+  mode: 'wait';
+  self?: string;
+  identityWarning?: string;
+  summary: {
+    total: number;
+    completed: number;
+    timeout: number;
+    error: number;
+    skipped: number;
+  };
+  results: AgentWaitState[];
+}
+
 /**
  * Build the final message with optional preamble.
  * Format: [SYSTEM: <preamble>]\n\n<message>
@@ -54,11 +86,6 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
   const { ui, config, tmux, flags, exit } = ctx;
   const waitEnabled = Boolean(flags.wait) || config.mode === 'wait';
 
-  if (waitEnabled && target === 'all') {
-    ui.error("Wait mode is not supported with 'all' yet. Send to one agent at a time.");
-    exit(ExitCodes.ERROR);
-  }
-
   if (target === 'all') {
     const agents = Object.entries(config.paneRegistry);
     if (agents.length === 0) {
@@ -67,44 +94,58 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
     }
 
     // Determine current agent to skip self
-    const { actor: self } = resolveActor(config.paneRegistry);
+    const { actor: self, warning: identityWarning } = resolveActor(config.paneRegistry);
+
+    // Surface identity warnings (mismatch, unregistered pane, etc.)
+    if (identityWarning && !flags.json) {
+      ui.warn(identityWarning);
+    }
 
     if (flags.delay && flags.delay > 0) {
       await sleepMs(flags.delay * 1000);
     }
 
-    const results: { agent: string; pane: string; status: string }[] = [];
+    // Filter out self
+    const targetAgents = agents.filter(([name]) => name !== self);
+    const skippedSelf = agents.length !== targetAgents.length;
+
+    if (!waitEnabled) {
+      // Non-wait mode: fire and forget
+      const results: { agent: string; pane: string; status: string }[] = [];
 
-    for (const [name, data] of agents) {
-      // Skip sending to self
-      if (name === self) {
-        results.push({ agent: name, pane: data.pane, status: 'skipped (self)' });
+      if (skippedSelf) {
+        const selfData = config.paneRegistry[self];
+        results.push({ agent: self, pane: selfData?.pane || '', status: 'skipped (self)' });
         if (!flags.json) {
-          console.log(`${colors.dim('○')} Skipped ${colors.cyan(name)} (self)`);
+          console.log(`${colors.dim('○')} Skipped ${colors.cyan(self)} (self)`);
         }
-        continue;
       }
 
-      try {
-        // Build message with preamble, then apply Gemini filter
-        let msg = buildMessage(message, name, ctx);
-        if (name === 'gemini') msg = msg.replace(/!/g, '');
-        tmux.send(data.pane, msg);
-        results.push({ agent: name, pane: data.pane, status: 'sent' });
-        if (!flags.json) {
-          console.log(`${colors.green('→')} Sent to ${colors.cyan(name)} (${data.pane})`);
-        }
-      } catch {
-        results.push({ agent: name, pane: data.pane, status: 'failed' });
-        if (!flags.json) {
-          ui.warn(`Failed to send to ${name}`);
+      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);
+          results.push({ agent: name, pane: data.pane, status: 'sent' });
+          if (!flags.json) {
+            console.log(`${colors.green('→')} Sent to ${colors.cyan(name)} (${data.pane})`);
+          }
+        } catch {
+          results.push({ agent: name, pane: data.pane, status: 'failed' });
+          if (!flags.json) {
+            ui.warn(`Failed to send to ${name}`);
+          }
         }
       }
-    }
 
-    if (flags.json) {
-      ui.json({ target: 'all', results });
+      if (flags.json) {
+        ui.json({ target: 'all', self, identityWarning, results });
+      }
+      return;
     }
+
+    // Wait mode: parallel polling
+    await cmdTalkAllWait(ctx, targetAgents, message, self, identityWarning, skippedSelf);
     return;
   }
 
@@ -272,3 +313,286 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
     clearActiveRequest(ctx.paths, target, requestId);
   }
 }
+
+// ─────────────────────────────────────────────────────────────
+// Broadcast wait mode: parallel polling for all agents
+// ─────────────────────────────────────────────────────────────
+
+async function cmdTalkAllWait(
+  ctx: Context,
+  targetAgents: [string, PaneEntry][],
+  message: string,
+  self: string,
+  identityWarning: string | undefined,
+  skippedSelf: boolean
+): Promise<void> {
+  const { ui, config, tmux, flags, exit, paths } = ctx;
+  const timeoutSeconds = flags.timeout ?? config.defaults.timeout;
+  const pollIntervalSeconds = Math.max(0.1, config.defaults.pollInterval);
+  const captureLines = config.defaults.captureLines;
+
+  // Best-effort state cleanup
+  cleanupState(paths, 60 * 60);
+
+  // Initialize wait state for each agent with unique nonces
+  const agentStates: AgentWaitState[] = [];
+
+  if (!flags.json) {
+    console.log(
+      `${colors.cyan('→')} Broadcasting to ${targetAgents.length} agent(s) (wait mode)...`
+    );
+  }
+
+  // Phase 1: Send messages to all agents and capture baselines
+  for (const [name, data] of targetAgents) {
+    const requestId = makeRequestId();
+    const nonce = makeNonce(); // Unique nonce per agent (#19)
+    const marker = `{tmux-team-end:${nonce}}`;
+
+    let baseline = '';
+    try {
+      baseline = tmux.capture(data.pane, captureLines);
+    } catch {
+      agentStates.push({
+        agent: name,
+        pane: data.pane,
+        requestId,
+        nonce,
+        marker,
+        baseline: '',
+        status: 'error',
+        error: `Failed to capture pane ${data.pane}`,
+      });
+      if (!flags.json) {
+        ui.warn(`Failed to capture ${name} (${data.pane})`);
+      }
+      continue;
+    }
+
+    // Build and send message
+    const messageWithPreamble = buildMessage(message, name, ctx);
+    const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+    const msg = name === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
+
+    try {
+      tmux.send(data.pane, msg);
+      setActiveRequest(paths, name, {
+        id: requestId,
+        nonce,
+        pane: data.pane,
+        startedAtMs: Date.now(),
+      });
+      agentStates.push({
+        agent: name,
+        pane: data.pane,
+        requestId,
+        nonce,
+        marker,
+        baseline,
+        status: 'pending',
+      });
+      if (!flags.json) {
+        console.log(`  ${colors.green('→')} Sent to ${colors.cyan(name)} (${data.pane})`);
+      }
+    } catch {
+      agentStates.push({
+        agent: name,
+        pane: data.pane,
+        requestId,
+        nonce,
+        marker,
+        baseline,
+        status: 'error',
+        error: `Failed to send to pane ${data.pane}`,
+      });
+      if (!flags.json) {
+        ui.warn(`Failed to send to ${name}`);
+      }
+    }
+  }
+
+  // Track pending agents
+  const pendingAgents = () => agentStates.filter((s) => s.status === 'pending');
+
+  if (pendingAgents().length === 0) {
+    // All failed to send, output results and exit with error
+    outputBroadcastResults(ctx, agentStates, self, identityWarning, skippedSelf);
+    exit(ExitCodes.ERROR);
+    return;
+  }
+
+  const startedAt = Date.now();
+  let lastLogAt = 0;
+  const isTTY = process.stdout.isTTY && !flags.json;
+
+  // SIGINT handler: cleanup ALL active requests (#18)
+  const onSigint = (): void => {
+    for (const state of agentStates) {
+      clearActiveRequest(paths, state.agent, state.requestId);
+    }
+    if (!flags.json) {
+      process.stdout.write('\n');
+      ui.error('Interrupted.');
+    }
+    // Output partial results
+    outputBroadcastResults(ctx, agentStates, self, identityWarning, skippedSelf);
+    exit(ExitCodes.ERROR);
+  };
+
+  process.once('SIGINT', onSigint);
+
+  try {
+    // Phase 2: Poll all agents in parallel until all complete or timeout
+    while (pendingAgents().length > 0) {
+      const elapsedSeconds = (Date.now() - startedAt) / 1000;
+
+      // Check timeout for each pending agent (#17)
+      for (const state of pendingAgents()) {
+        if (elapsedSeconds >= timeoutSeconds) {
+          state.status = 'timeout';
+          state.error = `Timed out after ${Math.floor(timeoutSeconds)}s`;
+          state.elapsedMs = Math.floor(elapsedSeconds * 1000);
+          clearActiveRequest(paths, state.agent, state.requestId);
+          if (!flags.json) {
+            console.log(
+              `  ${colors.red('✗')} ${colors.cyan(state.agent)} timed out (${Math.floor(elapsedSeconds)}s)`
+            );
+          }
+        }
+      }
+
+      // All done?
+      if (pendingAgents().length === 0) break;
+
+      // Progress logging (non-TTY)
+      if (!flags.json && !isTTY) {
+        const now = Date.now();
+        if (now - lastLogAt >= 5000) {
+          lastLogAt = now;
+          const pending = pendingAgents()
+            .map((s) => s.agent)
+            .join(', ');
+          console.error(
+            `[tmux-team] Waiting for: ${pending} (${Math.floor(elapsedSeconds)}s elapsed)`
+          );
+        }
+      }
+
+      await sleepMs(pollIntervalSeconds * 1000);
+
+      // Poll each pending agent
+      for (const state of pendingAgents()) {
+        let output = '';
+        try {
+          output = tmux.capture(state.pane, captureLines);
+        } catch {
+          state.status = 'error';
+          state.error = `Failed to capture pane ${state.pane}`;
+          state.elapsedMs = Date.now() - startedAt;
+          clearActiveRequest(paths, state.agent, state.requestId);
+          if (!flags.json) {
+            ui.warn(`Failed to capture ${state.agent}`);
+          }
+          continue;
+        }
+
+        const markerIndex = output.indexOf(state.marker);
+        if (markerIndex === -1) continue;
+
+        // Found marker - extract response
+        let startIndex = 0;
+        const baselineIndex = state.baseline ? output.lastIndexOf(state.baseline) : -1;
+        if (baselineIndex !== -1) {
+          startIndex = baselineIndex + state.baseline.length;
+        }
+
+        state.response = output.slice(startIndex, markerIndex).trim();
+        state.status = 'completed';
+        state.elapsedMs = Date.now() - startedAt;
+        clearActiveRequest(paths, state.agent, state.requestId);
+
+        if (!flags.json) {
+          console.log(
+            `  ${colors.green('✓')} ${colors.cyan(state.agent)} completed (${Math.floor(state.elapsedMs / 1000)}s)`
+          );
+        }
+      }
+    }
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+    // Cleanup any remaining active requests
+    for (const state of agentStates) {
+      clearActiveRequest(paths, state.agent, state.requestId);
+    }
+  }
+
+  // Output results
+  outputBroadcastResults(ctx, agentStates, self, identityWarning, skippedSelf);
+
+  // Exit with appropriate code
+  const hasTimeout = agentStates.some((s) => s.status === 'timeout');
+  const hasError = agentStates.some((s) => s.status === 'error');
+  if (hasTimeout) {
+    exit(ExitCodes.TIMEOUT);
+  } else if (hasError) {
+    exit(ExitCodes.ERROR);
+  }
+}
+
+function outputBroadcastResults(
+  ctx: Context,
+  agentStates: AgentWaitState[],
+  self: string,
+  identityWarning: string | undefined,
+  skippedSelf: boolean
+): void {
+  const { ui, flags } = ctx;
+
+  const summary = {
+    total: agentStates.length + (skippedSelf ? 1 : 0),
+    completed: agentStates.filter((s) => s.status === 'completed').length,
+    timeout: agentStates.filter((s) => s.status === 'timeout').length,
+    error: agentStates.filter((s) => s.status === 'error').length,
+    skipped: skippedSelf ? 1 : 0,
+  };
+
+  if (flags.json) {
+    const result: BroadcastWaitResult = {
+      target: 'all',
+      mode: 'wait',
+      self,
+      identityWarning,
+      summary,
+      results: agentStates.map((s) => ({
+        agent: s.agent,
+        pane: s.pane,
+        requestId: s.requestId,
+        nonce: s.nonce,
+        marker: s.marker,
+        baseline: '', // Don't include baseline in output
+        status: s.status,
+        response: s.response,
+        error: s.error,
+        elapsedMs: s.elapsedMs,
+      })),
+    };
+    ui.json(result);
+    return;
+  }
+
+  // Human-readable output
+  console.log();
+  console.log(
+    `${colors.cyan('Summary:')} ${summary.completed} completed, ${summary.timeout} timeout, ${summary.error} error, ${summary.skipped} skipped`
+  );
+  console.log();
+
+  // Print responses
+  for (const state of agentStates) {
+    if (state.status === 'completed' && state.response) {
+      console.log(colors.cyan(`─── Response from ${state.agent} (${state.pane}) ───`));
+      console.log(state.response);
+      console.log();
+    }
+  }
+}

package/src/config.test.ts

@@ -158,7 +158,7 @@ describe('loadConfig', () => {
 
     expect(config.mode).toBe('polling');
     expect(config.preambleMode).toBe('always');
-    expect(config.defaults.timeout).toBe(60);
+    expect(config.defaults.timeout).toBe(180);
     expect(config.defaults.pollInterval).toBe(1);
     expect(config.defaults.captureLines).toBe(100);
     expect(config.agents).toEqual({});

package/src/config.ts

@@ -23,7 +23,7 @@ const DEFAULT_CONFIG: Omit<GlobalConfig, 'agents'> & { agents: Record<string, ne
   mode: 'polling',
   preambleMode: 'always',
   defaults: {
-    timeout: 60,
+    timeout: 180,
     pollInterval: 1,
     captureLines: 100,
   },

package/src/pm/commands.test.ts

@@ -770,9 +770,10 @@ describe('cmdPmList', () => {
     await cmdPmList(ctx, []);
 
     expect(ctx.ui.jsonData.length).toBe(1);
-    expect(ctx.ui.jsonData[0]).toHaveProperty('teams');
-    expect(ctx.ui.jsonData[0]).toHaveProperty('currentTeamId');
-    expect(Array.isArray(ctx.ui.jsonData[0].teams)).toBe(true);
+    const data = ctx.ui.jsonData[0] as { teams: unknown[]; currentTeamId: string | null };
+    expect(data).toHaveProperty('teams');
+    expect(data).toHaveProperty('currentTeamId');
+    expect(Array.isArray(data.teams)).toBe(true);
   });
 });
 

package/src/pm/permissions.ts

@@ -175,11 +175,12 @@ export function resolveActor(paneRegistry: Record<string, PaneEntry>): ActorReso
 
   // Pane not in registry
   if (envActor) {
-    // Agent claims identity but pane not registered - warn
+    // Agent claims identity but pane not registered - use env identity with warning
+    // Security: Still apply agent's deny patterns to prevent bypass via unregistered pane
     return {
-      actor: 'human',
-      source: 'default',
-      warning: `⚠️  Unregistered pane: TMT_AGENT_NAME="${envActor}" but pane ${currentPane} is not in registry. Treating as human (full access).`,
+      actor: envActor,
+      source: 'env',
+      warning: `⚠️  Unregistered pane: pane ${currentPane} is not in registry. Using TMT_AGENT_NAME="${envActor}".`,
     };
   }
 

package/src/pm/storage/github.ts

@@ -53,7 +53,7 @@ interface GHIssue {
 interface GHMilestone {
   number: number;
   title: string;
-  state: 'OPEN' | 'CLOSED';
+  state: 'open' | 'closed'; // REST API uses lowercase (unlike GraphQL)
   createdAt: string;
 }
 
@@ -253,7 +253,7 @@ export class GitHubAdapter implements StorageAdapter {
     return {
       id,
       name: ghMilestone.title,
-      status: ghMilestone.state === 'CLOSED' ? 'done' : 'pending',
+      status: ghMilestone.state === 'closed' ? 'done' : 'pending',
       createdAt: ghMilestone.createdAt,
       updatedAt: ghMilestone.createdAt, // GH milestones don't have updatedAt
     };