orchestrix-yuri 4.6.7 → 4.7.1

package/lib/gateway/config.js

@@ -25,6 +25,7 @@ const DEFAULTS = {
     phase_poll_interval: 30000,   // plan phase: poll agent every 30s
     dev_poll_interval: 300000,    // dev phase: poll progress every 5 min
     report_interval: 1800000,     // dev phase: progress report every 30 min
+    conversation_timeout: 90000,  // normal conversation reply timeout (90s)
   },
 };
 

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

@@ -309,7 +309,7 @@ function runClaude(args, cwd, timeout) {
     }, (err, stdout, stderr) => {
       if (err && err.killed) {
         log.warn('Claude CLI timed out');
-        return resolve({ reply: '⏱ Response timed out.', raw: '' });
+        return resolve({ reply: '⏱ Taking longer than expected. Try a specific command like `*change "desc"` or `*status`.', raw: '' });
       }
       // Claude CLI may return non-zero exit code even with valid JSON output
       // (e.g., stderr "Warning: no stdin data received" causes exit code 1).

package/lib/gateway/engine/dispatcher.js

@@ -0,0 +1,169 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const os = require('os');
+const tmx = require('./tmux-utils');
+const { log } = require('../log');
+
+const SKILL_DIR = path.join(os.homedir(), '.claude', 'skills', 'yuri');
+const SESSION_NAME = 'yuri-dispatcher';
+
+/**
+ * Dispatcher: a persistent Claude Code instance in a tmux session
+ * that classifies incoming natural language messages into structured actions.
+ *
+ * Runs independently from the Yuri conversation session to avoid
+ * polluting chat history with classification prompts.
+ */
+class Dispatcher {
+  constructor(config) {
+    this._config = config || {};
+    this._ready = false;
+    this._busy = false;
+  }
+
+  /**
+   * Start the dispatcher tmux session with Claude Code + system prompt.
+   * Called once on gateway startup. Reuses existing session if alive.
+   */
+  async start() {
+    if (tmx.hasSession(SESSION_NAME)) {
+      this._ready = true;
+      log.engine('Dispatcher: reusing existing session');
+      return;
+    }
+
+    try {
+      execSync(`tmux new-session -d -s "${SESSION_NAME}" -x 200 -y 50`, { timeout: 10000 });
+    } catch (err) {
+      log.warn(`Dispatcher: failed to create tmux session: ${err.message}`);
+      return;
+    }
+
+    // Launch Claude Code with dispatcher system prompt
+    const promptPath = path.join(SKILL_DIR, 'resources', 'dispatcher-prompt.txt');
+    tmx.sendKeysWithEnter(SESSION_NAME, 0,
+      `claude --system-prompt-file "${promptPath}" --dangerously-skip-permissions`);
+
+    // Wait for Claude Code to be ready (❯ prompt)
+    const ready = tmx.waitForPrompt(SESSION_NAME, 0, 45000);
+    this._ready = ready;
+
+    if (ready) {
+      log.engine('Dispatcher: ready');
+    } else {
+      log.warn('Dispatcher: Claude Code did not become ready within timeout');
+    }
+  }
+
+  /**
+   * Classify a user message into an action.
+   * Returns { action, description, reasoning }.
+   *
+   * @param {string} text - raw user message
+   * @returns {Promise<{action: string, description: string, reasoning: string}>}
+   */
+  async classify(text) {
+    // Re-entry guard
+    if (this._busy) {
+      return { action: 'conversation', description: text, reasoning: 'dispatcher busy' };
+    }
+
+    // Auto-recover if session died
+    if (!this._ready || !tmx.hasSession(SESSION_NAME)) {
+      this._ready = false;
+      await this.start();
+      if (!this._ready) {
+        return { action: 'conversation', description: text, reasoning: 'dispatcher unavailable' };
+      }
+    }
+
+    this._busy = true;
+
+    try {
+      // Send user message to dispatcher
+      tmx.sendKeysWithEnter(SESSION_NAME, 0, text);
+
+      // Poll for completion (max 30s, every 2s)
+      const deadline = Date.now() + 30000;
+      let lastHash = '';
+      let stableCount = 0;
+
+      while (Date.now() < deadline) {
+        execSync('sleep 2');
+        const result = tmx.checkCompletion(SESSION_NAME, 0, lastHash);
+
+        if (result.status === 'complete' || (result.status === 'stable' && ++stableCount >= 2)) {
+          const output = tmx.capturePane(SESSION_NAME, 0, 30);
+          return this._parseResponse(output, text);
+        }
+
+        if (result.status !== 'stable') {
+          stableCount = 0;
+          lastHash = result.hash || '';
+        } else {
+          lastHash = result.hash;
+        }
+      }
+
+      // Timeout — default to conversation
+      log.warn('Dispatcher: classify timeout');
+      return { action: 'conversation', description: text, reasoning: 'classifier timeout' };
+    } finally {
+      this._busy = false;
+    }
+  }
+
+  /**
+   * Parse the dispatcher's tmux pane output to extract the JSON response.
+   * Searches from bottom up for the first valid JSON line with "action".
+   */
+  _parseResponse(output, originalText) {
+    const lines = output.split('\n');
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      // Look for JSON that contains "action"
+      if (line.startsWith('{') && line.includes('"action"')) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.action) {
+            const valid = ['change', 'plan', 'develop', 'test', 'deploy', 'status', 'iterate', 'conversation'];
+            if (valid.includes(parsed.action)) {
+              return {
+                action: parsed.action,
+                description: parsed.description || originalText,
+                reasoning: parsed.reasoning || '',
+              };
+            }
+          }
+        } catch { /* not valid JSON, continue searching */ }
+      }
+    }
+
+    log.warn('Dispatcher: failed to parse response, defaulting to conversation');
+    return { action: 'conversation', description: originalText, reasoning: 'parse failed' };
+  }
+
+  /**
+   * Check if dispatcher is available.
+   */
+  isReady() {
+    return this._ready && tmx.hasSession(SESSION_NAME);
+  }
+
+  /**
+   * Gracefully shutdown the dispatcher session.
+   */
+  shutdown() {
+    if (tmx.hasSession(SESSION_NAME)) {
+      tmx.killSession(SESSION_NAME);
+    }
+    this._ready = false;
+    this._busy = false;
+    log.engine('Dispatcher: shutdown');
+  }
+}
+
+module.exports = { Dispatcher };

package/lib/gateway/history.js

@@ -70,6 +70,19 @@ class ChatHistory {
     this._trimIfNeeded(filePath);
   }
 
+  /**
+   * Get the last assistant message for a chat.
+   * @param {string} chatId
+   * @returns {string|null}
+   */
+  getLastAssistantMessage(chatId) {
+    const messages = this.getRecent(chatId);
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === 'assistant') return messages[i].text;
+    }
+    return null;
+  }
+
   _trimIfNeeded(filePath) {
     const lines = fs.readFileSync(filePath, 'utf8').trim().split('\n').filter(Boolean);
     const limit = this.maxMessages * 2;

package/lib/gateway/router.js

@@ -10,6 +10,7 @@ const { OwnerBinding } = require('./binding');
 const engine = require('./engine/claude-sdk');
 const { runReflect } = require('./engine/reflect');
 const { PhaseOrchestrator } = require('./engine/phase-orchestrator');
+const { Dispatcher } = require('./engine/dispatcher');
 const { log } = require('./log');
 
 const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
@@ -73,6 +74,10 @@ class Router {
       this.orchestrator.tryRecover(projectRoot);
     }
 
+    // Dispatcher: persistent Claude agent for NL intent classification
+    this.dispatcher = new Dispatcher(config);
+    this.dispatcher.start().catch((err) => log.warn(`Dispatcher start failed: ${err.message}`));
+
     // Independent progress reporter: sends periodic status card
     // when dev phase is active (detected from focus.yaml + tmux),
     // regardless of whether orchestrator is tracking it.
@@ -276,7 +281,42 @@ class Router {
       return this._handlePhaseCommand(phaseCmd, msg);
     }
 
-    // ═══ NORMAL MESSAGE — goes through Claude ═══
+    // ═══ DISPATCHER CLASSIFY — NL intent detection via persistent Claude agent ═══
+    {
+      // Inject last assistant response as context for the dispatcher
+      const lastReply = this.history.getLastAssistantMessage(msg.chatId);
+      const contextText = lastReply
+        ? `[CONTEXT] Previous assistant response: ${lastReply.slice(0, 300)}\n\nUser message: ${msg.text}`
+        : msg.text;
+
+      let classified = null;
+      if (this.dispatcher) {
+        try {
+          classified = await this.dispatcher.classify(contextText);
+          log.router(`Dispatcher: ${classified.action} ← "${msg.text.slice(0, 50)}..." (${classified.reasoning})`);
+        } catch (err) {
+          log.warn(`Dispatcher classify failed: ${err.message}`);
+        }
+      }
+
+      // If dispatcher unavailable or failed, default to 'change' for work-like messages
+      if (!classified) {
+        classified = { action: 'change', description: msg.text, reasoning: 'dispatcher unavailable, defaulting to change' };
+        log.router(`Dispatcher unavailable, defaulting to change for: "${msg.text.slice(0, 50)}..."`);
+      }
+
+      if (classified.action !== 'conversation') {
+        try {
+          const intentResult = await this._executeClassifiedIntent(classified, msg);
+          if (intentResult) return intentResult;
+        } catch (err) {
+          log.warn(`Intent execution failed: ${err.message}`);
+          // Fall through to conversation
+        }
+      }
+    }
+
+    // ═══ NORMAL MESSAGE — conversation via Claude ═══
     if (this.processing.has(msg.chatId)) {
       return { text: '⏳ Still processing your previous message. Please wait.' };
     }
@@ -289,6 +329,35 @@ class Router {
     }
   }
 
+  // ── Dispatcher Intent Execution ─────────────────────────────────────────────
+
+  async _executeClassifiedIntent(classified, msg) {
+    const projectRoot = engine.resolveProjectRoot();
+    if (!projectRoot) {
+      return { text: '❌ No active project. Run `/yuri *create` in your terminal first.' };
+    }
+
+    this.history.append(msg.chatId, 'user', msg.text);
+
+    switch (classified.action) {
+      case 'change': {
+        const desc = classified.description || msg.text;
+        msg.text = `*change ${desc}`;
+        return this._handleChangeCommand(msg, projectRoot);
+      }
+      case 'plan':
+      case 'develop':
+      case 'test':
+      case 'iterate':
+      case 'deploy':
+        return this._handlePhaseCommand(classified.action, msg);
+      case 'status':
+        return this._handleStatusQuery(msg);
+      default:
+        return null;
+    }
+  }
+
   // ── Phase Command Handling ───────────────────────────────────────────────────
 
   _detectPhaseCommand(text) {
@@ -478,6 +547,7 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
       prompt,
       cwd: projectRoot,
       engineConfig: this.config.engine,
+      timeout: (this.config.engine && this.config.engine.conversation_timeout) || 90000,
     });
 
     this.history.append(msg.chatId, 'user', msg.text);
@@ -952,6 +1022,7 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
   async shutdown() {
     if (this._reportTimer) clearInterval(this._reportTimer);
     this.orchestrator.shutdown();
+    if (this.dispatcher) this.dispatcher.shutdown();
     if (engine.destroySession) engine.destroySession();
   }
 }

package/package.json

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

package/skill/resources/dispatcher-prompt.txt

@@ -0,0 +1,34 @@
+You are a message classifier for Yuri, a project orchestrator.
+
+Your ONLY job is to classify incoming user messages into structured actions.
+Messages may include "[CONTEXT]" with the previous assistant response for reference.
+
+## Available Actions
+
+| Action | When to use | Examples |
+|--------|-------------|---------|
+| change | User wants ANY work done: fix, modify, add, redesign, create a plan, write something, have an agent do work | "这个 bug 修一下", "让 UX 重新设计界面", "Add dark mode", "先做个完整的设计 plan", "写一份方案", "从 PO 开始改" |
+| plan | User explicitly wants to START the planning phase from scratch | "开始规划", "*plan" |
+| develop | User explicitly wants to START development phase | "开始开发", "*develop" |
+| test | User wants to run tests | "跑一下测试", "冒烟测试" |
+| deploy | User wants to deploy or release | "部署到线上", "发布", "上线" |
+| status | User asks about progress, previous results, or what happened | "之前的方案呢？", "进展如何？", "怎么样了", "结果出来了吗" |
+| iterate | User wants a new iteration cycle | "新迭代", "下一轮" |
+| conversation | ONLY for pure questions or opinions with NO actionable request | "你觉得怎么样？", "这个架构好不好？", "解释一下这段代码" |
+
+## Response Format
+
+Reply with EXACTLY this JSON format on a single line, nothing else:
+
+{"action":"<action>","description":"<brief description for the agent>","reasoning":"<one sentence why>"}
+
+## Critical Rules
+
+- **Bias toward "change"**: If the user wants ANYTHING done (create, write, fix, modify, redesign, evaluate, plan something), classify as "change". The "change" action is the safe default for any work request.
+- If the user is replying to a question with a choice/decision (e.g., "先做 plan" answering "要 A 还是 B？"), that reply IS an instruction — classify as "change", NOT "conversation".
+- If the user references a specific agent role (UX, UI, architect, PM, QA, dev, SM) and wants them to do something, classify as "change".
+- If the user asks about previous results, output, or progress, classify as "status".
+- "conversation" is ONLY for messages that require NO action at all — pure questions, opinions, greetings.
+- When in doubt between "change" and "conversation", ALWAYS choose "change".
+- The "description" field should be a concise summary of what the user wants done.
+- ALWAYS respond with the JSON format above. Never add explanation, markdown, or anything else.