tmux-team 2.1.0 → 3.0.0-alpha.1

package/src/commands/talk.test.ts

@@ -63,6 +63,7 @@ function createDefaultConfig(): ResolvedConfig {
       timeout: 60,
       pollInterval: 0.1, // Fast polling for tests
       captureLines: 100,
+      preambleEvery: 3,
     },
     agents: {},
     paneRegistry: {
@@ -85,7 +86,15 @@ function createContext(
   const exitError = new Error('exit called');
   (exitError as Error & { exitCode?: number }).exitCode = 0;
 
-  const config = { ...createDefaultConfig(), ...overrides.config };
+  const baseConfig = createDefaultConfig();
+  const config = {
+    ...baseConfig,
+    ...overrides.config,
+    defaults: {
+      ...baseConfig.defaults,
+      ...overrides.config?.defaults,
+    },
+  };
   const flags: Flags = { json: false, verbose: false, ...overrides.flags };
 
   return {
@@ -199,6 +208,88 @@ describe('buildMessage (via cmdTalk)', () => {
 
     expect(tmux.sends[0].message).toBe('[SYSTEM: Test preamble]\n\nTest message');
   });
+
+  it('injects preamble based on preambleEvery config (every N messages)', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 3,
+      },
+    };
+
+    // Message 1: should include preamble (first message)
+    const tmux1 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux1, paths, config }), 'claude', 'Hello 1');
+    expect(tmux1.sends[0].message).toContain('[SYSTEM: Be brief]');
+
+    // Message 2: should NOT include preamble
+    const tmux2 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux2, paths, config }), 'claude', 'Hello 2');
+    expect(tmux2.sends[0].message).toBe('Hello 2');
+
+    // Message 3: should NOT include preamble
+    const tmux3 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux3, paths, config }), 'claude', 'Hello 3');
+    expect(tmux3.sends[0].message).toBe('Hello 3');
+
+    // Message 4: should include preamble (4 - 1 = 3, divisible by 3)
+    const tmux4 = createMockTmux();
+    await cmdTalk(createContext({ tmux: tmux4, paths, config }), 'claude', 'Hello 4');
+    expect(tmux4.sends[0].message).toContain('[SYSTEM: Be brief]');
+  });
+
+  it('injects preamble every time when preambleEvery is 1', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 1,
+      },
+    };
+
+    // All messages should include preamble
+    for (let i = 0; i < 3; i++) {
+      const tmux = createMockTmux();
+      await cmdTalk(createContext({ tmux, paths, config }), 'claude', `Hello ${i}`);
+      expect(tmux.sends[0].message).toContain('[SYSTEM: Be brief]');
+    }
+  });
+
+  it('never injects preamble when preambleEvery is 0', async () => {
+    const paths = createTestPaths(testDir);
+    fs.mkdirSync(paths.globalDir, { recursive: true });
+
+    const config = {
+      preambleMode: 'always' as const,
+      agents: { claude: { preamble: 'Be brief' } },
+      defaults: {
+        timeout: 60,
+        pollInterval: 0.1,
+        captureLines: 100,
+        preambleEvery: 0,
+      },
+    };
+
+    // No messages should include preamble
+    for (let i = 0; i < 3; i++) {
+      const tmux = createMockTmux();
+      await cmdTalk(createContext({ tmux, paths, config }), 'claude', `Hello ${i}`);
+      expect(tmux.sends[0].message).toBe(`Hello ${i}`);
+    }
+  });
 });
 
 describe('cmdTalk - basic send', () => {
@@ -369,7 +460,14 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths: createTestPaths(testDir),
       flags: { wait: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -404,7 +502,14 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -412,7 +517,7 @@ describe('cmdTalk - --wait mode', () => {
     expect(ui.jsonOutput).toHaveLength(1);
     const output = ui.jsonOutput[0] as Record<string, unknown>;
     expect(output.status).toBe('completed');
-    expect(output.response).toBeDefined();
+    expect(output.response).toEqual(expect.stringContaining('Agent response here'));
   });
 
   it('returns timeout error with correct exit code', async () => {
@@ -427,7 +532,14 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.1 },
-      config: { defaults: { timeout: 0.1, pollInterval: 0.02, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.1,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     try {
@@ -444,23 +556,23 @@ 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, start marker, response, and 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]);
+        return `${oldContent}\n\n{tmux-team-start:${startMatch[1]}}\nMessage content here\n\nNew response content\n\n{tmux-team-end:${endMatch[1]}}`;
       }
-      return baseline;
+      return oldContent;
     };
 
     const ctx = createContext({
@@ -468,15 +580,25 @@ describe('cmdTalk - --wait mode', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
 
     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 () => {
@@ -496,7 +618,14 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths,
       flags: { wait: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -517,7 +646,14 @@ describe('cmdTalk - --wait mode', () => {
       tmux,
       paths,
       flags: { wait: true, timeout: 0.05 },
-      config: { defaults: { timeout: 0.05, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     try {
@@ -565,7 +701,12 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 5 },
       config: {
-        defaults: { timeout: 5, pollInterval: 0.05, captureLines: 100 },
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.05,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -606,7 +747,12 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 0.1, json: true },
       config: {
-        defaults: { timeout: 0.1, pollInterval: 0.02, captureLines: 100 },
+        defaults: {
+          timeout: 0.1,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -658,7 +804,12 @@ describe('cmdTalk - --wait mode', () => {
       paths,
       flags: { wait: true, timeout: 5 },
       config: {
-        defaults: { timeout: 5, pollInterval: 0.02, captureLines: 100 },
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.02,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
         paneRegistry: {
           codex: { pane: '10.1' },
           gemini: { pane: '10.2' },
@@ -692,25 +843,32 @@ 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
       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) {
+        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]}}`;
       }
-      return `Old response ${oldMarker}`;
+      return `${oldStartMarker}\nOld question\nOld response\n${oldEndMarker}`;
     };
 
     const ctx = createContext({
@@ -718,15 +876,24 @@ describe('cmdTalk - nonce collision handling', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
 
     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');
   });
 });
 
@@ -747,13 +914,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 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]}}`;
+      }
+      return '';
     };
 
     const ctx = createContext({
@@ -761,7 +929,14 @@ describe('cmdTalk - JSON output contract', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 5 },
-      config: { defaults: { timeout: 5, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 5,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     await cmdTalk(ctx, 'claude', 'Hello');
@@ -772,7 +947,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');
   });
 
@@ -786,7 +962,14 @@ describe('cmdTalk - JSON output contract', () => {
       ui,
       paths: createTestPaths(testDir),
       flags: { wait: true, json: true, timeout: 0.05 },
-      config: { defaults: { timeout: 0.05, pollInterval: 0.01, captureLines: 100 } },
+      config: {
+        defaults: {
+          timeout: 0.05,
+          pollInterval: 0.01,
+          captureLines: 100,
+          preambleEvery: 3,
+        },
+      },
     });
 
     try {
@@ -802,6 +985,258 @@ 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');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────
+// 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 });
+    }
+  });
+
+  it('includes both start and end markers in sent message', async () => {
+    const tmux = createMockTmux();
+    const ui = createMockUI();
+
+    // Return markers immediately to complete
+    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]}`;
+      }
+      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 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`;
+      }
+      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 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]}}`;
+      }
+      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 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]}}`;
+      }
+      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 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]}}`;
+      }
+      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
+          return `{tmux-team-start:old1}\nOld message\nOld response\n{tmux-team-end:old1}\n\n{tmux-team-start:${startMatch[1]}}\nNew message pending`;
+        }
+        // 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]}}`;
+      }
+      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) {
+        return `${lotsOfContent}\n{tmux-team-start:${startMatch[1]}}\nMessage\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');
   });
 });