@yemi33/minions 0.1.1027 → 0.1.1028

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.1.1028 (2026-04-16)
+
+### Features
+- route implement items to dedicated implement playbook (#1115)
+
+### Fixes
+-  prevent test from corrupting live meeting state
+- scheduler enabled field falsy check treats undefined as disabled (#1160)
+-  update branch-dedup tests to use canonical PR IDs after merge with master (#1146)
+-  auto-review not firing for manually-linked PRs with autoObserve=true
+-  mark PR abandoned on 404 instead of silently retrying each tick
+- replace undefined PROJECTS with config.projects in checkWatches (#1108)
+- write permission for publish workflow
+-  run tests inline and post check runs for publish PRs
+- add maxBuffer to all GitHub CLI spawns + paginate PR list (#1130)
+-  add required CI checks for PRs + update publish for auto-merge
+-  revert to PR merge now that stale status check is removed
+- guard live review check against undefined vote/state values (#1132)
+-  push version bump directly to master instead of via PR
+-  add push-triggered CI for chore/publish branches
+-  publish workflow chore PRs failing to merge
+-  harden KB ordering
+-  harden audited state transitions
+
+### Other
+- [E2E] Dashboard & engine perf: gzip cache, tiered status, lock backoff, polling parallelization (#1174)
+- Fix doc chat session isolation
+- test(pipeline): add unit tests for CRUD, stage execution, run lifecycle (#1162)
+- chore: test publish after removing stale status check
+- chore: trigger publish test
+- chore: test publish workflow fix
+- chore: trigger publish workflow test
+
 ## 0.1.1027 (2026-04-16)
 
 ### Features

package/dashboard.js

@@ -171,7 +171,14 @@ function getVerifyGuides() {
 function getArchivedPrds() { return []; }
 function getEngineState() { return queries.getControl(); }
 
+let _worktreeCountCache = 0;
+let _worktreeCountCacheTs = 0;
+
 function _countWorktrees() {
+  const now = Date.now();
+  if (_worktreeCountCacheTs && (now - _worktreeCountCacheTs) < shared.ENGINE_DEFAULTS.worktreeCountCacheTtl) {
+    return _worktreeCountCache;
+  }
   try {
     const config = queries.getConfig();
     const projects = shared.getProjects(config);
@@ -199,6 +206,8 @@ function _countWorktrees() {
         }
       } catch {}
     }
+    _worktreeCountCache = count;
+    _worktreeCountCacheTs = now;
     return count;
   } catch { return 0; }
 }
@@ -302,13 +311,20 @@ function parsePinnedEntries(content) {
   return entries;
 }
 
+// Two-tier status cache: fast state (10s) for frequently-changing data, slow state (60s) for rarely-changing data.
+// Combined into _statusCache for API/SSE consumers — no API contract change.
+let _fastState = null;
+let _fastStateTs = 0;
+const FAST_STATE_TTL = 10000; // 10s — dispatch, agents, metrics, work items, etc.
+let _slowState = null;
+let _slowStateTs = 0;
+const SLOW_STATE_TTL = 60000; // 60s — skills, PRDs, pinned, version, projects, etc.
 let _statusCache = null;
 let _statusCacheJson = null; // cached JSON.stringify(_statusCache) — avoids double-serialization for SSE
-let _statusCacheTs = 0;
-const STATUS_CACHE_TTL = 10000; // 10s — reduces expensive aggregation frequency; mutations call invalidateStatusCache()
+let _statusCacheGzip = null; // pre-computed gzip of _statusCacheJson — avoids per-request gzipSync
 const _statusStreamClients = new Set();
 let _statusPushTimer = null;
-let _lastStatusHash = '';
+let _lastStatusPushRef = null; // last JSON string reference pushed to SSE — O(1) change detection
 
 // mtime-based cache invalidation — skip full rebuild if no tracked files changed
 const _mtimeTrackedFiles = () => {
@@ -348,8 +364,12 @@ function _mtimesChanged(prev, curr) {
 }
 
 function invalidateStatusCache() {
+  _fastState = null;
+  _fastStateTs = 0;
+  // Slow state continues on its own TTL — not invalidated by mutations
   _statusCache = null;
   _statusCacheJson = null;
+  _statusCacheGzip = null;
   // Push to SSE clients (debounced 500ms to avoid flooding during batch mutations)
   if (_statusPushTimer) return;
   _statusPushTimer = setTimeout(() => {
@@ -364,89 +384,110 @@ function invalidateStatusCache() {
 
 function getStatus() {
   const now = Date.now();
-  if (_statusCache && (now - _statusCacheTs) < STATUS_CACHE_TTL) {
-    // Within TTL — check mtimes for early return (skip full rebuild if nothing changed)
+
+  // Fast state: 10s TTL with mtime-based validation for early exit
+  let fastStale = !_fastState || (now - _fastStateTs) >= FAST_STATE_TTL;
+  if (!fastStale) {
+    // Within TTL — check mtimes for early return (skip rebuild if no tracked files changed)
     const currMtimes = _getMtimes();
-    if (!_mtimesChanged(_lastMtimes, currMtimes)) return _statusCache;
+    if (_mtimesChanged(_lastMtimes, currMtimes)) fastStale = true;
   }
 
-  // Reload config on each cache miss — picks up external changes (minions init, minions add)
-  reloadConfig();
-
-  const prdInfo = getPrdInfo();
-  _statusCache = {
-    agents: getAgents(),
-    prdProgress: prdInfo.progress,
-    inbox: getInbox(),
-    notes: getNotesWithMeta(),
-    prd: prdInfo.status,
-    pullRequests: getPullRequests(),
-    verifyGuides: getVerifyGuides(),
-    archivedPrds: getArchivedPrds(),
-    engine: { ...getEngineState(), worktreeCount: _countWorktrees() },
-    adoThrottle: ado.getAdoThrottleState(),
-    ghThrottle: gh.getGhThrottleState(),
-    dispatch: getDispatchQueue(),
-    engineLog: getEngineLog(),
-    metrics: getMetrics(),
-    workItems: getWorkItems(),
-    skills: getSkills(),
-    mcpServers: getMcpServers(),
-    schedules: (() => {
-      const scheds = CONFIG.schedules || [];
-      const runs = shared.safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {};
-      return scheds.map(s => {
-        const runEntry = runs[s.id];
-        // Backward compat: runEntry can be a string (old format) or object (new format with back-references)
-        const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
-        const extra = typeof runEntry === 'object' && runEntry ? { _lastWorkItemId: runEntry.lastWorkItemId, _lastResult: runEntry.lastResult, _lastCompletedAt: runEntry.lastCompletedAt } : {};
-        return { ...s, _lastRun, ...extra };
-      });
-    })(),
-    watches: watchesMod.getWatches(),
-    meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
-    pipelines: (() => { try { const pl = require('./engine/pipeline'); return pl.getPipelines().map(p => ({ ...p, runs: (pl.getPipelineRuns()[p.id] || []).slice(-5) })); } catch { return []; } })(),
-    pinned: (() => { try { return parsePinnedEntries(safeRead(path.join(MINIONS_DIR, 'pinned.md'))); } catch { return []; } })(),
-    projects: PROJECTS.map(p => ({ name: p.name, path: p.localPath, description: p.description || '' })),
-    autoMode: {
-      approvePlans: !!CONFIG.engine?.autoApprovePlans,
-      decompose: CONFIG.engine?.autoDecompose !== false,
-      tempAgents: !!CONFIG.engine?.allowTempAgents,
-      inboxThreshold: CONFIG.engine?.inboxConsolidateThreshold || shared.ENGINE_DEFAULTS.inboxConsolidateThreshold,
-      ccModel: CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel,
-      ccEffort: CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort,
-    },
-    initialized: !!(CONFIG.agents && Object.keys(CONFIG.agents).length > 0),
-    installId: safeRead(path.join(MINIONS_DIR, '.install-id')).trim() || null,
-    version: (() => {
-      const engine = getEngineState();
-      const { diskVersion, diskCommit, isGitRepo } = getDiskVersion();
-      const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
-                          !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
-      const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
-                             !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
-      return {
-        running: engine.codeVersion || null,
-        runningCommit: engine.codeCommit || null,
-        dashboardRunning: _dashboardVersion.codeVersion,
-        dashboardRunningCommit: _dashboardVersion.codeCommit,
-        dashboardStartedAt: _dashboardVersion.startedAt,
-        disk: diskVersion,
-        diskCommit,
-        engineStale,
-        dashboardStale,
-        stale: engineStale || dashboardStale,
-        latest: _npmVersionCache?.latest || null,
-        // Only show "update available" for npm installs (no git repo) — repo users manage their own updates
-        updateAvailable: !isGitRepo && !!(diskVersion && _npmVersionCache?.latest && _npmVersionCache.latest !== diskVersion && _compareVersions(_npmVersionCache.latest, diskVersion) > 0),
-        _npmCheckError: _npmVersionCache?.error || null,
-      };
-    })(),
-    timestamp: new Date().toISOString(),
-  };
-  _statusCacheTs = now;
+  // Slow state: 60s TTL, pure TTL (no mtime check — these files change rarely)
+  const slowStale = !_slowState || (now - _slowStateTs) >= SLOW_STATE_TTL;
+
+  // If nothing stale, return cached merged result
+  if (!fastStale && !slowStale && _statusCache) return _statusCache;
+
+  // Rebuild fast state (frequently-changing data: ~12-15 reads)
+  if (fastStale) {
+    // Reload config on fast-state miss — picks up external changes (minions init, minions add)
+    reloadConfig();
+    _fastState = {
+      agents: getAgents(),
+      inbox: getInbox(),
+      notes: getNotesWithMeta(),
+      pullRequests: getPullRequests(),
+      engine: { ...getEngineState(), worktreeCount: _countWorktrees() },
+      adoThrottle: ado.getAdoThrottleState(),
+      ghThrottle: gh.getGhThrottleState(),
+      dispatch: getDispatchQueue(),
+      engineLog: getEngineLog(),
+      metrics: getMetrics(),
+      workItems: getWorkItems(),
+      watches: watchesMod.getWatches(),
+      meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
+    };
+    _fastStateTs = now;
+    _lastMtimes = _getMtimes();
+  }
+
+  // Rebuild slow state (rarely-changing data: ~8-15 reads, 60s TTL)
+  if (slowStale) {
+    const prdInfo = getPrdInfo();
+    _slowState = {
+      prdProgress: prdInfo.progress,
+      prd: prdInfo.status,
+      verifyGuides: getVerifyGuides(),
+      archivedPrds: getArchivedPrds(),
+      skills: getSkills(),
+      mcpServers: getMcpServers(),
+      schedules: (() => {
+        const scheds = CONFIG.schedules || [];
+        const runs = shared.safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {};
+        return scheds.map(s => {
+          const runEntry = runs[s.id];
+          // Backward compat: runEntry can be a string (old format) or object (new format with back-references)
+          const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
+          const extra = typeof runEntry === 'object' && runEntry ? { _lastWorkItemId: runEntry.lastWorkItemId, _lastResult: runEntry.lastResult, _lastCompletedAt: runEntry.lastCompletedAt } : {};
+          return { ...s, _lastRun, ...extra };
+        });
+      })(),
+      pipelines: (() => { try { const pl = require('./engine/pipeline'); return pl.getPipelines().map(p => ({ ...p, runs: (pl.getPipelineRuns()[p.id] || []).slice(-5) })); } catch { return []; } })(),
+      pinned: (() => { try { return parsePinnedEntries(safeRead(path.join(MINIONS_DIR, 'pinned.md'))); } catch { return []; } })(),
+      projects: PROJECTS.map(p => ({ name: p.name, path: p.localPath, description: p.description || '' })),
+      autoMode: {
+        approvePlans: !!CONFIG.engine?.autoApprovePlans,
+        decompose: CONFIG.engine?.autoDecompose !== false,
+        tempAgents: !!CONFIG.engine?.allowTempAgents,
+        inboxThreshold: CONFIG.engine?.inboxConsolidateThreshold || shared.ENGINE_DEFAULTS.inboxConsolidateThreshold,
+        ccModel: CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel,
+        ccEffort: CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort,
+      },
+      initialized: !!(CONFIG.agents && Object.keys(CONFIG.agents).length > 0),
+      installId: safeRead(path.join(MINIONS_DIR, '.install-id')).trim() || null,
+      version: (() => {
+        const engine = getEngineState();
+        const { diskVersion, diskCommit, isGitRepo } = getDiskVersion();
+        const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
+                            !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
+        const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
+                               !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
+        return {
+          running: engine.codeVersion || null,
+          runningCommit: engine.codeCommit || null,
+          dashboardRunning: _dashboardVersion.codeVersion,
+          dashboardRunningCommit: _dashboardVersion.codeCommit,
+          dashboardStartedAt: _dashboardVersion.startedAt,
+          disk: diskVersion,
+          diskCommit,
+          engineStale,
+          dashboardStale,
+          stale: engineStale || dashboardStale,
+          latest: _npmVersionCache?.latest || null,
+          // Only show "update available" for npm installs (no git repo) — repo users manage their own updates
+          updateAvailable: !isGitRepo && !!(diskVersion && _npmVersionCache?.latest && _npmVersionCache.latest !== diskVersion && _compareVersions(_npmVersionCache.latest, diskVersion) > 0),
+          _npmCheckError: _npmVersionCache?.error || null,
+        };
+      })(),
+    };
+    _slowStateTs = now;
+  }
+
+  // Merge both tiers — no API contract change
+  _statusCache = { ..._fastState, ..._slowState, timestamp: new Date().toISOString() };
   _statusCacheJson = null; // invalidate cached JSON — will be lazily rebuilt by getStatusJson()
-  _lastMtimes = _getMtimes();
+  _statusCacheGzip = null;
   return _statusCache;
 }
 
@@ -455,6 +496,7 @@ function getStatusJson() {
   getStatus(); // ensure _statusCache is fresh
   if (!_statusCacheJson) {
     _statusCacheJson = JSON.stringify(_statusCache);
+    _statusCacheGzip = zlib.gzipSync(_statusCacheJson); // pre-compute gzip once per cache rebuild
   }
   return _statusCacheJson;
 }
@@ -463,9 +505,8 @@ function getStatusJson() {
 setInterval(() => {
   if (_statusStreamClients.size === 0) return;
   const data = getStatusJson();
-  const hash = require('crypto').createHash('md5').update(data).digest('hex');
-  if (hash === _lastStatusHash) return;
-  _lastStatusHash = hash;
+  if (data === _lastStatusPushRef) return; // O(1) reference comparison — new string ref means content changed
+  _lastStatusPushRef = data;
   for (const res of _statusStreamClients) {
     try { res.write('data: ' + data + '\n\n'); } catch { _statusStreamClients.delete(res); }
   }
@@ -4222,15 +4263,15 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
   async function handleStatus(req, res) {
     try {
-      // Use pre-serialized JSON to avoid double-stringify in jsonReply
+      // Use pre-serialized JSON and pre-computed gzip buffer — zero per-request compression
       const json = getStatusJson();
       res.setHeader('Content-Type', 'application/json');
       res.setHeader('Access-Control-Allow-Origin', '*');
       res.statusCode = 200;
       const ae = req && req.headers && req.headers['accept-encoding'] || '';
-      if (ae.includes('gzip') && json.length > 1024) {
+      if (ae.includes('gzip') && _statusCacheGzip) {
         res.setHeader('Content-Encoding', 'gzip');
-        res.end(zlib.gzipSync(json));
+        res.end(_statusCacheGzip);
       } else {
         res.end(json);
       }

package/engine/cleanup.js

@@ -442,22 +442,24 @@ function runCleanup(config, verbose = false) {
 
   // 6a. Reconcile failed work items that have an attached PR (#407)
   // If a work item is 'failed' but already has _pr, it should be 'done'.
+  // Uses mutateWorkItems() for locked atomic read-modify-write — prevents
+  // race conditions with concurrent engine/dashboard/lifecycle writers.
   for (const project of projects) {
     try {
       const wiPath = projectWorkItemsPath(project);
-      const items = safeJson(wiPath) || [];
       let reconciled = 0;
-      for (const item of items) {
-        if (item.status === shared.WI_STATUS.FAILED && item._pr) {
-          item.status = shared.WI_STATUS.DONE;
-          if (item.failReason) delete item.failReason;
-          if (item.failedAt) delete item.failedAt;
-          if (!item.completedAt) item.completedAt = shared.ts();
-          reconciled++;
+      mutateWorkItems(wiPath, items => {
+        for (const item of items) {
+          if (item.status === shared.WI_STATUS.FAILED && item._pr) {
+            item.status = shared.WI_STATUS.DONE;
+            if (item.failReason) delete item.failReason;
+            if (item.failedAt) delete item.failedAt;
+            if (!item.completedAt) item.completedAt = shared.ts();
+            reconciled++;
+          }
         }
-      }
+      });
       if (reconciled > 0) {
-        safeWrite(wiPath, items);
         log('info', `Reconciled ${reconciled} failed-with-PR item(s) → done in ${project.name}`);
       }
     } catch (e) { log('warn', 'reconcile failed-with-PR: ' + e.message); }

package/engine/shared.js

@@ -534,6 +534,7 @@ const ENGINE_DEFAULTS = {
   worktreeCreateTimeout: 300000, // 5min for git worktree add on large Windows repos
   worktreeCreateRetries: 1, // retry once on transient timeout/lock races
   worktreeRoot: '../worktrees',
+  worktreeCountCacheTtl: 30000, // 30s — TTL for cached _countWorktrees() result in dashboard
   idleAlertMinutes: 15,
   fanOutTimeout: null, // falls back to agentTimeout
   restartGracePeriod: 1200000, // 20min
@@ -554,7 +555,7 @@ const ENGINE_DEFAULTS = {
   versionCheckInterval: 3600000, // 1 hour — how often to check npm for updates (ms)
   logFlushInterval: 5000, // 5s — how often to flush buffered log entries to disk
   logBufferSize: 50, // flush immediately when buffer exceeds this many entries
-  lockRetries: 2, // retry lock acquisition this many times after initial timeout (total attempts = 1 + lockRetries)
+  lockRetries: 0, // no retries — single 5s timeout window with 25ms polling (200 attempts) is sufficient; stale lock recovery at 60s handles crashes
   lockRetryBackoffMs: 500, // base backoff between lock retries (doubles each attempt: 500ms, 1s, 2s, ...)
   maxBuildFixAttempts: 3, // max consecutive auto-fix dispatch cycles per PR before escalation to human
   buildFixGracePeriod: 600000, // 10min — wait for CI to run after build fix before re-dispatching

package/engine.js

@@ -3229,16 +3229,19 @@ async function tickInner() {
   // Awaited so PR state is consistent before discoverWork reads it
   // Also re-polls early if previous tick had ADO auth failures (stale build status recovery)
   if (tickCount % adoPollStatusEvery === 0 || needsAdoPollRetry()) {
+    // Build promise array — enabled+unthrottled polls run concurrently via Promise.allSettled
+    const statusPolls = [];
     if (adoPollEnabled && !isAdoThrottled()) {
-      try { await pollPrStatus(config); } catch (err) { log('warn', `ADO PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+      statusPolls.push(pollPrStatus(config).catch(err => { log('warn', `ADO PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
     } else if (adoPollEnabled && isAdoThrottled()) {
       log('info', '[ado] PR status poll skipped — throttled');
     }
     if (ghPollEnabled && !isGhThrottled()) {
-      try { await ghPollPrStatus(config); } catch (err) { log('warn', `GitHub PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+      statusPolls.push(ghPollPrStatus(config).catch(err => { log('warn', `GitHub PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
     } else if (ghPollEnabled && isGhThrottled()) {
       log('info', '[gh] PR status poll skipped — throttled');
     }
+    if (statusPolls.length) await Promise.allSettled(statusPolls);
     try { await processPendingRebases(config); } catch (err) { log('warn', `Pending rebase processing error: ${err?.message || err}`); }
     // Sync PR status back to PRD items (missing → done when active PR exists)
     try { syncPrdFromPrs(config); } catch (err) { log('warn', `PRD sync error: ${err?.message || err}`); }
@@ -3260,19 +3263,25 @@ async function tickInner() {
 
   // 2.7. Poll PR threads for human comments (every adoPollCommentsEvery ticks, default ~12 minutes)
   if (tickCount % adoPollCommentsEvery === 0) {
+    // Build promise array — enabled+unthrottled comment polls run concurrently via Promise.allSettled
+    const commentPolls = [];
     if (adoPollEnabled && !isAdoThrottled()) {
-      try { await pollPrHumanComments(config); } catch (err) { log('warn', `ADO PR comment poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+      commentPolls.push(pollPrHumanComments(config).catch(err => { log('warn', `ADO PR comment poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
     } else if (adoPollEnabled && isAdoThrottled()) {
       log('info', '[ado] PR comment poll skipped — throttled');
     }
     if (ghPollEnabled && !isGhThrottled()) {
-      try { await ghPollPrHumanComments(config); } catch (err) { log('warn', `GitHub PR comment poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+      commentPolls.push(ghPollPrHumanComments(config).catch(err => { log('warn', `GitHub PR comment poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
     } else if (ghPollEnabled && isGhThrottled()) {
       log('info', '[gh] PR comment poll skipped — throttled');
     }
+    if (commentPolls.length) await Promise.allSettled(commentPolls);
     // Reconciliation runs regardless of poll flags — it's a recovery sweep, not a convenience poll
-    try { await reconcilePrs(config); } catch (err) { log('warn', `ADO PR reconciliation error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
-    try { await ghReconcilePrs(config); } catch (err) { log('warn', `GitHub PR reconciliation error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
+    // Reconciliation also parallelized — ADO and GitHub reconciliation are independent
+    const reconcilePolls = [];
+    reconcilePolls.push(reconcilePrs(config).catch(err => { log('warn', `ADO PR reconciliation error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
+    reconcilePolls.push(ghReconcilePrs(config).catch(err => { log('warn', `GitHub PR reconciliation error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }));
+    await Promise.allSettled(reconcilePolls);
   }
 
   // 2.9. Stalled dispatch detection — auto-retry failed items blocking the graph (every 20 ticks = ~10 min)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1027",
+  "version": "0.1.1028",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"