orchestrix-yuri 3.2.1 → 3.3.1

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,16 @@ 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.
@@ -105,6 +112,43 @@ class PhaseOrchestrator {
     }
   }
 
+  /**
+   * Capture the current agent's tmux pane content for Claude context injection.
+   * Returns a formatted string or null if no agent is active.
+   */
+  captureCurrentAgentContext() {
+    if (!this._phase || !this._session || !tmx.hasSession(this._session)) {
+      return null;
+    }
+
+    if (this._phase === 'plan') {
+      const agent = PLAN_AGENTS[this._step];
+      if (!agent) return null;
+
+      const pane = tmx.capturePane(this._session, agent.window, 40);
+      if (!pane.trim()) return null;
+
+      const waiting = this._waitingForInput ? ' (WAITING FOR YOUR INPUT)' : '';
+      return `[LIVE AGENT CONTEXT] Phase: plan, Agent: ${agent.name} (${this._step + 1}/${PLAN_AGENTS.length})${waiting}\n` +
+             `tmux session: ${this._session}, window: ${agent.window}\n` +
+             `--- Agent output (last 40 lines) ---\n${pane}\n--- End agent output ---`;
+    }
+
+    if (this._phase === 'develop') {
+      // Capture all 4 dev windows briefly
+      const windows = ['Architect', 'SM', 'Dev', 'QA'];
+      const summaries = [];
+      for (let w = 0; w < 4; w++) {
+        const tail = tmx.capturePane(this._session, w, 5);
+        const lastLine = tail.split('\n').filter((l) => l.trim()).pop() || '(empty)';
+        summaries.push(`  Window ${w} (${windows[w]}): ${lastLine.trim().slice(0, 80)}`);
+      }
+      return `[LIVE AGENT CONTEXT] Phase: develop, Session: ${this._session}\n${summaries.join('\n')}`;
+    }
+
+    return null;
+  }
+
   getStatus() {
     if (!this._phase) {
       return { phase: null, message: 'No phase is running.' };
@@ -239,6 +283,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);
 
@@ -251,8 +298,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 {
@@ -261,6 +321,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 = '';

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,6 +54,7 @@ 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
@@ -80,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.
    */
@@ -113,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()) {
@@ -244,7 +270,15 @@ class Router {
     await this._runCatchUp();
 
     const projectRoot = engine.resolveProjectRoot();
-    const prompt = engine.composePrompt(msg.text);
+
+    // If a phase is running, inject tmux pane context so Claude can see agent state
+    let prompt = engine.composePrompt(msg.text);
+    if (this.orchestrator.isRunning()) {
+      const agentContext = this.orchestrator.captureCurrentAgentContext();
+      if (agentContext) {
+        prompt = `${agentContext}\n\n---\n\nUser message: ${msg.text}`;
+      }
+    }
 
     log.router(`Processing: "${msg.text.slice(0, 80)}..." → cwd: ${projectRoot || '~'}`);
     const result = await engine.callClaude({

package/package.json

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