orchestrix-yuri 2.4.0 → 2.6.0

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

@@ -174,15 +174,39 @@ const PROCESSING_RE = /●/;
  */
 function stripChrome(raw) {
   return raw
-    .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')        // ANSI CSI escapes
-    .replace(/\x1B\].*?\x07/g, '')                 // OSC sequences
-    .replace(/[○●◐◑]/g, '')                        // TUI state indicators
-    .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')                // Braille spinner frames
-    .replace(/[⏵━─█·…→❯]/g, '')                    // UI decoration chars
-    .replace(/^\s*\d+\s*[│|]\s*/gm, '')            // line-number gutter
-    .replace(/^.*[A-Z][a-z]*ed for \d+.*$/gm, '')  // completion stats (all verbs)
-    .replace(/^.*[A-Z][a-z]*ing\.{3}.*$/gm, '')    // spinner verb lines ("Baking...")
-    .replace(/^\s*$/gm, '')                         // blank lines
+    // ANSI escape sequences
+    .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '')
+    .replace(/\x1B\].*?\x07/g, '')
+    // TUI indicators and decorations
+    .replace(/[○●◐◑⏺]/g, '')
+    .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')
+    .replace(/[⏵━─█·…→]/g, '')
+    // Claude Code banner
+    .replace(/^.*▐▛.*$/gm, '')
+    .replace(/^.*▝▜.*$/gm, '')
+    .replace(/^.*▘▘.*$/gm, '')
+    .replace(/^.*Claude Code v[\d.]+.*$/gm, '')
+    .replace(/^.*Opus.*context.*$/gm, '')
+    // Status line elements
+    .replace(/^.*bypass permissions.*$/gm, '')
+    .replace(/^.*shift\+tab to cycle.*$/gm, '')
+    .replace(/^.*◐\s*(min|medium|max|low|high).*$/gm, '')
+    .replace(/^.*\/effort.*$/gm, '')
+    .replace(/^.*Proxy\s*-\s*(On|Off).*$/gm, '')
+    // Shell commands that leaked
+    .replace(/^.*export\s+CLAUDE_AUTOCOMPACT.*$/gm, '')
+    .replace(/^.*dangerously-skip-permissions.*$/gm, '')
+    // Completion stats and spinner verbs
+    .replace(/^.*[A-Z][a-z]*ed for \d+.*$/gm, '')
+    .replace(/^.*[A-Z][a-z]*ing\.{3}.*$/gm, '')
+    // Prompt cursor and line decorations
+    .replace(/^❯\s*$/gm, '')
+    .replace(/^─+$/gm, '')
+    // Line-number gutter
+    .replace(/^\s*\d+\s*[│|]\s*/gm, '')
+    // Collapse blank lines
+    .replace(/^\s*$/gm, '')
+    .replace(/\n{3,}/g, '\n\n')
     .trim();
 }
 
@@ -204,39 +228,31 @@ function paneTail(name, n) {
 }
 
 /**
- * Detect Claude Code's current state from pane output.
+ * Check if Claude Code has started up and is ready for input.
+ * Used ONLY during session initialization — looks for the ❯ input prompt
+ * which appears once Claude Code has fully loaded.
  *
- * @returns {'idle'|'processing'|'complete'|'unknown'}
+ * DO NOT use this for response completion detection — ❯ is always visible.
  */
-function detectState(name) {
+function isStarted(name) {
   const tail = paneTail(name, 15);
+  return IDLE_RE.test(tail);
+}
 
-  // Priority 1: Completion message — most reliable signal
-  // e.g. "Baked for 31s", "Worked for 2m 45s"
-  if (COMPLETION_RE.test(tail)) {
-    return 'complete';
-  }
-
-  // Priority 2: Idle indicator — waiting for input
-  if (IDLE_RE.test(tail)) {
-    return 'idle';
-  }
-
-  // Priority 3: Processing indicator — still working
-  if (PROCESSING_RE.test(tail) || BRAILLE_SPINNER.test(tail)) {
-    return 'processing';
-  }
-
-  return 'unknown';
+/**
+ * Check if a completion message is present in the pane output.
+ * e.g. "Baked for 31s", "Worked for 2m 45s"
+ * This is the most reliable signal that Claude has finished responding.
+ */
+function hasCompletionMessage(text) {
+  return COMPLETION_RE.test(text);
 }
 
 /**
- * Detect if Claude Code is idle (ready for input).
- * Checks for ○ idle indicator or completion message.
+ * Check if Claude Code is actively processing (● spinner visible).
  */
-function isIdle(name) {
-  const state = detectState(name);
-  return state === 'idle' || state === 'complete';
+function isProcessing(text) {
+  return PROCESSING_RE.test(text) || BRAILLE_SPINNER.test(text);
 }
 
 // ── Context Management ─────────────────────────────────────────────────────────
@@ -304,7 +320,7 @@ async function proactiveCompact(name) {
   log.tmux('Proactive /compact triggered');
   injectMessage(name, '/compact focus on the most recent user conversation and any pending operations');
 
-  const ok = await waitForIdle(name, 120000); // compact can take up to 2min
+  const ok = await waitForReady(name, 120000); // compact can take up to 2min
   if (ok) {
     _messageCount = 0;
     log.tmux('Proactive /compact completed');
@@ -343,46 +359,45 @@ async function createSession(engineConfig) {
   tmux(`set-option -t ${sessionName} history-limit ${HISTORY_LIMIT}`);
   log.tmux(`Session "${sessionName}" created, launching Claude Code...`);
 
-  // Set auto-compact threshold to 80% (default is 95%)
+  // Set env var and launch Claude Code in a single command to keep pane clean.
+  // Using && chains avoids separate shell prompt lines polluting capture output.
   const compactPct = engineConfig.autocompact_pct || 80;
-  tmux(`send-keys -t ${sessionName}:0 'export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=${compactPct}' Enter`);
-
-  // Launch Claude Code in interactive mode
-  tmux(`send-keys -t ${sessionName}:0 '"${binary}" --dangerously-skip-permissions' Enter`);
+  tmux(`send-keys -t ${sessionName}:0 'export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=${compactPct} && "${binary}" --dangerously-skip-permissions' Enter`);
 
-  // Wait for Claude Code to initialize (detect idle indicator ○)
-  // Default 60s — Claude Code needs time to load CLAUDE.md, connect MCP servers, etc.
+  // Wait for Claude Code to initialize (detect ❯ prompt)
   const startupTimeout = engineConfig.startup_timeout || 60000;
-  log.tmux(`Waiting for Claude Code to become idle (timeout: ${startupTimeout / 1000}s)...`);
-  const started = await waitForIdle(sessionName, startupTimeout);
+  log.tmux(`Waiting for Claude Code to start (timeout: ${startupTimeout / 1000}s)...`);
+  const started = await waitForReady(sessionName, startupTimeout);
   if (!started) {
-    // Don't kill session on failure — let user debug with tmux attach
     const tail = paneTail(sessionName, 10);
-    log.error(`Claude Code did not become idle within ${startupTimeout / 1000}s`);
+    log.error(`Claude Code did not start within ${startupTimeout / 1000}s`);
     log.error(`Last pane output:\n${tail}`);
     log.info(`Debug: tmux attach -t ${sessionName}`);
-    throw new Error(`Claude Code did not become idle within ${startupTimeout / 1000}s`);
+    throw new Error(`Claude Code did not start within ${startupTimeout / 1000}s`);
   }
 
-  // Send L1 context as the initial system message.
-  // Channel Mode Instructions are already in CLAUDE.md (survives compact),
-  // so we only inject L1 global memory here to prime the session.
-  const l1 = loadL1Context();
-  if (l1) {
-    log.tmux('Injecting L1 context...');
-    await injectMessage(sessionName, l1);
-    await waitForIdle(sessionName, 120000); // allow up to 2min for L1 processing
-  }
+  // Clear tmux scrollback so session setup commands don't pollute response capture.
+  // The pane currently contains: shell commands, banner, status line.
+  // We want captureResponse to only see content from user messages onward.
+  await new Promise((r) => setTimeout(r, 1000)); // let TUI fully render
+  tmuxSafe(`clear-history -t ${sessionName}:0`);
+
+  // NOTE: We do NOT inject L1 context here. Instead, composePrompt() prepends
+  // L1 to the first user message. This avoids: (1) scrollback pollution from
+  // a huge YAML block, (2) waitForReady returning immediately because ❯ is
+  // always visible, (3) race conditions between L1 processing and first message.
 
   _sessionReady = true;
   log.tmux(`Session "${sessionName}" ready (cwd: ${projectRoot})`);
 }
 
 /**
- * Wait for Claude Code to become idle.
- * @returns {Promise<boolean>} true if idle detected, false if timeout
+ * Wait for Claude Code to be ready (❯ prompt visible).
+ * Used for session init and after /compact — NOT for response capture.
+ *
+ * @returns {Promise<boolean>} true if ready detected, false if timeout
  */
-function waitForIdle(name, timeoutMs) {
+function waitForReady(name, timeoutMs) {
   const pollInterval = 2000;
   return new Promise((resolve) => {
     const deadline = Date.now() + timeoutMs;
@@ -394,7 +409,7 @@ function waitForIdle(name, timeoutMs) {
         return resolve(false);
       }
 
-      if (isIdle(name)) {
+      if (isStarted(name)) {
         return resolve(true);
       }
       setTimeout(poll, pollInterval);
@@ -422,10 +437,14 @@ function injectMessage(name, text) {
 /**
  * Capture the response after injecting a message.
  *
- * Detection priority:
+ * Detection strategy (❯ prompt is always visible, so we CANNOT use idle detection):
  *   P1: Completion message — "[Verb]ed for [N]s/m" (e.g. "Baked for 31s")
- *   P2: Idle indicator — ○ appears in pane tail
- *   P3: Content stability — 3 consecutive polls with identical MD5 hash
+ *       Most reliable signal. Appears exactly once when Claude finishes.
+ *   P2: Content stability — pane output unchanged for N consecutive polls.
+ *       Fallback for edge cases where completion message is missed.
+ *
+ * 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) {
   const timeout = engineConfig.timeout || 300000;
@@ -435,7 +454,12 @@ async function captureResponse(name, marker, engineConfig) {
   const deadline = Date.now() + timeout;
   let lastHash = '';
   let stableCount = 0;
-  let sawProcessing = false;
+  let contentChanged = false;
+
+  // Capture baseline right after injection
+  const baselineRaw = capturePaneRaw(name, 500);
+  const baselineHash = crypto.createHash('md5').update(baselineRaw).digest('hex');
+  lastHash = baselineHash;
 
   return new Promise((resolve) => {
     const poll = () => {
@@ -451,31 +475,22 @@ async function captureResponse(name, marker, engineConfig) {
         return resolve({ reply: '❌ Claude Code session terminated unexpectedly.', raw: '' });
       }
 
-      const state = detectState(name);
       const raw = capturePaneRaw(name, 500);
       const hash = crypto.createHash('md5').update(raw).digest('hex');
 
-      // Track that Claude has started processing (● appeared)
-      // This prevents premature completion detection if ○ is still visible
-      // from the previous idle state before Claude begins processing.
-      if (state === 'processing') {
-        sawProcessing = true;
-        stableCount = 0;
-        lastHash = hash;
-        return setTimeout(poll, pollInterval);
+      // Track if content has changed since injection
+      if (hash !== baselineHash) {
+        contentChanged = true;
       }
 
       // P1: Completion message — most reliable done signal
-      if (state === 'complete' && sawProcessing) {
+      // Only check after content has changed (Claude has started responding)
+      if (contentChanged && hasCompletionMessage(paneTail(name, 15))) {
         return resolve(extractResponse(raw, marker));
       }
 
-      // P2: Idle indicator — done if we saw processing start
-      if (state === 'idle' && sawProcessing) {
-        return resolve(extractResponse(raw, marker));
-      }
-
-      // P4: Content stability fallback
+      // P2: Content stability — pane unchanged for N polls
+      // Only trigger after content has changed from baseline
       if (hash === lastHash) {
         stableCount++;
       } else {
@@ -483,7 +498,7 @@ async function captureResponse(name, marker, engineConfig) {
         lastHash = hash;
       }
 
-      if (stableCount >= stableThreshold && sawProcessing) {
+      if (contentChanged && stableCount >= stableThreshold) {
         log.tmux('Response detected via content stability');
         return resolve(extractResponse(raw, marker));
       }
@@ -492,7 +507,6 @@ async function captureResponse(name, marker, engineConfig) {
     };
 
     // Initial delay: give Claude time to start processing
-    // before first poll (avoids false-positive idle detection)
     setTimeout(poll, Math.max(pollInterval, 3000));
   });
 }
@@ -515,12 +529,12 @@ function extractResponse(raw, marker) {
 
   let responseText;
   if (markerIdx >= 0) {
-    // Skip the marker line and any immediate echo of the user message
+    log.tmux(`Marker found at line ${markerIdx}/${lines.length}`);
     const afterMarker = lines.slice(markerIdx + 1).join('\n');
     responseText = stripChrome(afterMarker);
   } else {
-    // Fallback: take last chunk of output, strip chrome
-    const tail = lines.slice(-100).join('\n');
+    log.warn(`Marker not found in pane output, using last 50 lines as fallback`);
+    const tail = lines.slice(-50).join('\n');
     responseText = stripChrome(tail);
   }
 
@@ -626,14 +640,21 @@ async function callClaude(opts) {
 
 /**
  * Compose prompt for the persistent session.
- * Only sends the raw user message — the session already has L1 context
- * from initialization, and Claude Code maintains its own conversation history.
+ * First message includes L1 context to prime the session.
+ * Subsequent messages send only the raw user text.
  *
  * @param {string} userMessage - The user's message text
  * @param {Array} _chatHistory - Unused (Claude keeps its own context)
  * @returns {string}
  */
 function composePrompt(userMessage, _chatHistory) {
+  // First message: prepend L1 context so Claude knows who it is
+  if (_messageCount === 0) {
+    const l1 = loadL1Context();
+    if (l1) {
+      return `${l1}\n\n---\n\nUser message: ${userMessage}`;
+    }
+  }
   return userMessage;
 }
 

package/package.json

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