orchestrix-yuri 4.6.5 → 4.6.6

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

@@ -238,7 +238,8 @@ class PhaseOrchestrator {
     }
 
     if (this._phase === 'test') {
-      return { phase: 'test', message: '🧪 Testing in progress. QA running smoke tests.' };
+      const card = this._buildTestProgressCard();
+      return { phase: 'test', message: card };
     }
 
     if (this._phase === 'iterate') {
@@ -947,11 +948,14 @@ class PhaseOrchestrator {
 
     // Start first epic test
     this._loadAndTestEpic();
+    this._testStartedAt = Date.now();
+    this._lastReportTime = Date.now();
 
     const pollInterval = this.config.phase_poll_interval || 30000;
     this._timer = setInterval(() => this._pollTest(), pollInterval);
 
-    log.engine(`Test phase started: session=${this._session}, epics=${epicIds.join(',')}, startIdx=${startIdx}`);
+    const reportMin = Math.round(this._reportInterval / 60000);
+    log.engine(`Test phase started: session=${this._session}, epics=${epicIds.join(',')}, startIdx=${startIdx}, report every ${reportMin}min`);
     return `🧪 Testing started! ${epicIds.length} epic(s) to test.\n\nQA will smoke-test each epic. Failed tests auto-trigger Dev fixes (max 3 rounds).\nI'll notify you of results.`;
   }
 
@@ -1054,6 +1058,14 @@ class PhaseOrchestrator {
       return;
     }
 
+    // Periodic progress report (reuses dev phase's _reportInterval)
+    const now = Date.now();
+    if (now - this._lastReportTime >= this._reportInterval) {
+      this._lastReportTime = now;
+      const card = this._buildTestProgressCard();
+      this.onProgress(card);
+    }
+
     // Determine which window to watch
     const window = ctx.subPhase === 'dev-fixing' ? 2 : 3;
     const result = tmx.checkCompletion(this._session, window, this._lastHash);
@@ -1154,6 +1166,62 @@ class PhaseOrchestrator {
     }
   }
 
+  /**
+   * Build a progress card for the test phase (used by getStatus + periodic reports).
+   */
+  _buildTestProgressCard() {
+    const ctx = this._testContext;
+    if (!ctx) return '🧪 Testing in progress.';
+
+    const total = ctx.epicIds.length;
+    const passed = Object.values(ctx.results).filter((r) => r.status === 'passed').length;
+    const failed = Object.values(ctx.results).filter((r) => r.status === 'failed').length;
+    const tested = passed + failed;
+    const pct = total > 0 ? Math.round((tested / total) * 100) : 0;
+
+    const currentEpic = ctx.epicIds[ctx.epicIdx];
+    const subPhaseLabel = {
+      'qa-testing': '🔍 QA smoke-testing',
+      'dev-fixing': '🔧 Dev fixing bug',
+    }[ctx.subPhase] || '⏳ Loading agent';
+
+    const elapsed = this._devStartedAt ? this._formatDuration(Date.now() - this._devStartedAt) : '';
+    const startedAt = this._testStartedAt ? this._formatDuration(Date.now() - this._testStartedAt) : '';
+
+    const lines = [
+      `🧪 **Test Phase Progress**`,
+      ``,
+      this._progressBar(pct),
+      ``,
+      `📊 Epics: ${tested}/${total} tested (✅ ${passed} passed, ❌ ${failed} failed)`,
+    ];
+
+    if (ctx.epicIdx < total) {
+      lines.push(`🎯 Current: Epic ${currentEpic} — ${subPhaseLabel} (round ${ctx.round + 1}/${ctx.maxRounds})`);
+    }
+
+    // Per-epic summary
+    if (tested > 0) {
+      lines.push('', '📋 Results:');
+      for (const epicId of ctx.epicIds) {
+        const r = ctx.results[epicId];
+        if (r && r.status === 'passed') {
+          lines.push(`  ✅ Epic ${epicId} — passed (${r.rounds} round(s))`);
+        } else if (r && r.status === 'failed') {
+          lines.push(`  ❌ Epic ${epicId} — failed (${r.rounds} rounds)`);
+        } else if (epicId === currentEpic) {
+          lines.push(`  ⏳ Epic ${epicId} — in progress`);
+        } else {
+          lines.push(`  ⬜ Epic ${epicId} — pending`);
+        }
+      }
+    }
+
+    if (startedAt) lines.push(`\n⏱️ Elapsed: ${startedAt}`);
+
+    return lines.join('\n');
+  }
+
   /**
    * Complete test phase: aggregate results, update state files, send summary.
    */
@@ -1220,6 +1288,7 @@ class PhaseOrchestrator {
 
     this._phase = null;
     this._testContext = null;
+    this._testStartedAt = null;
     log.engine(`Test phase complete: ${passed}/${total} passed, ${failed} failed`);
     this.onComplete('test', lines.join('\n'));
   }

package/lib/gateway/router.js

@@ -99,25 +99,38 @@ class Router {
 
       try {
         const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
-        if (parseInt(focus.phase, 10) !== 3) return;
-
-        // Skip if dev phase already complete
-        const phase3Path = path.join(projectRoot, '.yuri', 'state', 'phase3.yaml');
-        if (fs.existsSync(phase3Path)) {
-          const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
-          if (phase3.status === 'complete') return;
-        }
+        const phaseNum = parseInt(focus.phase, 10);
+
+        if (phaseNum === 3) {
+          // Skip if dev phase already complete
+          const phase3Path = path.join(projectRoot, '.yuri', 'state', 'phase3.yaml');
+          if (fs.existsSync(phase3Path)) {
+            const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
+            if (phase3.status === 'complete') return;
+          }
 
-        // Check tmux session is alive
-        const { execSync } = require('child_process');
-        const sessions = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', { encoding: 'utf8' }).trim();
-        if (!sessions.split('\n').some((s) => s.startsWith('orchestrix-'))) return;
+          // Check tmux session is alive
+          const { execSync } = require('child_process');
+          const sessions = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', { encoding: 'utf8' }).trim();
+          if (!sessions.split('\n').some((s) => s.startsWith('orchestrix-'))) return;
 
-        // Generate and send progress card
-        const card = this._buildStatusCard(projectRoot, focus);
-        if (card) {
-          log.router('Auto-reporting dev progress');
-          this._sendProactive(card);
+          const card = this._buildStatusCard(projectRoot, focus);
+          if (card) {
+            log.router('Auto-reporting dev progress');
+            this._sendProactive(card);
+          }
+        } else if (phaseNum === 4) {
+          // Skip if test phase already complete
+          const phase4Path = path.join(projectRoot, '.yuri', 'state', 'phase4.yaml');
+          if (!fs.existsSync(phase4Path)) return;
+          const phase4 = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+          if (phase4.status === 'complete' || phase4.status === 'complete_with_failures') return;
+
+          const card = this._buildTestStatusCard(projectRoot);
+          if (card) {
+            log.router('Auto-reporting test progress');
+            this._sendProactive(card);
+          }
         }
       } catch { /* silent */ }
     }, interval);
@@ -407,6 +420,16 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
             }
           }
 
+          // Test phase: generate test progress card from phase4.yaml
+          if (phaseNum === 4 && parts.length === 0) {
+            try {
+              const card = this._buildTestStatusCard(projectRoot);
+              if (card) parts.push(card);
+            } catch (err) {
+              log.warn(`Test progress card failed: ${err.message}`);
+            }
+          }
+
           // Fallback or non-dev phase
           if (parts.length === 0) {
             if (focus.pulse) parts.push(`Pulse: ${focus.pulse}`);
@@ -824,6 +847,52 @@ Reply with ONLY one word: small, medium, or large. Nothing else.`;
     return lines.join('\n');
   }
 
+  // ── Test Progress Card (from phase4.yaml, for *status when orchestrator is not tracking) ──
+
+  _buildTestStatusCard(projectRoot) {
+    const phase4Path = path.join(projectRoot, '.yuri', 'state', 'phase4.yaml');
+    if (!fs.existsSync(phase4Path)) return null;
+
+    const state = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+    if (!Array.isArray(state.epics) || state.epics.length === 0) return null;
+
+    const total = state.epics.length;
+    const passed = state.epics.filter((e) => e.status === 'passed').length;
+    const failed = state.epics.filter((e) => e.status === 'failed').length;
+    const tested = passed + failed;
+    const pct = total > 0 ? Math.round((tested / total) * 100) : 0;
+
+    const barTotal = 20;
+    const filled = Math.round(pct / 100 * barTotal);
+    const bar = '▓'.repeat(filled) + '░'.repeat(barTotal - filled) + ` ${pct}%`;
+
+    const lines = [
+      '🧪 **Test Phase Progress**',
+      '',
+      bar,
+      '',
+      `📊 Epics: ${tested}/${total} tested (✅ ${passed} passed, ❌ ${failed} failed)`,
+      '',
+      '📋 Results:',
+    ];
+
+    for (const epic of state.epics) {
+      if (epic.status === 'passed') {
+        lines.push(`  ✅ Epic ${epic.id} — passed (${epic.rounds || 0} round(s))`);
+      } else if (epic.status === 'failed') {
+        lines.push(`  ❌ Epic ${epic.id} — failed (${epic.rounds || 0} rounds)`);
+      } else {
+        lines.push(`  ⬜ Epic ${epic.id} — ${epic.status || 'pending'}`);
+      }
+    }
+
+    if (state.status === 'complete' || state.status === 'complete_with_failures') {
+      lines.push(`\n✅ Testing finished at ${state.completed_at || 'unknown'}`);
+    }
+
+    return lines.join('\n');
+  }
+
   // ── Help ──────────────────────────────────────────────────────────────────────
 
   _buildHelpText() {

package/package.json

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