tmux-team 3.1.0 → 3.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-team",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "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);
 

package/src/config.test.ts

@@ -135,6 +135,51 @@ describe('resolvePaths', () => {
     expect(paths.globalConfig).toBe('/custom/path/config.json');
     expect(paths.stateFile).toBe('/custom/path/state.json');
   });
+
+  it('searches up parent directories to find tmux-team.json', () => {
+    // Simulating: cwd is /projects/myapp/src/components
+    // tmux-team.json exists at /projects/myapp/tmux-team.json
+    const nestedCwd = '/projects/myapp/src/components';
+    const rootConfig = '/projects/myapp/tmux-team.json';
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      return p === rootConfig;
+    });
+
+    const paths = resolvePaths(nestedCwd);
+
+    // Should find the config in parent directory, not assume it's in cwd
+    expect(paths.localConfig).toBe(rootConfig);
+  });
+
+  it('nearest tmux-team.json wins when multiple exist', () => {
+    // Simulating: cwd is /projects/myapp/packages/frontend
+    // tmux-team.json exists at both:
+    //   /projects/myapp/tmux-team.json (monorepo root)
+    //   /projects/myapp/packages/frontend/tmux-team.json (package-specific)
+    const nestedCwd = '/projects/myapp/packages/frontend';
+    const packageConfig = '/projects/myapp/packages/frontend/tmux-team.json';
+    const monorepoConfig = '/projects/myapp/tmux-team.json';
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      return p === packageConfig || p === monorepoConfig;
+    });
+
+    const paths = resolvePaths(nestedCwd);
+
+    // Nearest config should win (package-specific, not monorepo root)
+    expect(paths.localConfig).toBe(packageConfig);
+  });
+
+  it('falls back to cwd when no tmux-team.json found in parents', () => {
+    // No tmux-team.json exists anywhere
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const paths = resolvePaths(mockCwd);
+
+    // Should fall back to cwd/tmux-team.json (default behavior for init)
+    expect(paths.localConfig).toBe(path.join(mockCwd, 'tmux-team.json'));
+  });
 });
 
 describe('loadConfig', () => {

package/src/config.ts

@@ -80,12 +80,37 @@ export function resolveGlobalDir(): string {
   return xdgPath;
 }
 
+/**
+ * Search up parent directories for a file (like how git finds .git/).
+ * Returns the path to the file if found, or null if not found.
+ */
+function findUpward(filename: string, startDir: string): string | null {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, filename);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      // Reached filesystem root
+      return null;
+    }
+    dir = parent;
+  }
+}
+
 export function resolvePaths(cwd: string = process.cwd()): Paths {
   const globalDir = resolveGlobalDir();
+
+  // Search up for local config (like .git discovery)
+  const localConfigPath =
+    findUpward(LOCAL_CONFIG_FILENAME, cwd) ?? path.join(cwd, LOCAL_CONFIG_FILENAME);
+
   return {
     globalDir,
     globalConfig: path.join(globalDir, CONFIG_FILENAME),
-    localConfig: path.join(cwd, LOCAL_CONFIG_FILENAME),
+    localConfig: localConfigPath,
     stateFile: path.join(globalDir, STATE_FILENAME),
   };
 }