orchestrix-yuri 3.1.2 → 3.2.0

package/lib/gateway/config.js

@@ -22,6 +22,8 @@ const DEFAULTS = {
     timeout: 300000,              // per-message timeout (5 min)
     autocompact_pct: 80,          // trigger auto-compact at this % (default 95%)
     compact_every: 50,            // proactive /compact after N messages
+    phase_poll_interval: 30000,   // plan phase: poll agent every 30s
+    dev_poll_interval: 300000,    // dev phase: poll progress every 5 min
   },
 };
 

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

@@ -0,0 +1,478 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const yaml = require('js-yaml');
+const tmx = require('./tmux-utils');
+const { log } = require('../log');
+
+const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
+const SKILL_DIR = path.join(os.homedir(), '.claude', 'skills', 'yuri');
+
+// ── Plan Agent Sequence ────────────────────────────────────────────────────────
+
+const PLAN_AGENTS = [
+  { name: 'analyst', cmd: '*create-doc project-brief', output: 'docs/project-brief.md', window: 0 },
+  { name: 'pm', cmd: '*create-doc prd', output: 'docs/prd.md', window: 1 },
+  { name: 'ux-expert', cmd: '*create-doc front-end-spec', output: 'docs/front-end-spec.md', window: 2 },
+  { name: 'architect', cmd: '*create-doc fullstack-architecture', output: 'docs/architecture.md', window: 3 },
+  { name: 'po', cmd: '*execute-checklist po-master-validation', output: null, window: 4 },
+  { name: 'po', cmd: '*shard', output: null, window: 4, sameWindow: true },
+];
+
+// ── Orchestrator ───────────────────────────────────────────────────────────────
+
+class PhaseOrchestrator {
+  /**
+   * @param {object} opts
+   * @param {function} opts.onProgress - (message: string) → void — proactive Telegram notification
+   * @param {function} opts.onComplete - (phase: string, summary: string) → void
+   * @param {function} opts.onError - (phase: string, error: string) → void
+   * @param {object} opts.config - engine config from channels.yaml
+   */
+  constructor(opts = {}) {
+    this.onProgress = opts.onProgress || (() => {});
+    this.onComplete = opts.onComplete || (() => {});
+    this.onError = opts.onError || (() => {});
+    this.config = opts.config || {};
+
+    this._phase = null;       // 'plan' | 'develop' | null
+    this._step = 0;           // current agent index
+    this._session = null;     // tmux session name
+    this._projectRoot = null;
+    this._timer = null;
+    this._lastHash = '';
+    this._stableCount = 0;
+  }
+
+  isRunning() { return this._phase !== null; }
+
+  getStatus() {
+    if (!this._phase) {
+      return { phase: null, message: 'No phase is running.' };
+    }
+
+    if (this._phase === 'plan') {
+      const agent = PLAN_AGENTS[this._step];
+      return {
+        phase: 'plan',
+        step: this._step + 1,
+        total: PLAN_AGENTS.length,
+        agent: agent ? agent.name : 'unknown',
+        message: `📋 Planning: agent ${this._step + 1}/${PLAN_AGENTS.length} (${agent ? agent.name : '?'}) running`,
+      };
+    }
+
+    if (this._phase === 'develop') {
+      return {
+        phase: 'develop',
+        message: '💻 Development in progress. Agents running autonomously.',
+      };
+    }
+
+    return { phase: this._phase, message: `Phase ${this._phase} is running.` };
+  }
+
+  cancel() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    const phase = this._phase;
+    this._phase = null;
+    this._step = 0;
+    log.engine(`Phase ${phase} cancelled`);
+  }
+
+  // ── Plan Phase ─────────────────────────────────────────────────────────────
+
+  /**
+   * Start plan phase in background. Returns immediately with status message.
+   */
+  startPlan(projectRoot) {
+    if (this._phase) {
+      return `⚠️ Phase "${this._phase}" is already running. Use *status to check progress.`;
+    }
+
+    this._projectRoot = projectRoot;
+    this._phase = 'plan';
+    this._step = 0;
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    // Validate phase1 complete
+    const phase1Path = path.join(projectRoot, '.yuri', 'state', 'phase1.yaml');
+    if (fs.existsSync(phase1Path)) {
+      const phase1 = yaml.load(fs.readFileSync(phase1Path, 'utf8')) || {};
+      if (phase1.status !== 'complete') {
+        this._phase = null;
+        return '❌ Phase 1 (Create) is not complete. Run *create first.';
+      }
+    }
+
+    // Check for resume — find last completed step
+    const phase2Path = path.join(projectRoot, '.yuri', 'state', 'phase2.yaml');
+    if (fs.existsSync(phase2Path)) {
+      const phase2 = yaml.load(fs.readFileSync(phase2Path, 'utf8')) || {};
+      if (phase2.status === 'complete') {
+        this._phase = null;
+        return '✅ Planning already complete. Run *develop to start development.';
+      }
+      if (phase2.status === 'in_progress' && Array.isArray(phase2.steps)) {
+        const lastComplete = phase2.steps.findLastIndex((s) => s.status === 'complete');
+        if (lastComplete >= 0) {
+          this._step = lastComplete + 1;
+          log.engine(`Resuming plan from step ${this._step + 1}/${PLAN_AGENTS.length}`);
+        }
+      }
+    }
+
+    // Create/ensure tmux session
+    try {
+      this._session = this._ensurePlanSession(projectRoot);
+    } catch (err) {
+      this._phase = null;
+      return `❌ Failed to create planning session: ${err.message}`;
+    }
+
+    // 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}`;
+    }
+
+    // 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.`;
+  }
+
+  /**
+   * Poll current plan agent for completion.
+   */
+  _pollPlanAgent() {
+    if (this._phase !== 'plan') return;
+
+    const agent = PLAN_AGENTS[this._step];
+    if (!agent) {
+      this._completePlan();
+      return;
+    }
+
+    // Check if tmux session is alive
+    if (!tmx.hasSession(this._session)) {
+      this._handleError('plan', 'tmux session died unexpectedly');
+      return;
+    }
+
+    // Check completion
+    const result = tmx.checkCompletion(this._session, agent.window, this._lastHash);
+
+    if (result.status === 'complete') {
+      this._onAgentComplete(agent);
+      return;
+    }
+
+    if (result.status === 'stable') {
+      this._stableCount++;
+      this._lastHash = result.hash;
+      if (this._stableCount >= 3) {
+        // Content stable for 3 polls — agent likely done
+        this._onAgentComplete(agent);
+        return;
+      }
+    } else {
+      this._stableCount = 0;
+      this._lastHash = result.hash || '';
+    }
+  }
+
+  _onAgentComplete(agent) {
+    this._stableCount = 0;
+    this._lastHash = '';
+
+    // Verify output file if specified
+    let outputExists = true;
+    if (agent.output) {
+      const outputPath = path.join(this._projectRoot, agent.output);
+      outputExists = fs.existsSync(outputPath);
+    }
+
+    // Update phase2 memory
+    this._updatePlanStepMemory(this._step, 'complete', agent.output);
+
+    const stepNum = this._step + 1;
+    log.engine(`Plan agent ${stepNum}/${PLAN_AGENTS.length} (${agent.name}) complete`);
+
+    // Notify user
+    const outputStatus = agent.output ? (outputExists ? `→ ${agent.output}` : `⚠️ ${agent.output} not found`) : '';
+    this.onProgress(`✅ Agent ${stepNum}/${PLAN_AGENTS.length} (${agent.name}) complete ${outputStatus}`);
+
+    // Move to next agent
+    this._step++;
+
+    if (this._step >= PLAN_AGENTS.length) {
+      this._completePlan();
+      return;
+    }
+
+    // Start next agent
+    try {
+      this._startPlanAgent(this._step);
+    } catch (err) {
+      this._handleError('plan', `Failed to start next agent: ${err.message}`);
+    }
+  }
+
+  _completePlan() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+
+    // Kill planning session
+    if (this._session && tmx.hasSession(this._session)) {
+      tmx.killSession(this._session);
+    }
+
+    // Update memory
+    this._updatePlanMemory('complete');
+
+    this._phase = null;
+    this._step = 0;
+
+    log.engine('Plan phase complete');
+    this.onComplete('plan', '🎉 Planning phase complete! All 6 agents finished.\n\nRun *develop to start automated development.');
+  }
+
+  _startPlanAgent(stepIdx) {
+    const agent = PLAN_AGENTS[stepIdx];
+    if (!agent) return;
+
+    log.engine(`Starting plan agent ${stepIdx + 1}/${PLAN_AGENTS.length}: ${agent.name} → ${agent.cmd}`);
+
+    // Create new window unless sameWindow
+    if (!agent.sameWindow && stepIdx > 0) {
+      tmx.newWindow(this._session, agent.window, agent.name, this._projectRoot);
+      // Start Claude Code in the new window
+      tmx.sendKeys(this._session, agent.window, 'cc');
+      execSync('sleep 1');
+      execSync(`tmux send-keys -t "${this._session}:${agent.window}" C-m`);
+
+      // Wait for Claude Code to start (with trust dialog handling)
+      const ready = tmx.waitForPrompt(this._session, agent.window, 30000);
+      if (!ready) {
+        throw new Error(`Claude Code did not start in window ${agent.window}`);
+      }
+    }
+
+    // Activate Orchestrix agent
+    tmx.sendKeysWithEnter(this._session, agent.window, `/o ${agent.name}`);
+    execSync('sleep 10'); // Wait for agent to load
+
+    // Send command
+    tmx.sendKeysWithEnter(this._session, agent.window, agent.cmd);
+  }
+
+  _ensurePlanSession(projectRoot) {
+    const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+    if (!fs.existsSync(scriptPath)) {
+      throw new Error(`ensure-session.sh not found at ${scriptPath}`);
+    }
+
+    const result = execSync(`bash "${scriptPath}" planning "${projectRoot}"`, {
+      encoding: 'utf8',
+      timeout: 60000,
+    }).trim();
+
+    // ensure-session.sh echoes the session name
+    const lines = result.split('\n');
+    return lines[lines.length - 1].trim();
+  }
+
+  // ── Develop Phase ──────────────────────────────────────────────────────────
+
+  startDevelop(projectRoot) {
+    if (this._phase) {
+      return `⚠️ Phase "${this._phase}" is already running. Use *status to check progress.`;
+    }
+
+    this._projectRoot = projectRoot;
+    this._phase = 'develop';
+
+    // Validate phase2 complete
+    const phase2Path = path.join(projectRoot, '.yuri', 'state', 'phase2.yaml');
+    if (fs.existsSync(phase2Path)) {
+      const phase2 = yaml.load(fs.readFileSync(phase2Path, 'utf8')) || {};
+      if (phase2.status !== 'complete') {
+        this._phase = null;
+        return '❌ Phase 2 (Plan) is not complete. Run *plan first.';
+      }
+    }
+
+    // Start dev session via ensure-session.sh (runs start-orchestrix.sh)
+    try {
+      const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+      const result = execSync(`bash "${scriptPath}" dev "${projectRoot}"`, {
+        encoding: 'utf8',
+        timeout: 120000, // dev session setup takes longer (start-orchestrix.sh)
+      }).trim();
+      const lines = result.split('\n');
+      this._session = lines[lines.length - 1].trim();
+    } catch (err) {
+      this._phase = null;
+      return `❌ Failed to start dev session: ${err.message}`;
+    }
+
+    // Start polling (less frequent — handoff-detector handles agent chaining)
+    const pollInterval = this.config.dev_poll_interval || 300000; // 5 min
+    this._timer = setInterval(() => this._pollDevSession(), pollInterval);
+
+    log.engine(`Dev phase started: session=${this._session}`);
+    return '🚀 Development started! 4 agents (Architect, SM, Dev, QA) are running.\n\nAgents chain automatically via handoff-detector. I\'ll report progress every 5 minutes.';
+  }
+
+  _pollDevSession() {
+    if (this._phase !== 'develop') return;
+
+    if (!tmx.hasSession(this._session)) {
+      this._handleError('develop', 'Dev tmux session died unexpectedly');
+      return;
+    }
+
+    // Read story progress from scan-stories.sh or phase3.yaml
+    const phase3Path = path.join(this._projectRoot, '.yuri', 'state', 'phase3.yaml');
+    if (fs.existsSync(phase3Path)) {
+      try {
+        const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
+        const progress = phase3.progress || {};
+        const byStatus = progress.by_status || {};
+        const total = progress.total_stories || 0;
+        const done = (byStatus.done || 0) + (byStatus.complete || 0);
+
+        if (total > 0 && done >= total) {
+          this._completeDev();
+          return;
+        }
+
+        // Report progress
+        this.onProgress(`💻 Dev progress: ${done}/${total} stories complete`);
+      } catch { /* continue polling */ }
+    }
+  }
+
+  _completeDev() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+
+    this._phase = null;
+    log.engine('Dev phase complete');
+    this.onComplete('develop', '🎉 Development complete! All stories finished.\n\nRun *test to start smoke testing.');
+  }
+
+  // ── Shared ─────────────────────────────────────────────────────────────────
+
+  _handleError(phase, message) {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._phase = null;
+    log.error(`Phase ${phase} error: ${message}`);
+    this.onError(phase, message);
+  }
+
+  _updatePlanMemory(status) {
+    const projectRoot = this._projectRoot;
+    const yuriDir = path.join(projectRoot, '.yuri');
+
+    // Update phase2.yaml
+    const phase2Path = path.join(yuriDir, 'state', 'phase2.yaml');
+    const stateDir = path.join(yuriDir, 'state');
+    if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+
+    let phase2 = {};
+    if (fs.existsSync(phase2Path)) {
+      phase2 = yaml.load(fs.readFileSync(phase2Path, 'utf8')) || {};
+    }
+
+    phase2.status = status;
+    if (status === 'in_progress' && !phase2.started_at) {
+      phase2.started_at = new Date().toISOString();
+    }
+    if (status === 'complete') {
+      phase2.completed_at = new Date().toISOString();
+    }
+    if (!Array.isArray(phase2.steps)) {
+      phase2.steps = PLAN_AGENTS.map((a) => ({ id: a.name, status: 'pending' }));
+    }
+    if (this._session) {
+      phase2.tmux = { session: this._session };
+    }
+
+    fs.writeFileSync(phase2Path, yaml.dump(phase2, { lineWidth: -1 }));
+
+    // Update focus.yaml
+    const focusPath = path.join(yuriDir, 'focus.yaml');
+    let focus = {};
+    if (fs.existsSync(focusPath)) {
+      focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+    }
+    focus.phase = 2;
+    focus.step = status === 'complete' ? 'phase2.complete' : 'planning';
+    focus.pulse = status === 'complete' ? 'Phase 2 complete' : `Phase 2: ${this._step + 1}/${PLAN_AGENTS.length} agents`;
+    focus.updated_at = new Date().toISOString();
+    fs.writeFileSync(focusPath, yaml.dump(focus, { lineWidth: -1 }));
+  }
+
+  _updatePlanStepMemory(stepIdx, status, output) {
+    const phase2Path = path.join(this._projectRoot, '.yuri', 'state', 'phase2.yaml');
+    if (!fs.existsSync(phase2Path)) return;
+
+    const phase2 = yaml.load(fs.readFileSync(phase2Path, 'utf8')) || {};
+    if (Array.isArray(phase2.steps) && phase2.steps[stepIdx]) {
+      phase2.steps[stepIdx].status = status;
+      if (output) phase2.steps[stepIdx].output = output;
+      phase2.steps[stepIdx].completed_at = new Date().toISOString();
+    }
+
+    fs.writeFileSync(phase2Path, yaml.dump(phase2, { lineWidth: -1 }));
+
+    // Append timeline event
+    const timelinePath = path.join(this._projectRoot, '.yuri', 'timeline', 'events.jsonl');
+    const timelineDir = path.dirname(timelinePath);
+    if (!fs.existsSync(timelineDir)) fs.mkdirSync(timelineDir, { recursive: true });
+
+    const event = {
+      ts: new Date().toISOString(),
+      type: 'agent_completed',
+      agent: PLAN_AGENTS[stepIdx].name,
+      output: output || '',
+    };
+    fs.appendFileSync(timelinePath, JSON.stringify(event) + '\n');
+  }
+
+  /**
+   * Graceful shutdown — stop polling but don't kill tmux sessions.
+   */
+  shutdown() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    log.engine('Phase orchestrator shut down (tmux sessions preserved)');
+  }
+}
+
+module.exports = { PhaseOrchestrator };

package/lib/gateway/engine/tmux-utils.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+
+/**
+ * Shared tmux utilities for phase orchestration.
+ * All operations are synchronous (execSync) since tmux commands are instant.
+ */
+
+function tmux(cmd) {
+  return execSync(`tmux ${cmd}`, { encoding: 'utf8', timeout: 10000 }).trim();
+}
+
+function tmuxSafe(cmd) {
+  try { return tmux(cmd); } catch { return null; }
+}
+
+function hasSession(session) {
+  return tmuxSafe(`has-session -t "${session}" 2>/dev/null`) !== null;
+}
+
+function killSession(session) {
+  tmuxSafe(`kill-session -t "${session}"`);
+}
+
+function capturePane(session, window, lines) {
+  return tmuxSafe(`capture-pane -t "${session}:${window}" -p -S -${lines || 200}`) || '';
+}
+
+function sendKeys(session, window, text) {
+  tmux(`send-keys -t "${session}:${window}" "${text.replace(/"/g, '\\"')}"`);
+}
+
+/**
+ * Send text to a tmux pane with proper Enter handling.
+ * 3-step pattern: send content → sleep 1s → send Enter.
+ */
+function sendKeysWithEnter(session, window, text) {
+  sendKeys(session, window, text);
+  execSync('sleep 1');
+  tmux(`send-keys -t "${session}:${window}" Enter`);
+}
+
+function newWindow(session, windowIdx, name, cwd) {
+  tmux(`new-window -t "${session}:${windowIdx}" -n "${name}" -c "${cwd}"`);
+}
+
+/**
+ * Wait for Claude Code's ❯ prompt to appear in pane.
+ * Also auto-accepts "trust this folder" dialog if detected.
+ *
+ * @returns {boolean} true if prompt appeared, false if timeout
+ */
+function waitForPrompt(session, window, timeoutMs) {
+  const deadline = Date.now() + (timeoutMs || 30000);
+  const pollMs = 2000;
+
+  while (Date.now() < deadline) {
+    execSync(`sleep ${pollMs / 1000}`);
+    const pane = capturePane(session, window, 15);
+
+    // Auto-accept trust dialog
+    if (/trust this folder|safety check/i.test(pane)) {
+      tmux(`send-keys -t "${session}:${window}" Enter`);
+      execSync('sleep 2');
+      continue;
+    }
+
+    // ❯ prompt means Claude Code is ready
+    if (/❯/.test(pane)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a Claude Code agent has finished in a tmux pane.
+ * Mirrors the logic from monitor-agent.sh.
+ *
+ * @returns {'complete'|'idle'|'running'|'stable'}
+ */
+function checkCompletion(session, window, lastHash) {
+  const pane = capturePane(session, window, 200);
+  const tail = pane.split('\n').slice(-10).join('\n');
+
+  // P1: Completion message ("Baked for 31s", "Worked for 2m")
+  if (/[A-Z][a-z]*ed for \d+/.test(tail)) {
+    return { status: 'complete', hash: null };
+  }
+
+  // P2: ❯ prompt with no active spinner — might be idle
+  // (Less reliable than completion message but still useful)
+
+  // P3: Content stability
+  const hash = crypto.createHash('md5').update(pane).digest('hex');
+  if (hash === lastHash) {
+    return { status: 'stable', hash };
+  }
+
+  return { status: 'running', hash };
+}
+
+module.exports = {
+  hasSession,
+  killSession,
+  capturePane,
+  sendKeys,
+  sendKeysWithEnter,
+  newWindow,
+  waitForPrompt,
+  checkCompletion,
+};

package/lib/gateway/index.js

@@ -39,6 +39,15 @@ async function startGateway(opts = {}) {
     });
     adapters.push(telegram);
 
+    // Wire proactive messaging: orchestrator → Telegram
+    router.setSendCallback(null, async (chatId, text) => {
+      try {
+        await telegram.bot.api.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+      } catch {
+        await telegram.bot.api.sendMessage(chatId, text).catch(() => {});
+      }
+    });
+
     try {
       await telegram.start();
     } catch (err) {

package/lib/gateway/router.js

@@ -9,18 +9,31 @@ const { ChatHistory } = require('./history');
 const { OwnerBinding } = require('./binding');
 const engine = require('./engine/claude-sdk');
 const { runReflect } = require('./engine/reflect');
+const { PhaseOrchestrator } = require('./engine/phase-orchestrator');
 const { log } = require('./log');
 
 const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
 
+// ── Phase command patterns ─────────────────────────────────────────────────────
+
+const PHASE_COMMANDS = {
+  plan:    /^\*plan\b/i,
+  develop: /^\*develop\b/i,
+  test:    /^\*test\b/i,
+  deploy:  /^\*deploy\b/i,
+  cancel:  /^\*cancel\b/i,
+};
+
+const STATUS_PATTERNS = [
+  /^\*status\b/i,
+  /进度|状态|怎么样了|到哪了/,
+  /\bstatus\b|\bprogress\b/i,
+];
+
 /**
- * Message router with five-engine orchestration.
- * Each engine is triggered by code logic, not prompt compliance.
+ * Message router with five-engine orchestration + async phase execution.
  */
 class Router {
-  /**
-   * @param {object} config - Parsed channels.yaml config
-   */
   constructor(config) {
     this.config = config;
     this.history = new ChatHistory({
@@ -31,41 +44,85 @@ class Router {
       telegram: new OwnerBinding({ channelType: 'telegram' }),
       feishu: new OwnerBinding({ channelType: 'feishu' }),
     };
-    this.processing = new Set(); // prevent concurrent processing per chat
+    this.processing = new Set();
+    this._ownerChatId = null;
+    this._sendCallback = null;
+
+    // Phase orchestrator — runs long operations in background
+    this.orchestrator = new PhaseOrchestrator({
+      config: config.engine,
+      onProgress: (msg) => this._sendProactive(msg),
+      onComplete: (phase, summary) => this._sendProactive(summary),
+      onError: (phase, err) => this._sendProactive(`❌ Phase ${phase} error: ${err}`),
+    });
+  }
+
+  /**
+   * Set the callback for proactive Telegram messages.
+   * Called by index.js after the Telegram adapter starts.
+   */
+  setSendCallback(chatId, callback) {
+    this._ownerChatId = chatId;
+    this._sendCallback = callback;
+  }
+
+  _sendProactive(text) {
+    if (this._sendCallback && this._ownerChatId) {
+      this._sendCallback(this._ownerChatId, text).catch((err) => {
+        log.warn(`Proactive send failed: ${err.message}`);
+      });
+    }
   }
 
   /**
-   * Handle an incoming channel message. This is the main entry point.
-   * All five engines are orchestrated here via code.
-   *
-   * @param {object} msg - {channelType, channelUserId, chatId, text, userName}
-   * @returns {Promise<{text: string}>}
+   * Handle an incoming channel message.
    */
   async handleMessage(msg) {
     // ═══ AUTH ═══
     const binding = this.bindings[msg.channelType];
-    if (!binding) {
-      return { text: '❌ Unsupported channel type.' };
-    }
+    if (!binding) return { text: '❌ Unsupported channel type.' };
 
     const authResult = binding.check(msg.chatId);
-    if (!authResult.allowed) {
-      return { text: '🔒 Unauthorized. This bot is private.' };
-    }
+    if (!authResult.allowed) return { text: '🔒 Unauthorized. This bot is private.' };
 
     if (authResult.firstBind) {
       log.router(`First bind: ${msg.channelType} chat ${msg.chatId} (${msg.userName})`);
     }
 
-    // Handle /start command
+    // Store owner chatId for proactive messaging
+    if (!this._ownerChatId) {
+      this._ownerChatId = msg.chatId;
+    }
+
+    // Handle /start
     if (msg.text === '/start') {
       if (authResult.firstBind) {
-        return { text: `🚀 Welcome! You are now bound as the owner of this Yuri instance.\n\nSend me any message to interact with your projects.` };
+        return { text: '🚀 Welcome! You are now bound as the owner of this Yuri instance.\n\nSend me any message to interact with your projects.' };
+      }
+      return { text: '🚀 Yuri is ready. Send me any message to interact with your projects.' };
+    }
+
+    // ═══ STATUS QUERY — always allowed, even during processing ═══
+    if (this._isStatusQuery(msg.text)) {
+      return this._handleStatusQuery(msg);
+    }
+
+    // ═══ CANCEL — stop running phase ═══
+    if (PHASE_COMMANDS.cancel.test(msg.text.trim())) {
+      if (this.orchestrator.isRunning()) {
+        this.orchestrator.cancel();
+        return { text: '🛑 Phase cancelled.' };
       }
-      return { text: `🚀 Yuri is ready. Send me any message to interact with your projects.` };
+      return { text: 'No phase is running.' };
     }
 
-    // Prevent concurrent processing for same chat
+    // ═══ PHASE COMMANDS — delegate to orchestrator (non-blocking) ═══
+    const phaseCmd = this._detectPhaseCommand(msg.text);
+    if (phaseCmd) {
+      return this._handlePhaseCommand(phaseCmd, msg);
+    }
+
+    // ═══ NORMAL MESSAGE — goes through Claude ═══
     if (this.processing.has(msg.chatId)) {
       return { text: '⏳ Still processing your previous message. Please wait.' };
     }
@@ -78,22 +135,96 @@ class Router {
     }
   }
 
+  // ── Phase Command Handling ───────────────────────────────────────────────────
+
+  _detectPhaseCommand(text) {
+    const trimmed = text.trim();
+    for (const [phase, re] of Object.entries(PHASE_COMMANDS)) {
+      if (phase === 'cancel') continue; // handled separately
+      if (re.test(trimmed)) return phase;
+    }
+    return null;
+  }
+
+  _handlePhaseCommand(phase, msg) {
+    const projectRoot = engine.resolveProjectRoot();
+    if (!projectRoot) {
+      return { text: '❌ No active project found. Create one first with *create.' };
+    }
+
+    let response;
+    switch (phase) {
+      case 'plan':
+        response = this.orchestrator.startPlan(projectRoot);
+        break;
+      case 'develop':
+        response = this.orchestrator.startDevelop(projectRoot);
+        break;
+      case 'test':
+      case 'deploy':
+        // These phases are simpler — let Claude handle them normally
+        // (they don't have the 30-minute orchestration problem)
+        return this._processMessageDirect(msg);
+      default:
+        response = `Unknown phase: ${phase}`;
+    }
+
+    // Save to chat history
+    this.history.append(msg.chatId, 'user', msg.text);
+    this.history.append(msg.chatId, 'assistant', response.slice(0, 2000));
+    this._updateGlobalFocus(msg, projectRoot);
+
+    return { text: response };
+  }
+
+  // ── Status Query ─────────────────────────────────────────────────────────────
+
+  _isStatusQuery(text) {
+    return STATUS_PATTERNS.some((re) => re.test(text.trim()));
+  }
+
+  _handleStatusQuery(msg) {
+    const parts = [];
+
+    // Orchestrator status
+    if (this.orchestrator.isRunning()) {
+      const status = this.orchestrator.getStatus();
+      parts.push(status.message);
+    }
+
+    // Read project focus for additional context
+    const projectRoot = engine.resolveProjectRoot();
+    if (projectRoot) {
+      const focusPath = path.join(projectRoot, '.yuri', 'focus.yaml');
+      if (fs.existsSync(focusPath)) {
+        try {
+          const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+          if (focus.pulse) parts.push(`Pulse: ${focus.pulse}`);
+          if (focus.step) parts.push(`Step: ${focus.step}`);
+        } catch { /* ok */ }
+      }
+    }
+
+    if (parts.length === 0) {
+      parts.push('No active phase. Available commands: *create, *plan, *develop, *test, *deploy');
+    }
+
+    this.history.append(msg.chatId, 'user', msg.text);
+    const reply = parts.join('\n');
+    this.history.append(msg.chatId, 'assistant', reply);
+
+    return { text: reply };
+  }
+
+  // ── Normal Message Processing (via Claude) ───────────────────────────────────
+
   async _processMessage(msg) {
-    // ═══ ENGINE: Reflect (code-enforced) ═══
-    // Process any unprocessed inbox signals BEFORE the Claude call,
-    // so the updated memory is available in the system prompt.
     try { runReflect(); } catch (err) { log.warn(`Reflect failed: ${err.message}`); }
-
-    // ═══ ENGINE: Catch-up (code-enforced) ═══
     await this._runCatchUp();
 
-    // ═══ Resolve project context ═══
     const projectRoot = engine.resolveProjectRoot();
-
-    // ═══ Compose prompt ═══
     const prompt = engine.composePrompt(msg.text);
 
-    // ═══ WORK: Call Claude engine ═══
     log.router(`Processing: "${msg.text.slice(0, 80)}..." → cwd: ${projectRoot || '~'}`);
     const result = await engine.callClaude({
       prompt,
@@ -101,15 +232,9 @@ class Router {
       engineConfig: this.config.engine,
     });
 
-    // ═══ Save chat history ═══
     this.history.append(msg.chatId, 'user', msg.text);
     this.history.append(msg.chatId, 'assistant', result.reply.slice(0, 2000));
-
-    // ═══ ENGINE: Observe (code-enforced signal detection) ═══
-    // Detect signals from BOTH user message and Claude's response.
     this._detectSignals(msg, result.reply);
-
-    // ═══ ENGINE: Update Focus (code-enforced) ═══
     this._updateGlobalFocus(msg, projectRoot);
 
     log.router(`Reply: "${result.reply.slice(0, 80)}..."`);
@@ -117,8 +242,23 @@ class Router {
   }
 
   /**
-   * ENGINE: Catch-up — check if Yuri has been idle and needs to refresh state.
+   * Process a message through Claude without the processing guard.
+   * Used for phase commands that should be handled by Claude (test, deploy).
    */
+  async _processMessageDirect(msg) {
+    if (this.processing.has(msg.chatId)) {
+      return { text: '⏳ Still processing your previous message. Please wait.' };
+    }
+    this.processing.add(msg.chatId);
+    try {
+      return await this._processMessage(msg);
+    } finally {
+      this.processing.delete(msg.chatId);
+    }
+  }
+
+  // ── Catch-up ─────────────────────────────────────────────────────────────────
+
   async _runCatchUp() {
     const focusPath = path.join(YURI_GLOBAL, 'focus.yaml');
     if (!fs.existsSync(focusPath)) return;
@@ -127,17 +267,12 @@ class Router {
     if (!focus.updated_at) return;
 
     const gap = Date.now() - new Date(focus.updated_at).getTime();
-    const ONE_HOUR = 3600_000;
-
-    if (gap > ONE_HOUR) {
-      log.router(`Catch-up: ${Math.round(gap / 60000)}min since last active. Refreshing portfolio.`);
+    if (gap > 3600_000) {
+      log.router(`Catch-up: ${Math.round(gap / 60000)}min idle. Refreshing portfolio.`);
       this._refreshPortfolioPulse();
     }
   }
 
-  /**
-   * Refresh portfolio pulse by scanning active projects.
-   */
   _refreshPortfolioPulse() {
     const registryPath = path.join(YURI_GLOBAL, 'portfolio', 'registry.yaml');
     if (!fs.existsSync(registryPath)) return;
@@ -167,7 +302,7 @@ class Router {
     }
   }
 
-  // ── Signal Detection Patterns (word-boundary aware) ──
+  // ── Signal Detection ─────────────────────────────────────────────────────────
 
   static PRIORITY_PATTERNS = [
     /\b(focus\s+on|switch\s+to|prioritize)\b/i,
@@ -200,17 +335,11 @@ class Router {
     /你的角色|你提到/,
   ];
 
-  /**
-   * Detect signals from user message AND Claude's response.
-   * Uses word-boundary regex to avoid false positives.
-   */
   _detectSignals(msg, claudeReply) {
     const inboxPath = path.join(YURI_GLOBAL, 'inbox.jsonl');
     const signals = [];
-
     const text = msg.text;
 
-    // Detect from user message
     if (Router.PRIORITY_PATTERNS.some((re) => re.test(text))) {
       signals.push({ signal: 'priority_change', raw: text });
     }
@@ -221,10 +350,8 @@ class Router {
       signals.push({ signal: 'boss_identity', raw: text });
     }
 
-    // Detect from Claude's response (confirms Claude recognized a signal)
     if (claudeReply) {
       if (Router.RESPONSE_PREFERENCE_HINTS.some((re) => re.test(claudeReply))) {
-        // Only add if we didn't already detect from user message
         if (!signals.some((s) => s.signal === 'boss_preference')) {
           signals.push({ signal: 'boss_preference', raw: text });
         }
@@ -236,7 +363,6 @@ class Router {
       }
     }
 
-    // Write to inbox
     for (const sig of signals) {
       const entry = {
         ts: new Date().toISOString(),
@@ -253,9 +379,6 @@ class Router {
     }
   }
 
-  /**
-   * Update global focus after processing a message.
-   */
   _updateGlobalFocus(msg, projectRoot) {
     const focusPath = path.join(YURI_GLOBAL, 'focus.yaml');
     if (!fs.existsSync(focusPath)) return;
@@ -271,12 +394,11 @@ class Router {
   }
 
   /**
-   * Graceful shutdown — destroy persistent engine session if active.
+   * Graceful shutdown.
    */
   async shutdown() {
-    if (engine.destroySession) {
-      engine.destroySession();
-    }
+    this.orchestrator.shutdown();
+    if (engine.destroySession) engine.destroySession();
   }
 }
 

package/package.json

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

package/skill/resources/start-orchestrix.sh

@@ -303,7 +303,7 @@ for i in $(seq "$CC_STARTUP_WAIT" -1 1); do
     if [ $((i % 2)) -eq 0 ] && [ -z "$TRUST_HANDLED" ]; then
         for w in 0 1 2 3; do
             PANE=$(tmux capture-pane -t "$SESSION_NAME:$w" -p -S -10 2>/dev/null || true)
-            if echo "$PANE" | grep -qi "trust"; then
+            if echo "$PANE" | grep -qi "trust this folder\|safety check"; then
                 tmux send-keys -t "$SESSION_NAME:$w" Enter
                 echo ""
                 echo "   🔓 Auto-accepted trust dialog in window $w"

package/skill/scripts/ensure-session.sh

@@ -33,7 +33,7 @@ if [ "$TYPE" = "planning" ]; then
   for i in $(seq 1 6); do
     sleep 2
     PANE_TEXT=$(tmux capture-pane -t "$SESSION:0" -p -S -10 2>/dev/null || true)
-    if echo "$PANE_TEXT" | grep -qi "trust"; then
+    if echo "$PANE_TEXT" | grep -qi "trust this folder\|safety check"; then
       tmux send-keys -t "$SESSION:0" Enter
       sleep 2
       break