orchestrix-yuri 4.6.3 → 4.6.5

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

@@ -38,7 +38,7 @@ class PhaseOrchestrator {
     this.onError = opts.onError || (() => {});
     this.config = opts.config || {};
 
-    this._phase = null;       // 'plan' | 'develop' | null
+    this._phase = null;       // 'plan' | 'develop' | 'test' | 'iterate' | 'change' | null
     this._step = 0;           // current agent index
     this._session = null;     // tmux session name
     this._projectRoot = null;
@@ -117,6 +117,62 @@ class PhaseOrchestrator {
         }
       }
     }
+
+    // Check phase4 (test)
+    const phase4Path = path.join(projectRoot, '.yuri', 'state', 'phase4.yaml');
+    if (fs.existsSync(phase4Path)) {
+      const phase4 = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+      if (phase4.status === 'in_progress' && Array.isArray(phase4.epics)) {
+        // Find a live orchestrix tmux session
+        let session = null;
+        try {
+          const sessions = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', { encoding: 'utf8' }).trim();
+          session = sessions.split('\n').find((s) => s.startsWith('orchestrix-'));
+        } catch { /* no sessions */ }
+
+        if (session && tmx.hasSession(session)) {
+          const epicIds = phase4.epics.map((e) => String(e.id));
+          const firstPending = epicIds.findIndex((id) => {
+            const e = phase4.epics.find((ep) => String(ep.id) === id);
+            return !e || (e.status !== 'passed' && e.status !== 'failed');
+          });
+
+          if (firstPending >= 0) {
+            this._phase = 'test';
+            this._projectRoot = projectRoot;
+            this._session = session;
+            this._lastHash = '';
+            this._stableCount = 0;
+            this._testBusy = false;
+
+            // Rebuild results from already-tested epics
+            const results = {};
+            for (const e of phase4.epics) {
+              if (e.status === 'passed' || e.status === 'failed') {
+                results[e.id] = { status: e.status, rounds: e.rounds || 0 };
+              }
+            }
+
+            this._testContext = {
+              epicIds,
+              epicIdx: firstPending,
+              round: 0,
+              maxRounds: 3,
+              subPhase: null,
+              results,
+            };
+
+            this._loadAndTestEpic();
+
+            const pollInterval = this.config.phase_poll_interval || 30000;
+            this._timer = setInterval(() => this._pollTest(), pollInterval);
+
+            log.engine(`Recovered test phase: session=${session}, resuming at epic idx ${firstPending}`);
+            return;
+          }
+        }
+      }
+    }
   }
 
   /**
@@ -763,6 +819,29 @@ class PhaseOrchestrator {
     }
 
     this._phase = null;
+
+    // Update state files so auto-reporter stops
+    try {
+      const phase3Path = path.join(this._projectRoot, '.yuri', 'state', 'phase3.yaml');
+      if (fs.existsSync(phase3Path)) {
+        const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
+        phase3.status = 'complete';
+        phase3.completed_at = new Date().toISOString();
+        fs.writeFileSync(phase3Path, yaml.dump(phase3, { lineWidth: -1 }));
+      }
+
+      const focusPath = path.join(this._projectRoot, '.yuri', 'focus.yaml');
+      if (fs.existsSync(focusPath)) {
+        const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+        focus.step = 'phase3.complete';
+        focus.pulse = 'Phase 3 complete, all stories done';
+        focus.updated_at = new Date().toISOString();
+        fs.writeFileSync(focusPath, yaml.dump(focus, { lineWidth: -1 }));
+      }
+    } catch (err) {
+      log.warn(`Failed to update state files on dev complete: ${err.message}`);
+    }
+
     log.engine('Dev phase complete');
     this.onComplete('develop', '🎉 Development complete! All stories finished.\n\nRun *test to start smoke testing.');
   }
@@ -772,6 +851,8 @@ class PhaseOrchestrator {
   /**
    * Start test phase: QA smoke test per epic, auto fix-retest loop.
    * Uses existing dev session's QA window (3) and Dev window (2).
+   *
+   * State machine subPhases: qa-loading → qa-testing → (on fail) dev-loading → dev-fixing → qa-loading ...
    */
   startTest(projectRoot) {
     if (this._phase) {
@@ -780,11 +861,11 @@ class PhaseOrchestrator {
 
     this._projectRoot = projectRoot;
     this._phase = 'test';
-    this._step = 0;
     this._lastHash = '';
     this._stableCount = 0;
+    this._testBusy = false;
 
-    // Ensure dev session exists (QA is window 3)
+    // Ensure dev session exists (QA is window 3, Dev is window 2)
     try {
       const scriptPath = path.join(SKILL_DIR, 'scripts', 'ensure-session.sh');
       const result = execSync(`bash "${scriptPath}" dev "${projectRoot}"`, {
@@ -797,44 +878,350 @@ class PhaseOrchestrator {
       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');
+    // Collect epic list from PRD files
+    const prdDir = path.join(projectRoot, 'docs', 'prd');
+    let epicIds = [];
+    try {
+      if (fs.existsSync(prdDir)) {
+        epicIds = fs.readdirSync(prdDir)
+          .filter((f) => /^epic-\d+/.test(f) && f.endsWith('.yaml'))
+          .map((f) => f.replace(/^epic-/, '').replace(/\.yaml$/, ''))
+          .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+      }
+    } catch { /* ignore */ }
+
+    if (epicIds.length === 0) {
+      this._phase = null;
+      return '❌ No epic files found in docs/prd/. Nothing to test.';
+    }
+
+    // Initialize or resume phase4.yaml state
+    const phase4Path = path.join(projectRoot, '.yuri', 'state', 'phase4.yaml');
+    let startIdx = 0;
+    try {
+      if (fs.existsSync(phase4Path)) {
+        const existing = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+        if (existing.status === 'in_progress' && Array.isArray(existing.epics)) {
+          // Resume: find first non-passed epic
+          const idx = epicIds.findIndex((id) => {
+            const e = existing.epics.find((ep) => String(ep.id) === String(id));
+            return !e || e.status !== 'passed';
+          });
+          if (idx >= 0) startIdx = idx;
+        }
+      }
+
+      // Write initial state
+      const epicsState = epicIds.map((id, i) => ({
+        id, status: i < startIdx ? 'passed' : 'pending', rounds: 0, last_tested_at: '',
+      }));
+      const state = { status: 'in_progress', started_at: new Date().toISOString(), completed_at: '', epics: epicsState, regression_rounds: 0 };
+      fs.writeFileSync(phase4Path, yaml.dump(state, { lineWidth: -1 }));
+    } catch (err) {
+      log.warn(`Failed to init phase4.yaml: ${err.message}`);
+    }
+
+    // Update focus.yaml
+    try {
+      const focusPath = path.join(projectRoot, '.yuri', 'focus.yaml');
+      if (fs.existsSync(focusPath)) {
+        const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+        focus.phase = 4;
+        focus.step = 'testing';
+        focus.action = 'starting smoke tests';
+        focus.pulse = `Phase 4: testing 0/${epicIds.length} epics`;
+        focus.updated_at = new Date().toISOString();
+        fs.writeFileSync(focusPath, yaml.dump(focus, { lineWidth: -1 }));
+      }
+    } catch { /* ignore */ }
+
+    // Initialize test context
+    this._testContext = {
+      epicIds,
+      epicIdx: startIdx,
+      round: 0,
+      maxRounds: 3,
+      subPhase: null, // set by _loadAndTestEpic
+      results: {},
+    };
+
+    // Start first epic test
+    this._loadAndTestEpic();
 
     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.';
+    log.engine(`Test phase started: session=${this._session}, epics=${epicIds.join(',')}, startIdx=${startIdx}`);
+    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.`;
   }
 
+  /**
+   * Reload QA agent and send *smoke-test for current epic.
+   */
+  _loadAndTestEpic() {
+    const ctx = this._testContext;
+    const epicId = ctx.epicIds[ctx.epicIdx];
+
+    this._testBusy = true;
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    try {
+      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 ${epicId}`);
+    } catch (err) {
+      this._testBusy = false;
+      this._handleError('test', `Failed to start QA for epic ${epicId}: ${err.message}`);
+      return;
+    }
+
+    ctx.subPhase = 'qa-testing';
+    this._testBusy = false;
+    log.engine(`QA testing epic ${epicId} (round ${ctx.round + 1}/${ctx.maxRounds})`);
+  }
+
+  /**
+   * Reload Dev agent and send *quick-fix for the detected bug.
+   */
+  _loadAndFixEpic(bugDesc) {
+    this._testBusy = true;
+    this._lastHash = '';
+    this._stableCount = 0;
+
+    try {
+      tmx.sendKeysWithEnter(this._session, 2, '/clear');
+      execSync('sleep 2');
+      tmx.sendKeysWithEnter(this._session, 2, '/o dev');
+      execSync('sleep 12');
+
+      // Escape quotes in bug description
+      const safeBug = (bugDesc || 'smoke test failure').replace(/"/g, '\\"');
+      tmx.sendKeysWithEnter(this._session, 2, `*quick-fix "${safeBug}"`);
+    } catch (err) {
+      this._testBusy = false;
+      this._handleError('test', `Failed to start Dev fix: ${err.message}`);
+      return;
+    }
+
+    this._testContext.subPhase = 'dev-fixing';
+    this._testBusy = false;
+    log.engine(`Dev fixing: ${bugDesc}`);
+  }
+
+  /**
+   * Capture QA pane output and determine PASS/FAIL.
+   */
+  _evaluateTestResult() {
+    const output = tmx.capturePane(this._session, 3, 200);
+    const lines = output.split('\n');
+    const tail = lines.slice(-50).join('\n');
+
+    // PASS indicators
+    if (/all\s+tests?\s+passed/i.test(tail) || /✅.*pass/i.test(tail) || /smoke.*pass/i.test(tail) || /PASS/i.test(tail)) {
+      return { passed: true, bugDesc: null };
+    }
+
+    // FAIL: extract bug description near failure markers
+    let bugDesc = 'smoke test failure';
+    for (let i = lines.length - 1; i >= Math.max(0, lines.length - 50); i--) {
+      if (/fail|❌|error|FAIL/i.test(lines[i])) {
+        // Take up to 3 lines around the failure for context
+        const start = Math.max(0, i - 1);
+        const end = Math.min(lines.length, i + 2);
+        bugDesc = lines.slice(start, end).join(' ').trim().substring(0, 200);
+        break;
+      }
+    }
+
+    return { passed: false, bugDesc };
+  }
+
+  /**
+   * State machine poll for test phase.
+   */
   _pollTest() {
     if (this._phase !== 'test') return;
+    if (this._testBusy) return;
+
+    const ctx = this._testContext;
+    if (!ctx) 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 = '';
+    // Determine which window to watch
+    const window = ctx.subPhase === 'dev-fixing' ? 2 : 3;
+    const result = tmx.checkCompletion(this._session, window, this._lastHash);
+
+    // Not done yet
+    if (result.status !== 'complete' && !(result.status === 'stable' && ++this._stableCount >= 3)) {
+      if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
+      else { this._lastHash = result.hash; }
+      return;
+    }
+
+    // Agent finished — reset counters
+    this._stableCount = 0;
+    this._lastHash = '';
+
+    const epicId = ctx.epicIds[ctx.epicIdx];
+
+    if (ctx.subPhase === 'qa-testing') {
+      const testResult = this._evaluateTestResult();
+
+      if (testResult.passed) {
+        ctx.results[epicId] = { status: 'passed', rounds: ctx.round + 1 };
+        this._updateTestState(epicId, 'passed', ctx.round + 1);
+        this.onProgress(`✅ Epic ${epicId} passed (${ctx.round + 1} round(s))`);
+        log.engine(`Epic ${epicId} PASSED after ${ctx.round + 1} round(s)`);
+        this._advanceToNextEpic();
+      } else if (ctx.round + 1 >= ctx.maxRounds) {
+        ctx.results[epicId] = { status: 'failed', rounds: ctx.round + 1 };
+        this._updateTestState(epicId, 'failed', ctx.round + 1);
+        this.onProgress(`❌ Epic ${epicId} failed after ${ctx.round + 1} rounds.\nLast error: ${testResult.bugDesc}`);
+        log.engine(`Epic ${epicId} FAILED after ${ctx.round + 1} rounds`);
+        this._advanceToNextEpic();
+      } else {
+        ctx.round++;
+        this.onProgress(`���️ Epic ${epicId} failed (round ${ctx.round}/${ctx.maxRounds}). Sending to Dev for fix...`);
+        log.engine(`Epic ${epicId} failed round ${ctx.round}, sending to Dev`);
+        this._loadAndFixEpic(testResult.bugDesc);
+      }
+    } else if (ctx.subPhase === 'dev-fixing') {
+      this.onProgress(`🔧 Dev fix done for epic ${epicId}. Retesting...`);
+      log.engine(`Dev fix done for epic ${epicId}, retesting`);
+      this._loadAndTestEpic();
+    }
+  }
+
+  /**
+   * Advance to next epic or complete test phase.
+   */
+  _advanceToNextEpic() {
+    const ctx = this._testContext;
+    ctx.epicIdx++;
+    ctx.round = 0;
+
+    const tested = ctx.epicIdx;
+    const total = ctx.epicIds.length;
+
+    // Update focus pulse
+    try {
+      const focusPath = path.join(this._projectRoot, '.yuri', 'focus.yaml');
+      if (fs.existsSync(focusPath)) {
+        const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+        focus.pulse = `Phase 4: ${tested}/${total} epics tested`;
+        focus.updated_at = new Date().toISOString();
+        fs.writeFileSync(focusPath, yaml.dump(focus, { lineWidth: -1 }));
+      }
+    } catch { /* ignore */ }
+
+    if (ctx.epicIdx >= ctx.epicIds.length) {
       this._completeTest();
       return;
     }
-    if (result.status !== 'stable') { this._stableCount = 0; this._lastHash = result.hash || ''; }
-    else { this._lastHash = result.hash; }
+
+    // Start next epic
+    this._loadAndTestEpic();
   }
 
+  /**
+   * Update a single epic's status in phase4.yaml.
+   */
+  _updateTestState(epicId, status, rounds) {
+    try {
+      const phase4Path = path.join(this._projectRoot, '.yuri', 'state', 'phase4.yaml');
+      if (!fs.existsSync(phase4Path)) return;
+
+      const state = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+      if (!Array.isArray(state.epics)) return;
+
+      const epic = state.epics.find((e) => String(e.id) === String(epicId));
+      if (epic) {
+        epic.status = status;
+        epic.rounds = rounds;
+        epic.last_tested_at = new Date().toISOString();
+      }
+      state.regression_rounds = (state.regression_rounds || 0) + rounds;
+      fs.writeFileSync(phase4Path, yaml.dump(state, { lineWidth: -1 }));
+    } catch (err) {
+      log.warn(`Failed to update phase4.yaml for epic ${epicId}: ${err.message}`);
+    }
+  }
+
+  /**
+   * Complete test phase: aggregate results, update state files, send summary.
+   */
   _completeTest() {
     if (this._timer) { clearInterval(this._timer); this._timer = null; }
+
+    const ctx = this._testContext;
+    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 total = ctx.epicIds.length;
+
+    // Update phase4.yaml
+    try {
+      const phase4Path = path.join(this._projectRoot, '.yuri', 'state', 'phase4.yaml');
+      if (fs.existsSync(phase4Path)) {
+        const state = yaml.load(fs.readFileSync(phase4Path, 'utf8')) || {};
+        state.status = failed > 0 ? 'complete_with_failures' : 'complete';
+        state.completed_at = new Date().toISOString();
+        fs.writeFileSync(phase4Path, yaml.dump(state, { lineWidth: -1 }));
+      }
+    } catch (err) {
+      log.warn(`Failed to finalize phase4.yaml: ${err.message}`);
+    }
+
+    // Update focus.yaml
+    try {
+      const focusPath = path.join(this._projectRoot, '.yuri', 'focus.yaml');
+      if (fs.existsSync(focusPath)) {
+        const focus = yaml.load(fs.readFileSync(focusPath, 'utf8')) || {};
+        focus.step = 'phase4.complete';
+        focus.pulse = `Phase 4 complete: ${passed}/${total} passed`;
+        focus.updated_at = new Date().toISOString();
+        fs.writeFileSync(focusPath, yaml.dump(focus, { lineWidth: -1 }));
+      }
+    } catch { /* ignore */ }
+
+    // Append timeline event
+    try {
+      const timelinePath = path.join(this._projectRoot, '.yuri', 'timeline', 'events.jsonl');
+      const dir = path.dirname(timelinePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      const event = JSON.stringify({ ts: new Date().toISOString(), type: 'phase_completed', phase: 4, passed, failed, total });
+      fs.appendFileSync(timelinePath, event + '\n');
+    } catch { /* ignore */ }
+
+    // Build summary
+    const lines = [`🧪 Testing complete! ${passed}/${total} epics passed.\n`];
+    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 after ${r.rounds} rounds`);
+      } else {
+        lines.push(`  ⏭️ Epic ${epicId} — skipped`);
+      }
+    }
+
+    if (failed === 0) {
+      lines.push('\n🚀 All tests passed! Run *deploy when ready.');
+    } else {
+      lines.push(`\n⚠️ ${failed} epic(s) failed. Review and fix manually, or run *test again.`);
+    }
+
     this._phase = null;
-    log.engine('Test phase complete');
-    this.onComplete('test', '🧪 Testing complete! Check QA results.\n\nRun *deploy when ready.');
+    this._testContext = null;
+    log.engine(`Test phase complete: ${passed}/${total} passed, ${failed} failed`);
+    this.onComplete('test', lines.join('\n'));
   }
 
   // ── Iterate (New Iteration) ────────────────────────────────────────────────

package/lib/gateway/router.js

@@ -101,6 +101,13 @@ class Router {
         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;
+        }
+
         // 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();

package/package.json

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

package/skill/scripts/scan-stories.sh

@@ -55,9 +55,9 @@ for f in "$STORIES_DIR"/*.md; do
   # Try heading format: "## Status" then next non-empty line
   status=$(awk '/^## Status/{found=1; next} found && /^[[:space:]]*$/{next} found{print; exit}' "$f" 2>/dev/null)
 
-  # Fallback: inline "Status: XXX"
+  # Fallback: inline "status: Done" or "Status: Done" (case-insensitive)
   if [ -z "$status" ]; then
-    status=$(grep -m1 -oE 'Status:\s*\S+' "$f" 2>/dev/null | sed 's/Status:\s*//')
+    status=$(grep -m1 -oiE 'status:\s*\S+' "$f" 2>/dev/null | sed 's/[Ss]tatus:\s*//')
   fi
 
   # Normalize to lowercase, strip whitespace