tmux-team 2.2.0 → 3.0.0-alpha.2

package/src/commands/talk.ts

@@ -13,7 +13,7 @@ import {
   setActiveRequest,
   incrementPreambleCounter,
 } from '../state.js';
-import { resolveActor } from '../pm/permissions.js';
+import { resolveActor } from '../identity.js';
 
 function sleepMs(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -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
 // ─────────────────────────────────────────────────────────────
@@ -41,10 +76,11 @@ interface AgentWaitState {
   pane: string;
   requestId: string;
   nonce: string;
-  marker: string;
-  baseline: string;
+  startMarker: string;
+  endMarker: string;
   status: 'pending' | 'completed' | 'timeout' | 'error';
   response?: string;
+  partialResponse?: string | null;
   error?: string;
   elapsedMs?: number;
 }
@@ -212,11 +248,12 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
   const requestId = makeRequestId();
   const nonce = makeNonce();
-  const marker = `{tmux-team-end:${nonce}}`;
+  const startMarker = `{tmux-team-start:${nonce}}`;
+  const endMarker = `{tmux-team-end:${nonce}}`;
 
-  // Build message with preamble, then append nonce instruction
+  // Build message with preamble, then wrap with start/end markers
   const messageWithPreamble = buildMessage(message, target, ctx);
-  const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+  const fullMessage = `${startMarker}\n${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${endMarker}]`;
 
   // Best-effort cleanup and soft-lock warning
   const state = cleanupState(ctx.paths, 60 * 60); // 1 hour TTL
@@ -227,14 +264,6 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
     );
   }
 
-  let baseline = '';
-  try {
-    baseline = tmux.capture(pane, captureLines);
-  } catch {
-    ui.error(`Failed to capture pane ${pane}. Is tmux running?`);
-    exit(ExitCodes.ERROR);
-  }
-
   setActiveRequest(ctx.paths, target, { id: requestId, nonce, pane, startedAtMs: Date.now() });
 
   const startedAt = Date.now();
@@ -258,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,
@@ -267,14 +310,19 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
             error: `Timed out waiting for ${target} after ${Math.floor(timeoutSeconds)}s`,
             requestId,
             nonce,
-            marker,
+            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);
       }
 
@@ -283,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)`
@@ -303,16 +351,39 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
         exit(ExitCodes.ERROR);
       }
 
-      const markerIndex = output.indexOf(marker);
-      if (markerIndex === -1) continue;
-
-      let startIndex = 0;
-      const baselineIndex = baseline ? output.lastIndexOf(baseline) : -1;
-      if (baselineIndex !== -1) {
-        startIndex = baselineIndex + baseline.length;
+      // 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
+      // the message may be word-wrapped across multiple visual lines
+      let responseStart = 0;
+      const instructionEndPattern = '}]';
+      const instructionEndIndex = output.lastIndexOf(instructionEndPattern, endMarkerIndex);
+      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: if no `}]` found, 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 responseStart = startMarkerIndex + startMarker.length;
+        }
       }
 
-      const response = output.slice(startIndex, markerIndex).trim();
+      const response = output.slice(responseStart, endMarkerIndex).trim();
 
       if (!flags.json && isTTY) {
         process.stdout.write('\r' + ' '.repeat(80) + '\r');
@@ -323,7 +394,7 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
       clearActiveRequest(ctx.paths, target, requestId);
 
-      const result: WaitResult = { requestId, nonce, marker, response };
+      const result: WaitResult = { requestId, nonce, startMarker, endMarker, response };
       if (flags.json) {
         ui.json({ target, pane, status: 'completed', ...result });
       } else {
@@ -367,35 +438,16 @@ async function cmdTalkAllWait(
     );
   }
 
-  // Phase 1: Send messages to all agents and capture baselines
+  // Phase 1: Send messages to all agents with start/end markers
   for (const [name, data] of targetAgents) {
     const requestId = makeRequestId();
     const nonce = makeNonce(); // Unique nonce per agent (#19)
-    const marker = `{tmux-team-end:${nonce}}`;
+    const startMarker = `{tmux-team-start:${nonce}}`;
+    const endMarker = `{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
+    // Build and send message with start/end markers
     const messageWithPreamble = buildMessage(message, name, ctx);
-    const fullMessage = `${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${marker}]`;
+    const fullMessage = `${startMarker}\n${messageWithPreamble}\n\n[IMPORTANT: When your response is complete, print exactly: ${endMarker}]`;
     const msg = name === 'gemini' ? fullMessage.replace(/!/g, '') : fullMessage;
 
     try {
@@ -411,8 +463,8 @@ async function cmdTalkAllWait(
         pane: data.pane,
         requestId,
         nonce,
-        marker,
-        baseline,
+        startMarker,
+        endMarker,
         status: 'pending',
       });
       if (!flags.json) {
@@ -424,8 +476,8 @@ async function cmdTalkAllWait(
         pane: data.pane,
         requestId,
         nonce,
-        marker,
-        baseline,
+        startMarker,
+        endMarker,
         status: 'error',
         error: `Failed to send to pane ${data.pane}`,
       });
@@ -476,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(
@@ -491,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)
@@ -520,17 +582,39 @@ async function cmdTalkAllWait(
           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;
+        // 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
+        // the message may be word-wrapped across multiple visual lines
+        let responseStart = 0;
+        const instructionEndPattern = '}]';
+        const instructionEndIndex = output.lastIndexOf(instructionEndPattern, endMarkerIndex);
+        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: if no `}]` found, try to find newline after start marker
+          const startMarkerIndex = output.lastIndexOf(state.startMarker);
+          if (startMarkerIndex !== -1) {
+            responseStart = output.indexOf('\n', startMarkerIndex);
+            if (responseStart !== -1) responseStart += 1;
+            else responseStart = startMarkerIndex + state.startMarker.length;
+          }
         }
 
-        state.response = output.slice(startIndex, markerIndex).trim();
+        state.response = output.slice(responseStart, endMarkerIndex).trim();
         state.status = 'completed';
         state.elapsedMs = Date.now() - startedAt;
         clearActiveRequest(paths, state.agent, state.requestId);
@@ -592,10 +676,11 @@ function outputBroadcastResults(
         pane: s.pane,
         requestId: s.requestId,
         nonce: s.nonce,
-        marker: s.marker,
-        baseline: '', // Don't include baseline in output
+        startMarker: s.startMarker,
+        endMarker: s.endMarker,
         status: s.status,
         response: s.response,
+        partialResponse: s.partialResponse,
         error: s.error,
         elapsedMs: s.elapsedMs,
       })),
@@ -617,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();
     }
   }
 }

package/src/config.test.ts

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

package/src/config.ts

@@ -27,7 +27,6 @@ const DEFAULT_CONFIG: GlobalConfig = {
     pollInterval: 1,
     captureLines: 100,
     preambleEvery: 3, // inject preamble every 3 messages
-    hideOrphanTasks: false, // hide tasks without milestone in list
   },
 };
 

package/src/identity.ts

@@ -0,0 +1,89 @@
+// ─────────────────────────────────────────────────────────────
+// Identity resolution - determine current agent from tmux pane
+// ─────────────────────────────────────────────────────────────
+
+import { execSync } from 'child_process';
+import type { PaneEntry } from './types.js';
+
+export interface ActorResolution {
+  actor: string;
+  source: 'pane' | 'env' | 'default';
+  warning?: string;
+}
+
+/**
+ * Get current tmux pane ID (e.g., "1.0").
+ */
+function getCurrentPane(): string | null {
+  if (!process.env.TMUX) {
+    return null;
+  }
+
+  const tmuxPane = process.env.TMUX_PANE;
+  if (!tmuxPane) {
+    return null;
+  }
+
+  try {
+    const result = execSync(
+      `tmux display-message -p -t "${tmuxPane}" '#{window_index}.#{pane_index}'`,
+      { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    );
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find agent name by pane ID.
+ */
+function findAgentByPane(paneRegistry: Record<string, PaneEntry>, paneId: string): string | null {
+  for (const [agentName, entry] of Object.entries(paneRegistry)) {
+    if (entry.pane === paneId) {
+      return agentName;
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve current actor using pane registry as primary source.
+ */
+export function resolveActor(paneRegistry: Record<string, PaneEntry>): ActorResolution {
+  const envActor = process.env.TMT_AGENT_NAME || process.env.TMUX_TEAM_ACTOR;
+  const currentPane = getCurrentPane();
+
+  // Not in tmux - use env var or default to human
+  if (!currentPane) {
+    if (envActor) {
+      return { actor: envActor, source: 'env' };
+    }
+    return { actor: 'human', source: 'default' };
+  }
+
+  // In tmux - look up pane in registry
+  const paneAgent = findAgentByPane(paneRegistry, currentPane);
+
+  if (paneAgent) {
+    if (envActor && envActor !== paneAgent) {
+      return {
+        actor: paneAgent,
+        source: 'pane',
+        warning: `⚠️  Identity mismatch: TMT_AGENT_NAME="${envActor}" but pane ${currentPane} is registered to "${paneAgent}". Using pane identity.`,
+      };
+    }
+    return { actor: paneAgent, source: 'pane' };
+  }
+
+  // Pane not in registry
+  if (envActor) {
+    return {
+      actor: envActor,
+      source: 'env',
+      warning: `⚠️  Unregistered pane: pane ${currentPane} is not in registry. Using TMT_AGENT_NAME="${envActor}".`,
+    };
+  }
+
+  return { actor: 'human', source: 'default' };
+}

package/src/types.ts

@@ -19,7 +19,6 @@ export interface ConfigDefaults {
   pollInterval: number; // seconds
   captureLines: number;
   preambleEvery: number; // inject preamble every N messages (default: 3)
-  hideOrphanTasks: boolean; // hide tasks without milestone in list (default: false)
 }
 
 export interface GlobalConfig {
@@ -86,7 +85,8 @@ export interface Tmux {
 export interface WaitResult {
   requestId: string;
   nonce: string;
-  marker: string;
+  startMarker: string;
+  endMarker: string;
   response: string;
 }
 

package/src/version.ts

@@ -14,7 +14,7 @@ function getVersion(): string {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     return pkg.version;
   } catch {
-    return '2.0.0';
+    return '3.0.0';
   }
 }