orchestrix-yuri 4.2.5 → 4.4.0

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

@@ -181,6 +181,20 @@ class PhaseOrchestrator {
       };
     }
 
+    if (this._phase === 'test') {
+      return { phase: 'test', message: '🧪 Testing in progress. QA running smoke tests.' };
+    }
+
+    if (this._phase === 'iterate') {
+      const ctx = this._changeContext || {};
+      return { phase: 'iterate', message: `🔄 Iteration in progress. Current: ${ctx.iteratePhase || 'starting'}` };
+    }
+
+    if (this._phase === 'change') {
+      const ctx = this._changeContext || {};
+      return { phase: 'change', message: `🔧 Change in progress (${ctx.scope || '?'}). Step ${this._step + 1}` };
+    }
+
     return { phase: this._phase, message: `Phase ${this._phase} is running.` };
   }
 
@@ -753,6 +767,367 @@ class PhaseOrchestrator {
     this.onComplete('develop', '🎉 Development complete! All stories finished.\n\nRun *test to start smoke testing.');
   }
 
+  // ── Test Phase ──────────────────────────────────────────────────────────────
+
+  /**
+   * Start test phase: QA smoke test per epic, auto fix-retest loop.
+   * Uses existing dev session's QA window (3) and Dev window (2).
+   */
+  startTest(projectRoot) {
+    if (this._phase) {
+      return `⚠️ Phase "${this._phase}" is already running. Use *status to check.`;
+    }
+
+    this._projectRoot = projectRoot;
+    this._phase = 'test';
+    this._step = 0;
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    // Ensure dev session exists (QA is window 3)
+    try {
+      const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+      const result = execSync(`bash "${scriptPath}" dev "${projectRoot}"`, {
+        encoding: 'utf8', timeout: 60000,
+      }).trim();
+      const lines = result.split('\n');
+      this._session = lines[lines.length - 1].trim();
+    } catch (err) {
+      this._phase = null;
+      return `❌ Failed to ensure dev session: ${err.message}`;
+    }
+
+    // Start QA smoke test on first epic
+    tmx.sendKeysWithEnter(this._session, 3, '/clear');
+    execSync('sleep 2');
+    tmx.sendKeysWithEnter(this._session, 3, '/o qa');
+    execSync('sleep 12');
+    tmx.sendKeysWithEnter(this._session, 3, '*smoke-test');
+
+    const pollInterval = this.config.phase_poll_interval || 30000;
+    this._timer = setInterval(() => this._pollTest(), pollInterval);
+
+    log.engine(`Test phase started: session=${this._session}`);
+    return '🧪 Testing started! QA is running smoke tests.\n\nI\'ll notify you of results. Failed tests will auto-trigger Dev fixes.';
+  }
+
+  _pollTest() {
+    if (this._phase !== 'test') return;
+
+    if (!tmx.hasSession(this._session)) {
+      this._handleError('test', 'tmux session died');
+      return;
+    }
+
+    const result = tmx.checkCompletion(this._session, 3, this._lastHash);
+    if (result.status === 'complete' || (result.status === 'stable' && ++this._stableCount >= 3)) {
+      this._stableCount = 0;
+      this._lastHash = '';
+      this._completeTest();
+      return;
+    }
+    if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
+    else { this._lastHash = result.hash; }
+  }
+
+  _completeTest() {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+    this._phase = null;
+    log.engine('Test phase complete');
+    this.onComplete('test', '🧪 Testing complete! Check QA results.\n\nRun *deploy when ready.');
+  }
+
+  // ── Iterate (New Iteration) ────────────────────────────────────────────────
+
+  /**
+   * Start a new iteration: PM generates next-steps, agents execute, SM starts dev.
+   * Flow: PM *start-iteration → parse HANDOFF → execute agents → SM *draft → dev auto
+   */
+  startIterate(projectRoot) {
+    if (this._phase) {
+      return `⚠️ Phase "${this._phase}" is already running. Use *status to check.`;
+    }
+
+    this._projectRoot = projectRoot;
+    this._phase = 'iterate';
+    this._step = 0;
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    // Step 1: Ensure planning session
+    try {
+      const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+      const result = execSync(`bash "${scriptPath}" planning "${projectRoot}"`, {
+        encoding: 'utf8', timeout: 60000,
+      }).trim();
+      const lines = result.split('\n');
+      this._session = lines[lines.length - 1].trim();
+    } catch (err) {
+      this._phase = null;
+      return `❌ Failed to create planning session: ${err.message}`;
+    }
+
+    // Start PM *start-iteration
+    tmx.sendKeysWithEnter(this._session, 0, '/o pm');
+    execSync('sleep 15');
+    tmx.sendKeysWithEnter(this._session, 0, '*start-iteration');
+
+    this._changeContext = { iteratePhase: 'pm' };
+    const pollInterval = this.config.phase_poll_interval || 30000;
+    this._timer = setInterval(() => this._pollIterate(), pollInterval);
+
+    log.engine(`Iterate started: session=${this._session}`);
+    return '🔄 New iteration started! PM is generating next-steps.\n\nAfter PM finishes, agents will execute in sequence, then dev automation resumes.';
+  }
+
+  _pollIterate() {
+    if (this._phase !== 'iterate') return;
+    if (this._waitingForInput) return;
+
+    const ctx = this._changeContext;
+    if (!ctx) return;
+
+    if (!tmx.hasSession(this._session)) {
+      this._handleError('iterate', 'tmux session died');
+      return;
+    }
+
+    const result = tmx.checkCompletion(this._session, 0, this._lastHash);
+    if (result.status === 'complete' || (result.status === 'stable' && ++this._stableCount >= 3)) {
+      this._stableCount = 0;
+      this._lastHash = '';
+      this._step++;
+
+      if (ctx.iteratePhase === 'pm') {
+        // PM done → send to Architect for review
+        this.onProgress('✅ PM generated next-steps. Sending to Architect...');
+        ctx.iteratePhase = 'architect';
+        tmx.sendKeysWithEnter(this._session, 0, '/clear');
+        execSync('sleep 2');
+        tmx.sendKeysWithEnter(this._session, 0, '/o architect');
+        execSync('sleep 15');
+        tmx.sendKeysWithEnter(this._session, 0, '*resolve-change');
+      } else if (ctx.iteratePhase === 'architect') {
+        // Architect done → transition to dev: SM *draft
+        this.onProgress('✅ Architect resolved. Starting dev automation via SM...');
+        try {
+          const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+          const devResult = execSync(`bash "${scriptPath}" dev "${this._projectRoot}"`, {
+            encoding: 'utf8', timeout: 120000,
+          }).trim();
+          const devLines = devResult.split('\n');
+          const devSession = devLines[devLines.length - 1].trim();
+
+          tmx.sendKeysWithEnter(devSession, 1, '/clear');
+          execSync('sleep 2');
+          tmx.sendKeysWithEnter(devSession, 1, '/o sm');
+          execSync('sleep 12');
+          tmx.sendKeysWithEnter(devSession, 1, '*draft');
+
+          this._completeIterate(devSession);
+        } catch (err) {
+          this._handleError('iterate', `Failed to start dev: ${err.message}`);
+        }
+      }
+      return;
+    }
+
+    if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
+    else { this._lastHash = result.hash; }
+  }
+
+  _completeIterate(devSession) {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+    // Kill planning session
+    if (this._session && tmx.hasSession(this._session)) {
+      tmx.killSession(this._session);
+    }
+    this._phase = null;
+    this._changeContext = null;
+    log.engine('Iterate complete — dev automation started');
+    this.onComplete('iterate', `🔄 New iteration launched!\n\nSM is drafting stories in dev session: ${devSession}\nAgents will chain automatically via handoff-detector.`);
+  }
+
+  // ── Change Management ───────────────────────────────────────────────────────
+
+  /**
+   * Execute a change request in background based on assessed scope.
+   *
+   * @param {string} projectRoot
+   * @param {'small'|'medium'|'large'} scope — assessed by Claude in step 1
+   * @param {string} description — the change description from user
+   * @returns {string} immediate status message
+   */
+  startChange(projectRoot, scope, description) {
+    if (this._phase) {
+      return `⚠️ Phase "${this._phase}" is already running. Finish it first or *cancel.`;
+    }
+
+    this._projectRoot = projectRoot;
+    this._phase = 'change';
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    log.engine(`Change management: scope=${scope}, desc="${description.slice(0, 60)}..."`);
+
+    try {
+      if (scope === 'small') {
+        return this._executeSmallChange(projectRoot, description);
+      } else if (scope === 'medium' || scope === 'large') {
+        return this._executeMediumChange(projectRoot, scope, description);
+      } else {
+        this._phase = null;
+        return `❌ Unknown scope: ${scope}. Expected small/medium/large.`;
+      }
+    } catch (err) {
+      this._phase = null;
+      return `❌ Change failed: ${err.message}`;
+    }
+  }
+
+  /**
+   * Small change: send *solo to Dev window in existing dev session.
+   */
+  _executeSmallChange(projectRoot, description) {
+    const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+    const result = execSync(`bash "${scriptPath}" dev "${projectRoot}"`, { encoding: 'utf8', timeout: 60000 }).trim();
+    const lines = result.split('\n');
+    this._session = lines[lines.length - 1].trim();
+
+    // Send to Dev window (window 2)
+    tmx.sendKeysWithEnter(this._session, 2, '/clear');
+    execSync('sleep 2');
+    tmx.sendKeysWithEnter(this._session, 2, '/o dev');
+    execSync('sleep 12');
+    tmx.sendKeysWithEnter(this._session, 2, `*solo "${description}"`);
+
+    // Poll for completion
+    const pollInterval = this.config.phase_poll_interval || 30000;
+    this._step = 0; // track which step we're on
+    this._changeContext = { scope: 'small', description };
+    this._timer = setInterval(() => this._pollChange(), pollInterval);
+
+    return `🔧 Small change started → Dev *solo\n\n"${description.slice(0, 100)}"\n\nI'll notify you when it's done.`;
+  }
+
+  /**
+   * Medium/Large change: PO route-change in planning session, then apply in dev session.
+   */
+  _executeMediumChange(projectRoot, scope, description) {
+    const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+
+    // Step 1: Ensure planning session
+    const planResult = execSync(`bash "${scriptPath}" planning "${projectRoot}"`, { encoding: 'utf8', timeout: 60000 }).trim();
+    const planLines = planResult.split('\n');
+    const planSession = planLines[planLines.length - 1].trim();
+
+    // Step 2: Activate PO and route change
+    tmx.sendKeysWithEnter(planSession, 0, '/o po');
+    execSync('sleep 15');
+    tmx.sendKeysWithEnter(planSession, 0, `*route-change "${description}"`);
+
+    // Poll for PO completion, then chain to next agent
+    const pollInterval = this.config.phase_poll_interval || 30000;
+    this._step = 0;
+    this._changeContext = {
+      scope,
+      description,
+      planSession,
+      // Steps: 0=PO route-change → 1=Architect/PM (based on PO output) → 2=SM apply-proposal
+    };
+    this._timer = setInterval(() => this._pollChange(), pollInterval);
+
+    return `🔧 ${scope === 'large' ? 'Large' : 'Medium'} change started → PO *route-change\n\n"${description.slice(0, 100)}"\n\nPO will assess and route to the right agent. I'll keep you updated.`;
+  }
+
+  /**
+   * Poll change management progress.
+   */
+  _pollChange() {
+    if (this._phase !== 'change') return;
+    if (this._waitingForInput) return;
+
+    const ctx = this._changeContext;
+    if (!ctx) return;
+
+    if (ctx.scope === 'small') {
+      // Polling Dev window for completion
+      if (!tmx.hasSession(this._session)) {
+        this._handleError('change', 'Dev tmux session died');
+        return;
+      }
+      const result = tmx.checkCompletion(this._session, 2, this._lastHash);
+      if (result.status === 'complete' || (result.status === 'stable' && ++this._stableCount >= 3)) {
+        this._completeChange('Dev completed the change.');
+        return;
+      }
+      if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
+      else { this._lastHash = result.hash; }
+      return;
+    }
+
+    // Medium/Large: multi-step
+    if (!tmx.hasSession(ctx.planSession)) {
+      this._handleError('change', 'Planning tmux session died');
+      return;
+    }
+
+    const result = tmx.checkCompletion(ctx.planSession, 0, this._lastHash);
+
+    if (result.status === 'complete' || (result.status === 'stable' && ++this._stableCount >= 3)) {
+      this._stableCount = 0;
+      this._lastHash = '';
+      this._step++;
+
+      if (this._step === 1) {
+        // PO finished routing. Now send to Architect for *resolve-change
+        this.onProgress('✅ PO routing complete. Sending to Architect...');
+        tmx.sendKeysWithEnter(ctx.planSession, 0, '/clear');
+        execSync('sleep 2');
+        tmx.sendKeysWithEnter(ctx.planSession, 0, '/o architect');
+        execSync('sleep 15');
+        tmx.sendKeysWithEnter(ctx.planSession, 0, '*resolve-change');
+      } else if (this._step === 2) {
+        // Architect finished. Apply in dev session via SM
+        this.onProgress('✅ Architect resolved. Applying change via SM...');
+        try {
+          const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
+          const devResult = execSync(`bash "${scriptPath}" dev "${this._projectRoot}"`, { encoding: 'utf8', timeout: 60000 }).trim();
+          const devLines = devResult.split('\n');
+          this._session = devLines[devLines.length - 1].trim();
+
+          tmx.sendKeysWithEnter(this._session, 1, '/clear');
+          execSync('sleep 2');
+          tmx.sendKeysWithEnter(this._session, 1, '/o sm');
+          execSync('sleep 12');
+          tmx.sendKeysWithEnter(this._session, 1, '*draft');
+
+          // Now poll dev session SM window
+          this._changeContext._pollDevSM = true;
+        } catch (err) {
+          this._handleError('change', `Failed to apply in dev session: ${err.message}`);
+        }
+      } else if (this._step >= 3) {
+        this._completeChange('Change applied. SM started new stories from the change.');
+      }
+      return;
+    }
+
+    if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
+    else { this._lastHash = result.hash; }
+  }
+
+  _completeChange(summary) {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    this._phase = null;
+    this._changeContext = null;
+    log.engine(`Change management complete: ${summary}`);
+    this.onComplete('change', `✅ Change management complete.\n\n${summary}`);
+  }
+
   // ── Shared ─────────────────────────────────────────────────────────────────
 
   _handleError(phase, message) {

package/lib/gateway/router.js

@@ -17,14 +17,17 @@ 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,
+  plan:     /^\*plan\b/i,
+  develop:  /^\*develop\b/i,
+  test:     /^\*test\b/i,
+  change:   /^\*change\s+(.+)/i,
+  iterate:  /^\*iterate\b/i,
+  deploy:   /^\*deploy\b/i,
+  cancel:   /^\*cancel\b/i,
 };
 
 const META_COMMANDS = {
+  help:     /^\*help\b/i,
   projects: /^\*projects\b/i,
   switch:   /^\*switch\s+(.+)/i,
 };
@@ -207,7 +210,10 @@ class Router {
       return this._handleStatusQuery(msg);
     }
 
-    // ═══ META COMMANDS — *projects, *switch (always allowed) ═══
+    // ═══ META COMMANDS — *help, *projects, *switch (always allowed) ═══
+    if (META_COMMANDS.help.test(msg.text.trim())) {
+      return { text: this._buildHelpText() };
+    }
     if (META_COMMANDS.projects.test(msg.text.trim())) {
       return this._handleProjects(msg);
     }
@@ -266,7 +272,7 @@ class Router {
     return null;
   }
 
-  _handlePhaseCommand(phase, msg) {
+  async _handlePhaseCommand(phase, msg) {
     const projectRoot = engine.resolveProjectRoot();
     if (!projectRoot) {
       return { text: '❌ No active project found. Create one first with *create.' };
@@ -281,15 +287,19 @@ class Router {
         response = this.orchestrator.startDevelop(projectRoot);
         break;
       case 'test':
+        response = this.orchestrator.startTest(projectRoot);
+        break;
+      case 'change':
+        return this._handleChangeCommand(msg, projectRoot);
+      case 'iterate':
+        response = this.orchestrator.startIterate(projectRoot);
+        break;
       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);
@@ -297,6 +307,56 @@ class Router {
     return { text: response };
   }
 
+  /**
+   * Handle *change command in two steps:
+   * Step 1: Claude assesses the scope (small/medium/large) — quick claude -p call
+   * Step 2: Orchestrator executes the change in tmux background
+   */
+  async _handleChangeCommand(msg, projectRoot) {
+    // Extract description from "*change description here"
+    const match = msg.text.trim().match(/^\*change\s+(.+)/i);
+    const description = match ? match[1].replace(/^["']|["']$/g, '') : '';
+
+    if (!description) {
+      return { text: '❌ Usage: *change "description of the change"\n\nExample: *change "Add dark mode toggle to settings page"' };
+    }
+
+    // Step 1: Ask Claude to assess scope
+    this.history.append(msg.chatId, 'user', msg.text);
+    log.router(`Change request: "${description.slice(0, 80)}..." — assessing scope...`);
+
+    const scopePrompt = `You are assessing a change request for a software project.
+
+Change description: "${description}"
+
+Based on the description, classify the scope as one of:
+- **small**: ≤5 files affected, no architectural changes, no new dependencies (e.g., UI tweak, bug fix, small feature)
+- **medium**: Cross-component change, needs PO routing and possibly architect review (e.g., new API endpoint, refactoring a module)
+- **large**: Cross-module/database/security change, needs full re-planning (e.g., auth system rewrite, new microservice)
+
+Reply with ONLY one word: small, medium, or large. Nothing else.`;
+
+    const scopeResult = await engine.callClaude({
+      prompt: scopePrompt,
+      cwd: projectRoot,
+      engineConfig: this.config.engine,
+      timeout: 30000, // quick assessment
+    });
+
+    const scopeRaw = (scopeResult.reply || '').trim().toLowerCase();
+    const scope = ['small', 'medium', 'large'].find((s) => scopeRaw.includes(s)) || 'medium';
+
+    log.router(`Change scope assessed: ${scope}`);
+
+    // Step 2: Execute via orchestrator
+    const response = this.orchestrator.startChange(projectRoot, scope, description);
+
+    this.history.append(msg.chatId, 'assistant', response.slice(0, 2000));
+    this._updateGlobalFocus(msg, projectRoot);
+
+    return { text: `📋 Scope: **${scope}**\n\n${response}` };
+  }
+
   // ── Status Query ─────────────────────────────────────────────────────────────
 
   _isStatusQuery(text) {
@@ -749,6 +809,46 @@ class Router {
     return lines.join('\n');
   }
 
+  // ── Help ──────────────────────────────────────────────────────────────────────
+
+  _buildHelpText() {
+    return `🚀 **Yuri — Meta-Orchestrator**
+
+**Project Lifecycle**
+| Command | Description |
+|---------|-------------|
+| \`*create\` | Create a new project (interactive Q&A) |
+| \`*plan\` | Start planning phase (6 agents sequentially, background) |
+| \`*develop\` | Start development phase (4 agents with HANDOFF, background) |
+| \`*test\` | Start smoke testing (QA per epic, auto fix-retest) |
+| \`*deploy\` | Deploy the project |
+
+**Change & Iteration**
+| Command | Description |
+|---------|-------------|
+| \`*change "desc"\` | Handle a requirement change (auto scope assessment) |
+| \`*iterate\` | Start new iteration (PM → agents → dev automation) |
+
+**Monitoring**
+| Command | Description |
+|---------|-------------|
+| \`*status\` | Show progress card (epic/story/agent/cost) |
+| \`*cancel\` | Stop the running phase |
+| \`*resume\` | Resume from last checkpoint |
+
+**Portfolio**
+| Command | Description |
+|---------|-------------|
+| \`*projects\` | List all registered projects |
+| \`*switch <name>\` | Switch active project |
+| \`*help\` | Show this help |
+
+**Notes**
+- \`*plan\`, \`*develop\`, \`*test\`, \`*change\`, \`*iterate\` run in background — you can chat normally while they execute
+- Progress is reported every 30 minutes automatically
+- Reply to agent question messages to answer them directly`;
+  }
+
   _updateGlobalFocus(msg, projectRoot) {
     const focusPath = path.join(YURI_GLOBAL, 'focus.yaml');
     if (!fs.existsSync(focusPath)) return;

package/package.json

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