orchestrix-yuri 4.0.6 → 4.1.0

package/lib/gateway/channels/feishu.js

@@ -42,7 +42,7 @@ class FeishuAdapter {
       appId: this.appId,
       appSecret: this.appSecret,
       domain: lark.Domain.Feishu,
-      loggerLevel: lark.LoggerLevel.WARN,
+      loggerLevel: lark.LoggerLevel.ERROR,
     });
 
     await this.wsClient.start({ eventDispatcher: dispatcher });

package/lib/gateway/config.js

@@ -24,6 +24,7 @@ const DEFAULTS = {
     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
+    report_interval: 1800000,     // dev phase: progress report every 30 min
   },
 };
 

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

@@ -50,6 +50,11 @@ class PhaseOrchestrator {
     this._waitingForInput = false;     // true when agent asked a question
     this._waitingMessageId = null;     // Telegram message_id of the question notification
     this._onQuestionAsked = opts.onQuestionAsked || (() => Promise.resolve(null));
+
+    // Dev phase progress reporting
+    this._devStartedAt = null;         // timestamp when dev phase started
+    this._lastReportTime = 0;          // last progress report timestamp
+    this._reportInterval = (opts.config && opts.config.report_interval) || 1800000; // 30 min default
     // onQuestionAsked(text) → sends to Telegram, returns { messageId }
   }
 
@@ -101,6 +106,8 @@ class PhaseOrchestrator {
           this._phase = 'develop';
           this._projectRoot = projectRoot;
           this._session = phase3.tmux.session;
+          this._devStartedAt = phase3.started_at ? new Date(phase3.started_at).getTime() : Date.now();
+          this._lastReportTime = Date.now(); // don't send report immediately on recover
 
           const pollInterval = this.config.dev_poll_interval || 300000;
           this._timer = setInterval(() => this._pollDevSession(), pollInterval);
@@ -166,9 +173,11 @@ class PhaseOrchestrator {
     }
 
     if (this._phase === 'develop') {
+      const progress = this._gatherDevProgress();
+      const card = this._buildProgressCard(progress);
       return {
         phase: 'develop',
-        message: '💻 Development in progress. Agents running autonomously.',
+        message: card,
       };
     }
 
@@ -548,9 +557,12 @@ class PhaseOrchestrator {
     // 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);
+    this._devStartedAt = Date.now();
+    this._lastReportTime = Date.now();
 
-    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.';
+    const reportMin = Math.round(this._reportInterval / 60000);
+    log.engine(`Dev phase started: session=${this._session}, report every ${reportMin}min`);
+    return `🚀 Development started! 4 agents (Architect, SM, Dev, QA) are running.\n\nAgents chain automatically via handoff-detector. I'll send a progress report every ${reportMin} minutes.`;
   }
 
   _pollDevSession() {
@@ -561,25 +573,168 @@ class PhaseOrchestrator {
       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)) {
+    // Gather progress data
+    const progress = this._gatherDevProgress();
+
+    // Check if all stories done
+    if (progress.totalStories > 0 && progress.doneStories >= progress.totalStories) {
+      this._completeDev();
+      return;
+    }
+
+    // Periodic progress report
+    const now = Date.now();
+    if (now - this._lastReportTime >= this._reportInterval) {
+      this._lastReportTime = now;
+      const card = this._buildProgressCard(progress);
+      this.onProgress(card);
+    }
+  }
+
+  /**
+   * Gather dev progress from story files + tmux panes.
+   */
+  _gatherDevProgress() {
+    const result = {
+      totalEpics: 0, doneEpics: 0,
+      totalStories: 0, doneStories: 0,
+      byStatus: {},
+      currentAgent: null, currentWindow: null, currentStory: null,
+      runningFor: this._devStartedAt ? Date.now() - this._devStartedAt : 0,
+    };
+
+    // Method 1: scan-stories.sh
+    const scriptPath = path.join(SKILL_DIR, 'scripts', 'scan-stories.sh');
+    if (fs.existsSync(scriptPath) && this._projectRoot) {
       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;
+        const output = execSync(`bash "${scriptPath}" "${this._projectRoot}"`, {
+          encoding: 'utf8', timeout: 10000,
+        }).trim();
+
+        if (output && output !== 'NO_STORIES_DIR') {
+          for (const line of output.split('\n')) {
+            const [status, countStr] = line.split(':');
+            const count = parseInt(countStr, 10) || 0;
+            if (status && count > 0) {
+              result.byStatus[status] = count;
+              result.totalStories += count;
+              if (status === 'Done') result.doneStories += count;
+            }
+          }
         }
+      } catch { /* fallback to phase3.yaml */ }
+    }
+
+    // Method 2: phase3.yaml fallback
+    if (result.totalStories === 0) {
+      const phase3Path = path.join(this._projectRoot, '.yuri', 'state', 'phase3.yaml');
+      if (fs.existsSync(phase3Path)) {
+        try {
+          const phase3 = yaml.load(fs.readFileSync(phase3Path, 'utf8')) || {};
+          const p = phase3.progress || {};
+          result.totalStories = p.total_stories || 0;
+          result.totalEpics = p.total_epics || 0;
+          const bs = p.by_status || {};
+          result.doneStories = (bs.done || 0) + (bs.complete || 0);
+          result.byStatus = bs;
+        } catch { /* ok */ }
+      }
+    }
 
-        // Report progress
-        this.onProgress(`💻 Dev progress: ${done}/${total} stories complete`);
-      } catch { /* continue polling */ }
+    // Count epics from docs/stories/ directory
+    const storiesDir = path.join(this._projectRoot, 'docs', 'stories');
+    if (fs.existsSync(storiesDir)) {
+      try {
+        const entries = fs.readdirSync(storiesDir);
+        const epicDirs = entries.filter((e) => {
+          return fs.statSync(path.join(storiesDir, e)).isDirectory() && e.startsWith('epic');
+        });
+        result.totalEpics = epicDirs.length || result.totalEpics;
+      } catch { /* ok */ }
     }
+
+    // Detect current active agent from tmux panes
+    if (this._session && tmx.hasSession(this._session)) {
+      const windowNames = ['Architect', 'SM', 'Dev', 'QA'];
+      for (let w = 0; w < 4; w++) {
+        const pane = tmx.capturePane(this._session, w, 5);
+        // Active = has processing indicator (●) or recent output (not just ❯)
+        const lines = pane.split('\n').filter((l) => l.trim());
+        const lastLine = lines[lines.length - 1] || '';
+        if (/●|⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/.test(pane) || (lines.length > 2 && !/^❯\s*$/.test(lastLine))) {
+          result.currentAgent = windowNames[w];
+          result.currentWindow = w;
+
+          // Try to extract story ID from pane content
+          const storyMatch = pane.match(/story[_-]?\d+[\._-]\d+/i) || pane.match(/\d+\.\d+/);
+          if (storyMatch) result.currentStory = storyMatch[0];
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Build a formatted progress card for Telegram/Feishu.
+   */
+  _buildProgressCard(p) {
+    const pct = p.totalStories > 0 ? Math.round(p.doneStories / p.totalStories * 100) : 0;
+    const bar = this._progressBar(pct);
+    const elapsed = this._formatDuration(p.runningFor);
+
+    const lines = [
+      `📊 **Dev Progress Report**`,
+      `━━━━━━━━━━━━━━━━━━━━━`,
+    ];
+
+    if (p.totalEpics > 0) {
+      lines.push(`Epic: ${p.doneEpics}/${p.totalEpics}`);
+    }
+    lines.push(`Story: ${p.doneStories}/${p.totalStories} (${pct}%)`);
+    lines.push(`${bar}`);
+    lines.push(`━━━━━━━━━━━━━━━━━━━━━`);
+
+    // Status breakdown
+    const statusEntries = Object.entries(p.byStatus).filter(([, v]) => v > 0);
+    if (statusEntries.length > 0) {
+      const statusIcons = {
+        Done: '✅', InProgress: '🔄', Review: '👀', Blocked: '🚫',
+        Approved: '✅', AwaitingArchReview: '🏛️', RequiresRevision: '🔧', Escalated: '⚠️',
+      };
+      for (const [status, count] of statusEntries) {
+        lines.push(`${statusIcons[status] || '·'} ${status}: ${count}`);
+      }
+      lines.push(`━━━━━━━━━━━━━━━━━━━━━`);
+    }
+
+    // Current activity
+    if (p.currentAgent) {
+      const storyInfo = p.currentStory ? ` → ${p.currentStory}` : '';
+      lines.push(`Current: ${p.currentAgent} (window ${p.currentWindow})${storyInfo}`);
+    } else {
+      lines.push(`Current: waiting for next handoff`);
+    }
+
+    lines.push(`⏱ Running for ${elapsed}`);
+
+    return lines.join('\n');
+  }
+
+  _progressBar(pct) {
+    const total = 20;
+    const filled = Math.round(pct / 100 * total);
+    const empty = total - filled;
+    return '▓'.repeat(filled) + '░'.repeat(empty) + ` ${pct}%`;
+  }
+
+  _formatDuration(ms) {
+    const min = Math.floor(ms / 60000);
+    if (min < 60) return `${min}min`;
+    const h = Math.floor(min / 60);
+    const m = min % 60;
+    return `${h}h ${m}min`;
   }
 
   _completeDev() {

package/package.json

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