tmux-team 3.1.0 → 3.2.0

package/package.json

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

package/src/commands/talk.test.ts

@@ -1224,12 +1224,6 @@ describe('cmdTalk - end marker detection', () => {
     return `Message\n\nWhen you finish responding, print this exact line:\n${endMarker}\n${response}\n${endMarker}`;
   }
 
-  // Helper: generate mock capture where instruction scrolled off, detected via UI
-  function mockResponseWithUI(nonce: string, response: string): string {
-    const endMarker = `---RESPONSE-END-${nonce}---`;
-    return `${response}\n${endMarker}\n\n╭───────────────────╮\n│ > Type message    │\n╰───────────────────╯`;
-  }
-
   it('includes end marker in sent message', async () => {
     const tmux = createMockTmux();
     const ui = createMockUI();
@@ -1289,35 +1283,6 @@ describe('cmdTalk - end marker detection', () => {
     expect(output.response).toContain('actual response');
   });
 
-  it('detects completion via UI elements when instruction scrolled off', async () => {
-    const tmux = createMockTmux();
-    const ui = createMockUI();
-
-    tmux.capture = () => {
-      const sent = tmux.sends[0]?.message || '';
-      const endMatch = sent.match(END_MARKER_REGEX);
-      if (endMatch) {
-        // Only ONE end marker visible (agent's), followed by CLI UI
-        return mockResponseWithUI(endMatch[1], 'Response from agent');
-      }
-      return '';
-    };
-
-    const ctx = createContext({
-      tmux,
-      ui,
-      paths: createTestPaths(testDir),
-      flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100, preambleEvery: 3 } },
-    });
-
-    await cmdTalk(ctx, 'claude', 'Test');
-
-    const output = ui.jsonOutput[0] as Record<string, unknown>;
-    expect(output.status).toBe('completed');
-    expect(output.response).toContain('Response from agent');
-  });
-
   it('handles multiline responses correctly', async () => {
     const tmux = createMockTmux();
     const ui = createMockUI();

package/src/commands/talk.ts

@@ -278,9 +278,10 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
   let lastNonTtyLogAt = 0;
   const isTTY = process.stdout.isTTY && !flags.json;
 
-  // Idle detection for Gemini (doesn't print end markers)
-  const GEMINI_IDLE_THRESHOLD_MS = 5000; // 5 seconds of no output change = complete
-  let lastOutputHash = '';
+  // Debounce detection: wait for output to stabilize
+  const MIN_WAIT_MS = 3000; // Wait at least 3 seconds before detecting completion
+  const IDLE_THRESHOLD_MS = 3000; // Content unchanged for 3 seconds = complete
+  let lastOutput = '';
   let lastOutputChangeAt = Date.now();
 
   const onSigint = (): void => {
@@ -402,40 +403,40 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
         console.error(`[DEBUG ${elapsedSec}s] Output tail:\n${output.slice(-300)}`);
       }
 
-      // Find end marker - agent prints it when done
-      // For long responses, our instruction may scroll off, so we check:
-      // 1. Two occurrences (instruction + agent), OR
-      // 2. One occurrence that's followed by only UI elements (agent printed it)
-      const firstEndMarkerIndex = output.indexOf(endMarker);
-      const lastEndMarkerIndex = output.lastIndexOf(endMarker);
-
-      if (firstEndMarkerIndex === -1) {
-        // No marker at all - still waiting
-        continue;
+      // Track output changes for debounce detection
+      if (output !== lastOutput) {
+        lastOutput = output;
+        lastOutputChangeAt = Date.now();
       }
 
-      // Check if marker is from agent (not just in our instruction)
-      // Either: two markers (instruction scrolled, agent printed), or
-      // one marker followed by CLI UI elements (instruction scrolled off)
-      const afterMarker = output.slice(lastEndMarkerIndex + endMarker.length);
-      const followedByUI = afterMarker.includes('╭') || afterMarker.includes('context left');
-      const twoMarkers = firstEndMarkerIndex !== lastEndMarkerIndex;
+      const elapsedMs = Date.now() - startedAt;
+      const idleMs = Date.now() - lastOutputChangeAt;
+
+      // Find end marker
+      const hasEndMarker = output.includes(endMarker);
 
-      if (!twoMarkers && !followedByUI) {
-        // Marker is still in our instruction, agent hasn't responded yet
+      // Completion conditions:
+      // 1. Must wait at least MIN_WAIT_MS
+      // 2. Must have end marker in output
+      // 3. Output must be stable for IDLE_THRESHOLD_MS (debounce)
+      if (elapsedMs < MIN_WAIT_MS || !hasEndMarker || idleMs < IDLE_THRESHOLD_MS) {
+        if (flags.debug && hasEndMarker) {
+          console.error(
+            `[DEBUG] Marker found, waiting for debounce (elapsed: ${elapsedMs}ms, idle: ${idleMs}ms)`
+          );
+        }
         continue;
       }
 
-      if (flags.debug)
-        console.error(
-          `[DEBUG] Agent completed (twoMarkers: ${twoMarkers}, followedByUI: ${followedByUI})`
-        );
+      if (flags.debug) {
+        console.error(`[DEBUG] Agent completed (elapsed: ${elapsedMs}ms, idle: ${idleMs}ms)`);
+      }
 
-      // Extract response: get N lines before the agent's end marker
+      // Extract response: get N lines before the end marker
       const responseLines = flags.lines ?? 100;
       const lines = output.split('\n');
 
-      // Find the line with the agent's end marker (last occurrence)
+      // Find the line with the end marker (last occurrence = agent's marker)
       let endMarkerLineIndex = -1;
       for (let i = lines.length - 1; i >= 0; i--) {
         if (lines[i].includes(endMarker)) {
@@ -446,13 +447,9 @@ export async function cmdTalk(ctx: Context, target: string, message: string): Pr
 
       if (endMarkerLineIndex === -1) continue;
 
-      // Determine where response starts
-      let startLine = 0;
-      if (firstEndMarkerIndex !== lastEndMarkerIndex) {
-        // Two markers - find line after first marker (instruction)
-        const firstMarkerLineIndex = lines.findIndex((line) => line.includes(endMarker));
-        startLine = firstMarkerLineIndex + 1;
-      }
+      // Find where response starts (after instruction's end marker, if visible)
+      const firstMarkerLineIndex = lines.findIndex((line) => line.includes(endMarker));
+      let startLine = firstMarkerLineIndex + 1;
       // Limit to N lines before end marker
       startLine = Math.max(startLine, endMarkerLineIndex - responseLines);