orchestrix-yuri 3.2.0 → 3.2.1

package/lib/gateway/engine/phase-orchestrator.js

@@ -49,6 +49,62 @@ class PhaseOrchestrator {
 
   isRunning() { return this._phase !== null; }
 
+  /**
+   * Try to recover an in-progress phase from YAML state + tmux session.
+   * Called once on gateway startup. If a phase was running when the gateway
+   * died, reconnect to the existing tmux session and resume polling.
+   */
+  tryRecover(projectRoot) {
+    if (this._phase) return; // already running
+    if (!projectRoot) return;
+
+    // Check phase2 (plan)
+    const phase2Path = path.join(projectRoot, '.yuri', 'state', 'phase2.yaml');
+    if (fs.existsSync(phase2Path)) {
+      const phase2 = yaml.load(fs.readFileSync(phase2Path, 'utf8')) || {};
+      if (phase2.status === 'in_progress' && phase2.tmux && phase2.tmux.session) {
+        if (tmx.hasSession(phase2.tmux.session)) {
+          // Recover: reconnect to existing session, resume polling
+          this._phase = 'plan';
+          this._projectRoot = projectRoot;
+          this._session = phase2.tmux.session;
+
+          // Find current step from YAML
+          if (Array.isArray(phase2.steps)) {
+            const lastComplete = phase2.steps.findLastIndex((s) => s.status === 'complete');
+            this._step = lastComplete >= 0 ? lastComplete + 1 : 0;
+          }
+
+          const pollInterval = this.config.phase_poll_interval || 30000;
+          this._timer = setInterval(() => this._pollPlanAgent(), pollInterval);
+
+          const agent = PLAN_AGENTS[this._step];
+          log.engine(`Recovered plan phase: session=${this._session}, step ${this._step + 1}/${PLAN_AGENTS.length} (${agent ? agent.name : '?'})`);
+          return;
+        }
+      }
+    }
+
+    // Check phase3 (develop)
+    const phase3Path = path.join(projectRoot, '.yuri', 'state', 'phase3.yaml');
+    if (fs.existsSync(phase3Path)) {
+      const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
+      if (phase3.status === 'in_progress' && phase3.tmux && phase3.tmux.session) {
+        if (tmx.hasSession(phase3.tmux.session)) {
+          this._phase = 'develop';
+          this._projectRoot = projectRoot;
+          this._session = phase3.tmux.session;
+
+          const pollInterval = this.config.dev_poll_interval || 300000;
+          this._timer = setInterval(() => this._pollDevSession(), pollInterval);
+
+          log.engine(`Recovered dev phase: session=${this._session}`);
+          return;
+        }
+      }
+    }
+  }
+
   getStatus() {
     if (!this._phase) {
       return { phase: null, message: 'No phase is running.' };
@@ -140,20 +196,29 @@ class PhaseOrchestrator {
     // Update memory
     this._updatePlanMemory('in_progress');
 
-    // Start first (or resumed) agent
-    try {
-      this._startPlanAgent(this._step);
-    } catch (err) {
-      this._phase = null;
-      return `❌ Failed to start agent: ${err.message}`;
+    // Check if the current agent's window already has Claude Code running.
+    // This happens when gateway restarts while an agent is mid-execution.
+    // In that case, just start polling — don't re-send commands.
+    const agent = PLAN_AGENTS[this._step];
+    const windowHasActivity = this._isWindowActive(agent.window);
+
+    if (windowHasActivity) {
+      log.engine(`Agent ${this._step + 1} (${agent.name}) already active in window ${agent.window}, resuming polling`);
+    } else {
+      try {
+        this._startPlanAgent(this._step);
+      } catch (err) {
+        this._phase = null;
+        return `❌ Failed to start agent: ${err.message}`;
+      }
     }
 
     // Start polling
     const pollInterval = this.config.phase_poll_interval || 30000;
     this._timer = setInterval(() => this._pollPlanAgent(), pollInterval);
 
-    const agent = PLAN_AGENTS[this._step];
-    return `🚀 Planning started! Agent ${this._step + 1}/${PLAN_AGENTS.length} (${agent.name}) is running.\n\nI'll notify you as each agent completes. You can ask me anything in the meantime.`;
+    const currentAgent = PLAN_AGENTS[this._step];
+    return `🚀 Planning ${windowHasActivity ? 'resumed' : 'started'}! Agent ${this._step + 1}/${PLAN_AGENTS.length} (${currentAgent.name}) is running.\n\nI'll notify you as each agent completes. You can ask me anything in the meantime.`;
   }
 
   /**
@@ -254,6 +319,17 @@ class PhaseOrchestrator {
     this.onComplete('plan', '🎉 Planning phase complete! All 6 agents finished.\n\nRun *develop to start automated development.');
   }
 
+  /**
+   * Check if a tmux window has an active Claude Code session.
+   * Returns true if ❯ prompt or processing indicators are visible.
+   */
+  _isWindowActive(windowIdx) {
+    if (!this._session || !tmx.hasSession(this._session)) return false;
+    const pane = tmx.capturePane(this._session, windowIdx, 15);
+    // ❯ means Claude Code is running (idle or processing)
+    return /❯/.test(pane);
+  }
+
   _startPlanAgent(stepIdx) {
     const agent = PLAN_AGENTS[stepIdx];
     if (!agent) return;

package/lib/gateway/router.js

@@ -55,6 +55,12 @@ class Router {
       onComplete: (phase, summary) => this._sendProactive(summary),
       onError: (phase, err) => this._sendProactive(`❌ Phase ${phase} error: ${err}`),
     });
+
+    // Auto-recover any in-progress phase from previous gateway run
+    const projectRoot = engine.resolveProjectRoot();
+    if (projectRoot) {
+      this.orchestrator.tryRecover(projectRoot);
+    }
   }
 
   /**
@@ -186,13 +192,13 @@ class Router {
   _handleStatusQuery(msg) {
     const parts = [];
 
-    // Orchestrator status
+    // Orchestrator status (if actively tracking)
     if (this.orchestrator.isRunning()) {
       const status = this.orchestrator.getStatus();
       parts.push(status.message);
     }
 
-    // Read project focus for additional context
+    // Read project state from YAML — works even if orchestrator isn't tracking
     const projectRoot = engine.resolveProjectRoot();
     if (projectRoot) {
       const focusPath = path.join(projectRoot, '.yuri', 'focus.yaml');
@@ -201,6 +207,21 @@ class Router {
           const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
           if (focus.pulse) parts.push(`Pulse: ${focus.pulse}`);
           if (focus.step) parts.push(`Step: ${focus.step}`);
+
+          // If YAML says in_progress but orchestrator isn't tracking, warn
+          if (!this.orchestrator.isRunning() && focus.phase) {
+            const phasePaths = {
+              2: path.join(projectRoot, '.yuri', 'state', 'phase2.yaml'),
+              3: path.join(projectRoot, '.yuri', 'state', 'phase3.yaml'),
+            };
+            const statePath = phasePaths[focus.phase];
+            if (statePath && fs.existsSync(statePath)) {
+              const state = yaml.load(fs.readFileSync(statePath, 'utf8')) || {};
+              if (state.status === 'in_progress') {
+                parts.push(`\n⚠️ Phase ${focus.phase} was in progress but orchestrator lost track (gateway restarted?). Send *plan or *develop to reconnect.`);
+              }
+            }
+          }
         } catch { /* ok */ }
       }
     }

package/package.json

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