orchestrix-yuri 2.3.2 → 2.3.4

package/lib/gateway/config.js

@@ -20,7 +20,7 @@ const DEFAULTS = {
   engine: {
     skill: 'yuri',
     tmux_session: 'yuri-gateway',
-    startup_timeout: 30000,       // ms to wait for Claude Code to initialize
+    startup_timeout: 60000,       // ms to wait for Claude Code to initialize
     poll_interval: 2000,          // ms between capture-pane polls
     stable_count: 3,              // consecutive stable polls before declaring done
     max_retries: 3,               // session restart retries before error

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

@@ -162,7 +162,6 @@ const BRAILLE_SPINNER = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/;
 const COMPLETION_RE = /[A-Z][a-z]*ed for \d+/;
 const IDLE_RE = /○/;
 const PROCESSING_RE = /●/;
-const APPROVAL_RE = /◐/;
 
 /**
  * Strip TUI chrome from captured pane output.
@@ -203,7 +202,11 @@ function paneTail(name, n) {
 /**
  * Detect Claude Code's current state from pane output.
  *
- * @returns {'idle'|'processing'|'approval'|'complete'|'unknown'}
+ * Note: We launch with --dangerously-skip-permissions, so approval prompts (◐)
+ * should never appear. The detection is kept for robustness but no auto-approve
+ * action is taken — sending blind 'y' keystrokes is dangerous.
+ *
+ * @returns {'idle'|'processing'|'complete'|'unknown'}
  */
 function detectState(name) {
   const tail = paneTail(name, 15);
@@ -214,17 +217,12 @@ function detectState(name) {
     return 'complete';
   }
 
-  // Priority 2: Approval prompt — needs immediate response
-  if (APPROVAL_RE.test(tail)) {
-    return 'approval';
-  }
-
-  // Priority 3: Idle indicator — waiting for input
+  // Priority 2: Idle indicator — waiting for input
   if (IDLE_RE.test(tail)) {
     return 'idle';
   }
 
-  // Priority 4: Processing indicator — still working
+  // Priority 3: Processing indicator — still working
   if (PROCESSING_RE.test(tail) || BRAILLE_SPINNER.test(tail)) {
     return 'processing';
   }
@@ -241,20 +239,6 @@ function isIdle(name) {
   return state === 'idle' || state === 'complete';
 }
 
-/**
- * Detect if Claude Code is showing an approval prompt (◐).
- */
-function isApprovalPrompt(name) {
-  return detectState(name) === 'approval';
-}
-
-/**
- * Detect if Claude Code is actively processing (● or spinner).
- */
-function isProcessing(name) {
-  return detectState(name) === 'processing';
-}
-
 // ── Context Management ─────────────────────────────────────────────────────────
 //
 // Claude Code has built-in auto-compact that triggers at ~95% context capacity.
@@ -341,32 +325,43 @@ async function createSession(engineConfig) {
 
   const binary = getClaudeBinary();
   const projectRoot = resolveProjectRoot() || os.homedir();
+  log.tmux(`Binary: ${binary}`);
+  log.tmux(`Project root: ${projectRoot}`);
 
   // Ensure CLAUDE.md has channel mode instructions (survives compact)
   ensureClaudeMd(projectRoot);
 
-  // Kill existing stale session
+  // Only kill existing session if it exists — don't kill on retry
+  // so the user can `tmux attach -t yuri-gateway` to debug
   if (hasSession(sessionName)) {
+    log.tmux(`Killing existing session "${sessionName}"`);
     tmuxSafe(`kill-session -t ${sessionName}`);
   }
 
   // Create session with generous scrollback
   tmux(`new-session -d -s ${sessionName} -n claude -c "${projectRoot}"`);
   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%)
-  // This gives comfortable buffer before context pressure
   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`);
 
-  // Wait for Claude Code to initialize (detect idle indicator)
-  const startupTimeout = engineConfig.startup_timeout || 30000;
+  // Wait for Claude Code to initialize (detect idle indicator ○)
+  // Default 60s — Claude Code needs time to load CLAUDE.md, connect MCP servers, etc.
+  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);
   if (!started) {
-    throw new Error(`Claude Code did not become idle within ${startupTimeout}ms`);
+    // 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(`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`);
   }
 
   // Send L1 context as the initial system message.
@@ -374,6 +369,7 @@ async function createSession(engineConfig) {
   // 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
   }
@@ -398,11 +394,6 @@ function waitForIdle(name, timeoutMs) {
         return resolve(false);
       }
 
-      // Auto-approve any permission prompts
-      if (isApprovalPrompt(name)) {
-        tmuxSafe(`send-keys -t ${name}:0 'y' Enter`);
-      }
-
       if (isIdle(name)) {
         return resolve(true);
       }
@@ -431,11 +422,10 @@ function injectMessage(name, text) {
 /**
  * Capture the response after injecting a message.
  *
- * Detection priority (mirrors monitor-agent.sh):
+ * Detection priority:
  *   P1: Completion message — "[Verb]ed for [N]s/m" (e.g. "Baked for 31s")
  *   P2: Idle indicator — ○ appears in pane tail
- *   P3: Approval prompt — ◐ detected, auto-approve with 'y'
- *   P4: Content stability — 3 consecutive polls with identical MD5 hash
+ *   P3: Content stability — 3 consecutive polls with identical MD5 hash
  */
 async function captureResponse(name, marker, engineConfig) {
   const timeout = engineConfig.timeout || 300000;
@@ -475,16 +465,6 @@ async function captureResponse(name, marker, engineConfig) {
         return setTimeout(poll, pollInterval);
       }
 
-      // P3: Auto-approve permission prompts (◐)
-      if (state === 'approval') {
-        tmuxSafe(`send-keys -t ${name}:0 'y' Enter`);
-        sawProcessing = true; // approval implies processing started
-        stableCount = 0;
-        lastHash = hash;
-        // Brief pause after approval before next poll
-        return setTimeout(poll, 2000);
-      }
-
       // P1: Completion message — most reliable done signal
       if (state === 'complete' && sawProcessing) {
         return resolve(extractResponse(raw, marker));
@@ -577,8 +557,14 @@ async function ensureSession(engineConfig) {
         return;
       } catch (err) {
         log.warn(`Session init attempt ${attempt}/${maxRetries} failed: ${err.message}`);
-        if (attempt === maxRetries) throw err;
-        // Brief pause before retry
+        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}`);
+          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}`);
         await new Promise((r) => setTimeout(r, 3000));
       }
     }

package/package.json

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