orchestrix-yuri 4.7.6 → 4.7.8

package/lib/gateway/router.js

@@ -349,6 +349,9 @@ class Router {
       }
       case 'change': {
         const desc = classified.description || msg.text;
+        // Direct agent routing: user explicitly names an agent → skip scope/PO
+        const directResult = await this._tryDirectAgentRoute(msg, projectRoot, desc);
+        if (directResult) return directResult;
         msg.text = `*change ${desc}`;
         return this._handleChangeCommand(msg, projectRoot);
       }
@@ -358,8 +361,16 @@ class Router {
       case 'iterate':
       case 'deploy':
         return this._handlePhaseCommand(classified.action, msg);
-      case 'status':
+      case 'status': {
+        // Agent-specific or decision queries need Claude reasoning with tmux context,
+        // not a canned status card. Fall through to conversation handler.
+        const agentRe = /\b(sm|architect|dev|qa|po|pm|ux)\b/i;
+        const decisionRe = /决策|决定|确认|需要我|block|decide|should i|approve/i;
+        if (agentRe.test(msg.text) || decisionRe.test(msg.text)) {
+          return null; // → conversation handler (Claude with tmux context)
+        }
         return this._handleStatusQuery(msg);
+      }
       default:
         return null;
     }
@@ -411,6 +422,105 @@ class Router {
     return { text: response };
   }
 
+  /**
+   * Direct agent routing: when user explicitly names a planning or dev agent,
+   * skip scope assessment and PO routing — send the instruction directly.
+   * Returns null if no agent match (caller should fall through to normal change flow).
+   */
+  async _tryDirectAgentRoute(msg, projectRoot, description) {
+    // Agent name patterns → { session type, agent slug for /o, window }
+    const AGENT_MAP = {
+      // Planning session agents
+      'analyst':   { session: 'planning', slug: 'analyst', window: 0 },
+      'pm':        { session: 'planning', slug: 'pm', window: 1 },
+      'ux-expert': { session: 'planning', slug: 'ux-expert', window: 2 },
+      'ux':        { session: 'planning', slug: 'ux-expert', window: 2 },
+      // Dev session agents
+      'architect': { session: 'dev', slug: 'architect', window: 0 },
+      'sm':        { session: 'dev', slug: 'sm', window: 1 },
+      'dev':       { session: 'dev', slug: 'dev', window: 2 },
+      'qa':        { session: 'dev', slug: 'qa', window: 3 },
+    };
+
+    // Match agent name in user message (case-insensitive, word boundary)
+    const text = msg.text.toLowerCase();
+    let matched = null;
+    for (const [name, info] of Object.entries(AGENT_MAP)) {
+      if (text.includes(name)) {
+        // Prefer longer match (ux-expert over ux)
+        if (!matched || name.length > matched.name.length) {
+          matched = { name, ...info };
+        }
+      }
+    }
+    if (!matched) return null;
+
+    // Guard: don't hijack if orchestrator is busy with something else
+    if (this.orchestrator.isRunning()) {
+      return null; // let normal flow handle it
+    }
+
+    log.router(`Direct agent route: ${matched.slug} (${matched.session} session, window ${matched.window})`);
+
+    try {
+      const { execSync } = require('child_process');
+      const scriptPath = path.join(os.homedir(), '.claude', 'skills', 'yuri', 'scripts', 'ensure-session.sh');
+      const result = execSync(`bash "${scriptPath}" ${matched.session} "${projectRoot}"`, {
+        encoding: 'utf8', timeout: 60000,
+      }).trim();
+      const lines = result.split('\n');
+      const session = lines[lines.length - 1].trim();
+
+      const tmx = require('./engine/tmux-utils');
+      tmx.sendKeysWithEnter(session, matched.window, '/clear');
+      execSync('sleep 2');
+      tmx.sendKeysWithEnter(session, matched.window, `/o ${matched.slug}`);
+      execSync('sleep 12');
+
+      // Send the user's instruction directly
+      const safeDesc = description.replace(/"/g, '\\"');
+      tmx.sendKeysWithEnter(session, matched.window, safeDesc);
+
+      // Set up polling via orchestrator (reuses change/small flow)
+      this.orchestrator._projectRoot = projectRoot;
+      this.orchestrator._phase = 'change';
+      this.orchestrator._session = session;
+      this.orchestrator._lastHash = '';
+      this.orchestrator._stableCount = 0;
+      this.orchestrator._step = 0;
+      this.orchestrator._changeContext = { scope: 'direct', description, agent: matched.slug };
+      const pollInterval = this.orchestrator.config.phase_poll_interval || 30000;
+      this.orchestrator._timer = setInterval(() => {
+        // Poll the specific agent window
+        if (this.orchestrator._phase !== 'change') return;
+        if (!tmx.hasSession(session)) {
+          this.orchestrator._handleError('change', `${matched.slug} tmux session died`);
+          return;
+        }
+        const check = tmx.checkCompletion(session, matched.window, this.orchestrator._lastHash);
+        if (check.status === 'complete' || (check.status === 'stable' && ++this.orchestrator._stableCount >= 3)) {
+          if (this.orchestrator._timer) { clearInterval(this.orchestrator._timer); this.orchestrator._timer = null; }
+          this.orchestrator._phase = null;
+          this.orchestrator._changeContext = null;
+          this.orchestrator.onComplete('change', `✅ ${matched.slug} completed the task.`);
+          return;
+        }
+        if (check.status !== 'stable') { this.orchestrator._stableCount = 0; this.orchestrator._lastHash = check.hash || ''; }
+        else { this.orchestrator._lastHash = check.hash; }
+      }, pollInterval);
+
+      this.history.append(msg.chatId, 'user', msg.text);
+      const reply = `🎯 Direct → **${matched.slug}** (window ${matched.window})\n\n"${description.slice(0, 120)}"\n\nI'll notify you when done.`;
+      this.history.append(msg.chatId, 'assistant', reply);
+      this._updateGlobalFocus(msg, projectRoot);
+
+      return { text: reply };
+    } catch (err) {
+      log.warn(`Direct agent route failed: ${err.message}`);
+      return null; // fall through to normal change flow
+    }
+  }
+
   /**
    * Handle *change command in two steps:
    * Step 1: Claude assesses the scope (small/medium/large) — quick claude -p call
@@ -540,13 +650,19 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
 
     const projectRoot = engine.resolveProjectRoot();
 
-    // If a phase is running, inject tmux pane context so Claude can see agent state
+    // 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}`;
       }
+    } else if (projectRoot) {
+      // Even without active orchestrator, check for live dev sessions
+      const tmxContext = this._captureLiveDevContext(projectRoot);
+      if (tmxContext) {
+        prompt = `${tmxContext}\n\n---\n\nUser message: ${msg.text}`;
+      }
     }
 
     log.router(`Processing: "${msg.text.slice(0, 80)}..." → cwd: ${projectRoot || '~'}`);
@@ -970,6 +1086,31 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
     return lines.join('\n');
   }
 
+  // ── Live Dev Context (for conversation when orchestrator is not tracking) ─────
+
+  _captureLiveDevContext(projectRoot) {
+    const { execSync } = require('child_process');
+    const tmx = require('./engine/tmux-utils');
+    try {
+      const sessions = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', { encoding: 'utf8' }).trim();
+      const projectName = path.basename(projectRoot).toLowerCase();
+      const devSession = sessions.split('\n').find((s) =>
+        s.startsWith('orchestrix-') && s.toLowerCase().includes(projectName)
+      ) || sessions.split('\n').find((s) => s.startsWith('orchestrix-'));
+      if (!devSession || !tmx.hasSession(devSession)) return null;
+
+      const windows = ['Architect', 'SM', 'Dev', 'QA'];
+      const summaries = [];
+      for (let w = 0; w < 4; w++) {
+        const tail = tmx.capturePane(devSession, w, 10);
+        const lines = tail.split('\n').filter((l) => l.trim());
+        const last = lines.slice(-3).map((l) => l.trim().slice(0, 100)).join('\n    ');
+        summaries.push(`  Window ${w} (${windows[w]}):\n    ${last || '(idle)'}`);
+      }
+      return `[LIVE DEV SESSION] ${devSession} (orchestrator not actively tracking)\n${summaries.join('\n')}`;
+    } catch { return null; }
+  }
+
   // ── Help ──────────────────────────────────────────────────────────────────────
 
   _buildHelpText() {

package/package.json

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