orchestrix-yuri 2.6.0 → 2.7.0

package/lib/gateway/engine/claude-tmux.js

@@ -347,10 +347,9 @@ async function createSession(engineConfig) {
   // Ensure CLAUDE.md has channel mode instructions (survives compact)
   ensureClaudeMd(projectRoot);
 
-  // Only kill existing session if it exists — don't kill on retry
-  // so the user can `tmux attach -t yuri-gateway` to debug
+  // Kill existing broken session (ensureSession already checked if it was healthy)
   if (hasSession(sessionName)) {
-    log.tmux(`Killing existing session "${sessionName}"`);
+    log.tmux(`Replacing unhealthy session "${sessionName}"`);
     tmuxSafe(`kill-session -t ${sessionName}`);
   }
 
@@ -446,7 +445,7 @@ function injectMessage(name, text) {
  * We also track whether content has changed since injection (via marker)
  * to avoid returning before Claude has even started responding.
  */
-async function captureResponse(name, marker, engineConfig) {
+async function captureResponse(name, engineConfig) {
   const timeout = engineConfig.timeout || 300000;
   const pollInterval = engineConfig.poll_interval || 2000;
   const stableThreshold = engineConfig.stable_count || 3;
@@ -467,7 +466,7 @@ async function captureResponse(name, marker, engineConfig) {
       if (Date.now() > deadline) {
         log.warn('Response capture timed out');
         const raw = capturePaneRaw(name, 500);
-        return resolve(extractResponse(raw, marker));
+        return resolve(extractResponse(raw, baselineRaw));
       }
 
       // Session died
@@ -484,13 +483,11 @@ async function captureResponse(name, marker, engineConfig) {
       }
 
       // P1: Completion message — most reliable done signal
-      // Only check after content has changed (Claude has started responding)
       if (contentChanged && hasCompletionMessage(paneTail(name, 15))) {
-        return resolve(extractResponse(raw, marker));
+        return resolve(extractResponse(raw, baselineRaw));
       }
 
       // P2: Content stability — pane unchanged for N polls
-      // Only trigger after content has changed from baseline
       if (hash === lastHash) {
         stableCount++;
       } else {
@@ -500,7 +497,7 @@ async function captureResponse(name, marker, engineConfig) {
 
       if (contentChanged && stableCount >= stableThreshold) {
         log.tmux('Response detected via content stability');
-        return resolve(extractResponse(raw, marker));
+        return resolve(extractResponse(raw, baselineRaw));
       }
 
       setTimeout(poll, pollInterval);
@@ -512,49 +509,60 @@ async function captureResponse(name, marker, engineConfig) {
 }
 
 /**
- * Extract the assistant's response from captured pane output.
- * Finds the marker, takes everything after it, strips chrome.
+ * Extract the assistant's response by diffing current pane against baseline.
+ *
+ * Strategy: the baseline was captured right after message injection (before
+ * Claude started responding). The current capture has Claude's response + TUI
+ * chrome. We diff the two to find only the new content.
+ *
+ * @param {string} currentRaw - Current pane capture
+ * @param {string} baselineRaw - Pane capture from right after injection
+ * @returns {{reply: string, raw: string}}
  */
-function extractResponse(raw, marker) {
-  const lines = raw.split('\n');
-  let markerIdx = -1;
-
-  // Find the last occurrence of the marker (in case of scrollback)
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i].includes(marker)) {
-      markerIdx = i;
-      break;
-    }
-  }
+function extractResponse(currentRaw, baselineRaw) {
+  const currentLines = currentRaw.split('\n');
+  const baselineLines = new Set(baselineRaw.split('\n'));
 
-  let responseText;
-  if (markerIdx >= 0) {
-    log.tmux(`Marker found at line ${markerIdx}/${lines.length}`);
-    const afterMarker = lines.slice(markerIdx + 1).join('\n');
-    responseText = stripChrome(afterMarker);
-  } else {
-    log.warn(`Marker not found in pane output, using last 50 lines as fallback`);
-    const tail = lines.slice(-50).join('\n');
-    responseText = stripChrome(tail);
-  }
+  // Find lines that are new (not in baseline)
+  const newLines = currentLines.filter((line) => !baselineLines.has(line));
+  let responseText = stripChrome(newLines.join('\n'));
 
-  // Trim trailing idle indicators and empty lines
+  // Remove trailing indicators and collapse blank lines
   responseText = responseText
     .replace(/[○●◐◑]\s*$/g, '')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
 
-  return { reply: responseText || '(no response captured)', raw };
+  if (!responseText) {
+    log.warn('No new content found after diffing pane output');
+    // Fallback: strip the whole current output
+    responseText = stripChrome(currentLines.slice(-30).join('\n')).trim();
+  }
+
+  return { reply: responseText || '(no response captured)', raw: currentRaw };
 }
 
 // ── Public API ─────────────────────────────────────────────────────────────────
 
 /**
  * Ensure the tmux session is alive and ready.
- * Lazy-initializes on first call. Restarts if session died.
+ * - If session already exists with Claude Code running → reuse it
+ * - If session doesn't exist → create fresh
+ * - If session exists but Claude Code crashed → recreate
  */
 async function ensureSession(engineConfig) {
-  if (_sessionName && hasSession(_sessionName) && _sessionReady) {
+  const sessionName = engineConfig.tmux_session || DEFAULT_SESSION;
+
+  // Fast path: session alive and marked ready in this process
+  if (_sessionName === sessionName && hasSession(sessionName) && _sessionReady) {
+    return;
+  }
+
+  // Check if session exists from a previous gateway run
+  if (hasSession(sessionName) && isStarted(sessionName)) {
+    log.tmux(`Reusing existing session "${sessionName}" (Claude Code is running)`);
+    _sessionName = sessionName;
+    _sessionReady = true;
     return;
   }
 
@@ -573,12 +581,10 @@ async function ensureSession(engineConfig) {
         log.warn(`Session init attempt ${attempt}/${maxRetries} failed: ${err.message}`);
         if (attempt === maxRetries) {
           log.error('All init attempts failed. Check Claude Code installation and tmux.');
-          log.info(`Debug: tmux attach -t ${engineConfig.tmux_session || DEFAULT_SESSION}`);
+          log.info(`Debug: tmux attach -t ${sessionName}`);
           throw err;
         }
-        // Kill session before retry so createSession starts fresh
-        const sn = engineConfig.tmux_session || DEFAULT_SESSION;
-        if (hasSession(sn)) tmuxSafe(`kill-session -t ${sn}`);
+        if (hasSession(sessionName)) tmuxSafe(`kill-session -t ${sessionName}`);
         await new Promise((r) => setTimeout(r, 3000));
       }
     }
@@ -617,13 +623,9 @@ async function callClaude(opts) {
           await proactiveCompact(_sessionName);
         }
 
-        // Generate a unique marker for boundary detection
-        const marker = `YURI-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const markedPrompt = `[${marker}] ${prompt}`;
-
-        // Inject and capture
-        injectMessage(_sessionName, markedPrompt);
-        const result = await captureResponse(_sessionName, marker, config);
+        // Inject user message (no marker — extraction uses completion message position)
+        injectMessage(_sessionName, prompt);
+        const result = await captureResponse(_sessionName, config);
 
         _messageCount++;
         resolve(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrix-yuri",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Yuri — Meta-Orchestrator for Orchestrix. Drive your entire project lifecycle with natural language.",
   "main": "lib/installer.js",
   "bin": {