tmux-team 2.2.0 → 3.0.0-alpha.2

package/src/commands/talk.test.ts

@@ -64,7 +64,6 @@ function createDefaultConfig(): ResolvedConfig {
       pollInterval: 0.1, // Fast polling for tests
       captureLines: 100,
       preambleEvery: 3,
-      hideOrphanTasks: false,
     },
     agents: {},
     paneRegistry: {
@@ -222,7 +221,6 @@ describe('buildMessage (via cmdTalk)', () => {
         pollInterval: 0.1,
         captureLines: 100,
         preambleEvery: 3,
-        hideOrphanTasks: false,
       },
     };
 
@@ -259,7 +257,6 @@ describe('buildMessage (via cmdTalk)', () => {
         pollInterval: 0.1,
         captureLines: 100,
         preambleEvery: 1,
-        hideOrphanTasks: false,
       },
     };
 
@@ -283,7 +280,6 @@ describe('buildMessage (via cmdTalk)', () => {
         pollInterval: 0.1,
         captureLines: 100,
         preambleEvery: 0,
-        hideOrphanTasks: false,
       },
     };
 
@@ -447,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
@@ -454,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({
@@ -470,7 +472,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -497,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';
     };
@@ -513,7 +514,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -544,7 +544,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -563,23 +562,24 @@ describe('cmdTalk - --wait mode', () => {
     expect(output.error).toContain('Timed out');
   });
 
-  it('isolates response from baseline using scrollback', async () => {
+  it('isolates response using start/end markers in scrollback', async () => {
     const tmux = createMockTmux();
     const ui = createMockUI();
 
-    let captureCount = 0;
-    const baseline = 'Previous conversation\nOld content here';
+    const oldContent = 'Previous conversation\nOld content here';
 
     tmux.capture = () => {
-      captureCount++;
-      if (captureCount === 1) return baseline;
-      // Second capture includes baseline + new content + 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 match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (match) {
-        return `${baseline}\n\nNew response content\n\n{tmux-team-end:${match[1]}}`;
+      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]);
+        // 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 baseline;
+      return oldContent;
     };
 
     const ctx = createContext({
@@ -593,7 +593,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -602,8 +601,11 @@ describe('cmdTalk - --wait mode', () => {
 
     const output = ui.jsonOutput[0] as Record<string, unknown>;
     expect(output.status).toBe('completed');
-    // Response should NOT include baseline content
-    expect(output.response).toBe('New response content');
+    // Response should NOT include old content before start marker
+    expect(output.response).not.toContain('Previous conversation');
+    expect(output.response).not.toContain('Old content here');
+    // Response should contain the actual response content
+    expect(output.response).toContain('New response content');
   });
 
   it('clears active request on completion', async () => {
@@ -615,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);
@@ -629,7 +631,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -658,7 +659,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -680,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...';
     };
@@ -713,7 +713,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.05,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -730,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...';
     };
@@ -760,7 +759,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -798,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 '';
     };
@@ -818,7 +816,6 @@ describe('cmdTalk - --wait mode', () => {
           pollInterval: 0.02,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
         paneRegistry: {
           codex: { pane: '10.1' },
@@ -853,25 +850,33 @@ describe('cmdTalk - nonce collision handling', () => {
     const ui = createMockUI();
 
     let captureCount = 0;
-    const oldMarker = '{tmux-team-end:0000}'; // Old marker from previous request
+    const oldStartMarker = '{tmux-team-start:0000}';
+    const oldEndMarker = '{tmux-team-end:0000}'; // Old marker from previous request
 
     tmux.capture = () => {
       captureCount++;
+      // Scrollback includes OLD markers from a previous request
       if (captureCount === 1) {
-        // Baseline includes an OLD marker
-        return `Old response ${oldMarker}`;
+        return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
       }
-      // New capture still has old marker but not new one yet
+      // New capture still has old markers but new request markers not complete yet
       if (captureCount === 2) {
-        return `Old response ${oldMarker}\nNew question asked`;
+        const sent = tmux.sends[0]?.message || '';
+        const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
+        if (startMatch) {
+          return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}\n\n{tmux-team-start:${startMatch[1]}}\nNew question asked`;
+        }
+        return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
       }
-      // Finally, new marker appears
+      // Finally, new end marker appears - must have TWO occurrences of new end marker
       const sent = tmux.sends[0]?.message || '';
-      const match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      if (match) {
-        return `Old response ${oldMarker}\nNew question asked\nNew response {tmux-team-end:${match[1]}}`;
+      const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (startMatch && endMatch) {
+        // 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 `Old response ${oldMarker}`;
+      return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
     };
 
     const ctx = createContext({
@@ -885,7 +890,6 @@ describe('cmdTalk - nonce collision handling', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -894,8 +898,10 @@ describe('cmdTalk - nonce collision handling', () => {
 
     const output = ui.jsonOutput[0] as Record<string, unknown>;
     expect(output.status).toBe('completed');
-    // Response should be from after the new question, not triggered by old marker
+    // Response should be from after the new start marker, not triggered by old markers
     expect(output.response as string).not.toContain('Old response');
+    expect(output.response as string).not.toContain('Old question');
+    expect(output.response as string).toContain('New response');
   });
 });
 
@@ -916,13 +922,14 @@ describe('cmdTalk - JSON output contract', () => {
     const tmux = createMockTmux();
     const ui = createMockUI();
 
-    let captureCount = 0;
     tmux.capture = () => {
-      captureCount++;
-      if (captureCount === 1) return '';
       const sent = tmux.sends[0]?.message || '';
-      const match = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
-      return match ? `Response {tmux-team-end:${match[1]}}` : '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      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 '';
     };
 
     const ctx = createContext({
@@ -936,7 +943,6 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -949,7 +955,8 @@ describe('cmdTalk - JSON output contract', () => {
     expect(output).toHaveProperty('status', 'completed');
     expect(output).toHaveProperty('requestId');
     expect(output).toHaveProperty('nonce');
-    expect(output).toHaveProperty('marker');
+    expect(output).toHaveProperty('startMarker');
+    expect(output).toHaveProperty('endMarker');
     expect(output).toHaveProperty('response');
   });
 
@@ -969,7 +976,6 @@ describe('cmdTalk - JSON output contract', () => {
           pollInterval: 0.01,
           captureLines: 100,
           preambleEvery: 3,
-          hideOrphanTasks: false,
         },
       },
     });
@@ -987,6 +993,395 @@ describe('cmdTalk - JSON output contract', () => {
     expect(output).toHaveProperty('error');
     expect(output).toHaveProperty('requestId');
     expect(output).toHaveProperty('nonce');
-    expect(output).toHaveProperty('marker');
+    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');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────
+// Start/End Marker Tests - comprehensive coverage for the new marker system
+// ─────────────────────────────────────────────────────────────
+
+describe('cmdTalk - start/end marker extraction', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'talk-test-'));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  // 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 complete response immediately
+    tmux.capture = () => {
+      const sent = tmux.sends[0]?.message || '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      if (endMatch) {
+        return mockResponse(endMatch[1], 'Response');
+      }
+      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 message');
+
+    const sent = tmux.sends[0].message;
+    expect(sent).toMatch(/\{tmux-team-start:[a-f0-9]+\}/);
+    expect(sent).toMatch(/\{tmux-team-end:[a-f0-9]+\}/);
+
+    // Both markers should have same nonce
+    const startMatch = sent.match(/\{tmux-team-start:([a-f0-9]+)\}/);
+    const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+    expect(startMatch?.[1]).toBe(endMatch?.[1]);
+  });
+
+  it('extracts only content between start and end markers', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    tmux.capture = () => {
+      const sent = tmux.sends[0]?.message || '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      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';
+    };
+
+    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('actual response');
+    expect(output.response).not.toContain('Old garbage');
+    expect(output.response).not.toContain('Content after marker');
+  });
+
+  it('handles multiline responses correctly', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    const multilineResponse = `Line 1 of response
+Line 2 of response
+Line 3 with special chars: <>&"'
+Line 4 final`;
+
+    tmux.capture = () => {
+      const sent = tmux.sends[0]?.message || '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      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 '';
+    };
+
+    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.response).toContain('Line 1 of response');
+    expect(output.response).toContain('Line 4 final');
+  });
+
+  it('handles empty response between markers', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    tmux.capture = () => {
+      const sent = tmux.sends[0]?.message || '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      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 '';
+    };
+
+    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');
+    // Response should be the message content (trimmed)
+    expect(typeof output.response).toBe('string');
+  });
+
+  it('correctly handles start marker on same line as content', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    tmux.capture = () => {
+      const sent = tmux.sends[0]?.message || '';
+      const endMatch = sent.match(/\{tmux-team-end:([a-f0-9]+)\}/);
+      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';
+    };
+
+    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.response).not.toContain('Old stuff');
+    expect(output.response).toContain('Actual response content');
+  });
+
+  it('uses lastIndexOf for start marker to handle multiple occurrences', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    let captureCount = 0;
+    tmux.capture = () => {
+      captureCount++;
+      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) {
+        if (captureCount < 3) {
+          // First few captures: old markers in history, new start marker sent but not end yet
+          // (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 (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 '';
+    };
+
+    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');
+    // Should get response from the NEW start marker, not the old one
+    expect(output.response).toContain('New actual response');
+    expect(output.response).not.toContain('Old response');
+  });
+
+  it('handles large scrollback with markers at edges', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    // Simulate 100+ lines of scrollback
+    const lotsOfContent = Array.from({ length: 150 }, (_, i) => `Line ${i}`).join('\n');
+
+    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) {
+        // 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;
+    };
+
+    const ctx = createContext({
+      tmux,
+      ui,
+      paths: createTestPaths(testDir),
+      flags: { wait: true, json: true, timeout: 5 },
+      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 200, 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('actual response');
+    expect(output.response).not.toContain('Line 0');
   });
 });