orchestrix-yuri 4.2.4 → 4.3.0

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

@@ -753,6 +753,186 @@ class PhaseOrchestrator {
     this.onComplete('develop', '🎉 Development complete! All stories finished.\n\nRun *test to start smoke testing.');
   }
 
+  // ── 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

@@ -19,6 +19,7 @@ const YURI_GLOBAL = path.join(os.homedir(), '.yuri');
 const PHASE_COMMANDS = {
   plan:    /^\*plan\b/i,
   develop: /^\*develop\b/i,
+  change:  /^\*change\s+(.+)/i,
   test:    /^\*test\b/i,
   deploy:  /^\*deploy\b/i,
   cancel:  /^\*cancel\b/i,
@@ -266,7 +267,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.' };
@@ -280,16 +281,15 @@ class Router {
       case 'develop':
         response = this.orchestrator.startDevelop(projectRoot);
         break;
+      case 'change':
+        return this._handleChangeCommand(msg, projectRoot);
       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);
@@ -297,6 +297,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) {

package/package.json

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

package/skill/tasks/yuri-status.md

@@ -105,27 +105,63 @@ Read `{project}/.yuri/state/phase2.yaml`.
 
 ### IF Phase 3 (Develop) is in progress or complete:
 
-Read `{project}/.yuri/state/phase3.yaml`.
+**Generate a progress card** using these data sources:
 
-Scan current story statuses:
+**1. Scan story statuses:**
 ```bash
 SCRIPT_DIR="${CLAUDE_SKILL_DIR}/scripts"
 bash "$SCRIPT_DIR/scan-stories.sh" "$PROJECT_DIR"
 ```
 
-```
-### Development Progress
-
-| Metric | Value |
-|--------|-------|
-| Total Stories | {total} |
-| Done | {done count} |
-| In Progress | {in_progress count} |
-| Blocked | {blocked count} |
-| Remaining | {remaining count} |
+The script outputs:
+- `Total:{N}` — total planned stories from all `docs/prd/epic-*.yaml` definitions
+- `Created:{N}` — story files in `docs/stories/`
+- `StatusDone:{filename}` / `StatusInProgress:{filename}` / etc. — per-file status
+- `Epics:{N}` — total epics (max N from `docs/prd/epic-N-*`)
+- `CurrentEpic:{N}` — epic of current story
+- `CurrentStory:{filename}` — InProgress or last non-Done story
 
-Progress: [{done}/{total}] {'█' * pct}{'░' * (100-pct)} {pct}%
-```
+**2. Detect active tmux agent:**
+```bash
+# Check which orchestrix-* session exists
+tmux list-sessions -F "#{session_name}" 2>/dev/null | grep "^orchestrix-"
+
+# For each window (0=Architect, 1=SM, 2=Dev, 3=QA):
+# - Window showing "Command | Description" table = IDLE
+# - Window WITHOUT that table = actively executing
+for w in 0 1 2 3; do
+  OUTPUT=$(tmux capture-pane -t "$DEV_SESSION:$w" -p -S -15)
+  if ! echo "$OUTPUT" | grep -q "Command.*Description"; then
+    echo "Window $w is ACTIVE"
+  fi
+done
+```
+
+**3. Format the progress card:**
+
+```
+📊 Dev Progress Report
+━━━━━━━━━━━━━━━━━━━━━
+Epic: {CurrentEpic}/{Epics}
+Story: {done}/{total} done ({pct}%) | {created} created
+▓▓▓▓▓▓░░░░░░░░░░░░░░ {pct}%
+━━━━━━━━━━━━━━━━━━━━━
+✅ Done: {N}
+🔄 InProgress: {N}
+📋 Approved: {N}
+📝 Draft: {N}
+━━━━━━━━━━━━━━━━━━━━━
+📝 Current: {CurrentStory}
+🤖 Agent: {active_agent} (window {N})
+⏱ Running for {elapsed}
+```
+
+Where:
+- `{pct}` = round(done / total * 100)
+- Progress bar: `▓` for filled, `░` for empty (20 chars total)
+- Only show status categories with count > 0
+- `{elapsed}` = time since `focus.updated_at` or `phase3.started_at`
+- If no agent is active (all windows show Command table), show "All agents idle (waiting for handoff)"
 
 ### IF Phase 4 (Test) is in progress or complete: