orchestrix-yuri 3.2.0 → 3.3.0

package/lib/gateway/channels/telegram.js

@@ -33,6 +33,9 @@ class TelegramAdapter {
         chatId: String(ctx.chat.id),
         text: ctx.message.text,
         userName: ctx.from.first_name || ctx.from.username || 'Unknown',
+        replyToMessageId: ctx.message.reply_to_message
+          ? String(ctx.message.reply_to_message.message_id)
+          : null,
       };
 
       try {

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

@@ -45,9 +45,72 @@ class PhaseOrchestrator {
     this._timer = null;
     this._lastHash = '';
     this._stableCount = 0;
+
+    // Agent question bridging
+    this._waitingForInput = false;     // true when agent asked a question
+    this._waitingMessageId = null;     // Telegram message_id of the question notification
+    this._onQuestionAsked = opts.onQuestionAsked || (() => Promise.resolve(null));
+    // onQuestionAsked(text) → sends to Telegram, returns { messageId }
   }
 
   isRunning() { return this._phase !== null; }
+  isWaitingForInput() { return this._waitingForInput; }
+
+  /**
+   * 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) {
@@ -140,20 +203,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.`;
   }
 
   /**
@@ -174,6 +246,9 @@ class PhaseOrchestrator {
       return;
     }
 
+    // Skip polling while waiting for user input
+    if (this._waitingForInput) return;
+
     // Check completion
     const result = tmx.checkCompletion(this._session, agent.window, this._lastHash);
 
@@ -186,8 +261,21 @@ class PhaseOrchestrator {
       this._stableCount++;
       this._lastHash = result.hash;
       if (this._stableCount >= 3) {
-        // Content stable for 3 polls — agent likely done
-        this._onAgentComplete(agent);
+        // Content stable for 3 polls — distinguish "done" vs "waiting for input"
+        const pane = tmx.capturePane(this._session, agent.window, 30);
+        const tail = pane.split('\n').slice(-15).join('\n');
+
+        if (/[A-Z][a-z]*ed for \d+/.test(tail)) {
+          // Completion message present — truly done
+          this._onAgentComplete(agent);
+        } else if (this._looksLikeQuestion(tail)) {
+          // Agent is asking a question — bridge to user
+          this._onAgentWaitingInput(agent, tail);
+        } else {
+          // Ambiguous — treat as done (agent may have finished without completion message)
+          log.engine(`Agent ${agent.name} stable without completion message, treating as done`);
+          this._onAgentComplete(agent);
+        }
         return;
       }
     } else {
@@ -196,6 +284,82 @@ class PhaseOrchestrator {
     }
   }
 
+  /**
+   * Detect if pane content looks like the agent is asking a question.
+   */
+  _looksLikeQuestion(tail) {
+    // Has question mark near the end
+    if (/[?？]\s*$/.test(tail) || /[?？]\s*\n\s*❯/m.test(tail)) return true;
+    // Has numbered options (1. xxx  2. xxx)
+    if (/^\s*[1-9]\.\s+\S/m.test(tail) && /❯/.test(tail)) return true;
+    // Has Y/N prompt
+    if (/\(Y\/N\)/i.test(tail) || /\(y\/n\)/i.test(tail)) return true;
+    // Has "please confirm" or similar
+    if (/confirm|choose|select|which|请选择|请确认|是否/i.test(tail) && /❯/.test(tail)) return true;
+    return false;
+  }
+
+  /**
+   * Agent is waiting for user input. Notify user via Telegram and pause polling.
+   */
+  async _onAgentWaitingInput(agent, paneContent) {
+    this._waitingForInput = true;
+
+    // Extract the question from pane content (last meaningful lines before ❯)
+    const lines = paneContent.split('\n');
+    const promptIdx = lines.findLastIndex((l) => /❯/.test(l));
+    const questionLines = lines.slice(Math.max(0, promptIdx - 15), promptIdx).filter((l) => l.trim());
+    const question = questionLines.join('\n').trim() || '(unable to extract question)';
+
+    log.engine(`Agent ${agent.name} is asking a question, notifying user`);
+
+    const notification = `📋 **${agent.name}** is asking:\n\n${question}\n\n↩️ *Reply to this message to answer the agent.*`;
+
+    try {
+      const result = await this._onQuestionAsked(notification);
+      if (result && result.messageId) {
+        this._waitingMessageId = String(result.messageId);
+      }
+    } catch (err) {
+      log.warn(`Failed to send question notification: ${err.message}`);
+      // Auto-continue on failure
+      this._waitingForInput = false;
+    }
+  }
+
+  /**
+   * Relay user's reply to the agent's tmux window.
+   * Called by router when user replies to the question notification.
+   */
+  relayUserInput(text) {
+    if (!this._waitingForInput || !this._session) {
+      return false;
+    }
+
+    const agent = PLAN_AGENTS[this._step];
+    if (!agent) return false;
+
+    log.engine(`Relaying user input to ${agent.name}: "${text.slice(0, 50)}..."`);
+
+    tmx.sendKeysWithEnter(this._session, agent.window, text);
+
+    // Resume polling
+    this._waitingForInput = false;
+    this._waitingMessageId = null;
+    this._stableCount = 0;
+    this._lastHash = '';
+
+    return true;
+  }
+
+  /**
+   * Get the Telegram message_id of the current question notification.
+   * Used by router to check if a reply-to matches.
+   */
+  getWaitingMessageId() {
+    return this._waitingMessageId;
+  }
+
   _onAgentComplete(agent) {
     this._stableCount = 0;
     this._lastHash = '';
@@ -254,6 +418,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/index.js

@@ -39,12 +39,16 @@ async function startGateway(opts = {}) {
     });
     adapters.push(telegram);
 
-    // Wire proactive messaging: orchestrator → Telegram
+    // Wire proactive messaging: orchestrator → Telegram (returns { messageId })
     router.setSendCallback(null, async (chatId, text) => {
       try {
-        await telegram.bot.api.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+        const sent = await telegram.bot.api.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+        return { messageId: String(sent.message_id) };
       } catch {
-        await telegram.bot.api.sendMessage(chatId, text).catch(() => {});
+        try {
+          const sent = await telegram.bot.api.sendMessage(chatId, text);
+          return { messageId: String(sent.message_id) };
+        } catch { return null; }
       }
     });
 

package/lib/gateway/router.js

@@ -54,7 +54,14 @@ class Router {
       onProgress: (msg) => this._sendProactive(msg),
       onComplete: (phase, summary) => this._sendProactive(summary),
       onError: (phase, err) => this._sendProactive(`❌ Phase ${phase} error: ${err}`),
+      onQuestionAsked: (text) => this._sendProactiveWithId(text),
     });
+
+    // Auto-recover any in-progress phase from previous gateway run
+    const projectRoot = engine.resolveProjectRoot();
+    if (projectRoot) {
+      this.orchestrator.tryRecover(projectRoot);
+    }
   }
 
   /**
@@ -74,6 +81,20 @@ class Router {
     }
   }
 
+  /**
+   * Send a proactive message and return { messageId } for reply-to tracking.
+   */
+  async _sendProactiveWithId(text) {
+    if (!this._sendCallback || !this._ownerChatId) return null;
+    try {
+      const result = await this._sendCallback(this._ownerChatId, text);
+      return result; // { messageId }
+    } catch (err) {
+      log.warn(`Proactive send failed: ${err.message}`);
+      return null;
+    }
+  }
+
   /**
    * Handle an incoming channel message.
    */
@@ -107,6 +128,17 @@ class Router {
       return this._handleStatusQuery(msg);
     }
 
+    // ═══ AGENT REPLY — user replied to an agent question notification ═══
+    if (msg.replyToMessageId && this.orchestrator.isWaitingForInput()) {
+      const waitingId = this.orchestrator.getWaitingMessageId();
+      if (waitingId && msg.replyToMessageId === waitingId) {
+        const relayed = this.orchestrator.relayUserInput(msg.text);
+        if (relayed) {
+          return { text: '✅ Reply sent to agent. Resuming...' };
+        }
+      }
+    }
+
     // ═══ CANCEL — stop running phase ═══
     if (PHASE_COMMANDS.cancel.test(msg.text.trim())) {
       if (this.orchestrator.isRunning()) {
@@ -186,13 +218,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 +233,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.3.0",
   "description": "Yuri — Meta-Orchestrator for Orchestrix. Drive your entire project lifecycle with natural language.",
   "main": "lib/installer.js",
   "bin": {