@yemi33/minions 0.1.1026 → 0.1.1028

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.1.1026 (2026-04-16)
+## 0.1.1028 (2026-04-16)
 
 ### Features
 - route implement items to dedicated implement playbook (#1115)
@@ -25,6 +25,40 @@
 -  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
+- 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
+- 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

package/dashboard/js/modal-qa.js

@@ -40,6 +40,7 @@ function _renderQaUserMessage(thread, message, selection) {
   _showThreadWrap();
 }
 const _qaSessions = new Map(); // persist conversations across modal open/close {key → {history, threadHtml}}
+const _qaRuntime = new Map(); // key → {history, processing, abortController, queue}
 // Restore from localStorage
 try {
   const saved = JSON.parse(localStorage.getItem('qa-sessions') || '{}');
@@ -55,6 +56,175 @@ function _saveQaSessions() {
   } catch { /* localStorage might be full */ }
 }
 
+function _qaCloneQueue(queue) {
+  return Array.isArray(queue) ? queue.map(item => ({ ...item })) : [];
+}
+
+function _qaGetRuntime(key) {
+  if (!key) return null;
+  let runtime = _qaRuntime.get(key);
+  if (!runtime) {
+    const prior = _qaSessions.get(key);
+    runtime = {
+      history: Array.isArray(prior?.history) ? prior.history.slice() : [],
+      processing: false,
+      abortController: null,
+      queue: _qaCloneQueue(prior?.queue),
+    };
+    _qaRuntime.set(key, runtime);
+  }
+  return runtime;
+}
+
+function _qaThreadEl() {
+  return document.getElementById('modal-qa-thread');
+}
+
+function _qaThreadHtml() {
+  return (_qaThreadEl() || {}).innerHTML || '';
+}
+
+function _qaIsActiveSession(key) {
+  return !!key && _qaSessionKey === key && document.getElementById('modal')?.classList?.contains('open');
+}
+
+function _qaSyncActiveRuntime() {
+  if (!_qaSessionKey) return;
+  const runtime = _qaGetRuntime(_qaSessionKey);
+  if (!runtime) return;
+  runtime.history = _qaHistory.slice();
+  runtime.processing = _qaProcessing;
+  runtime.abortController = _qaAbortController || null;
+  runtime.queue = _qaCloneQueue(_qaQueue);
+}
+
+function _qaPersistSession(key, { threadHtml, docContext, filePath, history, queue } = {}) {
+  if (!key) return;
+  const runtime = _qaGetRuntime(key);
+  const prior = _qaSessions.get(key) || {};
+  const persistedHistory = Array.isArray(history)
+    ? history.slice()
+    : Array.isArray(runtime?.history)
+      ? runtime.history.slice()
+      : Array.isArray(prior.history)
+        ? prior.history.slice()
+        : [];
+  _qaSessions.set(key, {
+    history: persistedHistory,
+    threadHtml: threadHtml != null ? threadHtml : (prior.threadHtml || ''),
+    docContext: docContext ? { ...docContext } : (prior.docContext ? { ...prior.docContext } : { title: '', content: '', selection: '' }),
+    filePath: filePath !== undefined ? filePath : prior.filePath,
+    queue: Array.isArray(queue) ? _qaCloneQueue(queue) : _qaCloneQueue(runtime?.queue),
+  });
+  _saveQaSessions();
+}
+
+function _qaSaveActiveSessionState() {
+  if (!_qaSessionKey) return;
+  _qaSyncActiveRuntime();
+  _qaPersistSession(_qaSessionKey, {
+    threadHtml: _qaThreadHtml(),
+    docContext: { ..._modalDocContext },
+    filePath: _modalFilePath,
+    history: _qaHistory,
+    queue: _qaQueue,
+  });
+}
+
+function _qaLoadSessionState(key) {
+  const prior = _qaSessions.get(key);
+  const runtime = _qaGetRuntime(key);
+  _qaHistory = Array.isArray(runtime?.history) && runtime.history.length
+    ? runtime.history.slice()
+    : Array.isArray(prior?.history)
+      ? prior.history.slice()
+      : [];
+  _qaProcessing = !!runtime?.processing;
+  _qaAbortController = runtime?.abortController || null;
+  _qaQueue = _qaCloneQueue(runtime?.queue);
+  const thread = _qaThreadEl();
+  if (thread) {
+    const tmp = document.createElement('div');
+    tmp.innerHTML = prior?.threadHtml || '';
+    if (!_qaProcessing) tmp.querySelectorAll('.modal-qa-loading').forEach(el => el.remove());
+    thread.innerHTML = tmp.innerHTML;
+  }
+}
+
+function _qaResetActiveState() {
+  _qaHistory = [];
+  _qaProcessing = false;
+  _qaAbortController = null;
+  _qaQueue = [];
+  _qaSessionKey = '';
+}
+
+function _qaBuildUserMessageHtml(message, selection) {
+  let qHtml = '<div class="modal-qa-q">' + escHtml(message);
+  if (selection) {
+    qHtml += '<span class="selection-ref">Re: "' + escHtml(selection.slice(0, 100)) + ((selection.length > 100) ? '...' : '') + '"</span>';
+  }
+  qHtml += '</div>';
+  return qHtml;
+}
+
+function _qaBuildQueuedHtml(message) {
+  const preview = escHtml(message.length > 60 ? message.slice(0, 57) + '...' : message);
+  return '<div class="qa-queued-item" style="color:var(--muted);font-size:10px;padding:4px 8px">Queued: "' + preview + '"</div>';
+}
+
+function _qaBuildLoadingHtml(loadingId, queueCount) {
+  const qaQueueBadge = queueCount > 0 ? ' <span style="font-size:9px;color:var(--muted);background:var(--surface);padding:1px 5px;border-radius:8px;border:1px solid var(--border)">+' + queueCount + ' queued</span>' : '';
+  return '<div class="modal-qa-loading" id="' + loadingId + '">' +
+    '<div class="dot-pulse"><span></span><span></span><span></span></div> ' +
+    '<span id="' + loadingId + '-text">Thinking...</span> ' +
+    '<span id="' + loadingId + '-time" style="font-size:10px;color:var(--muted)"></span>' +
+    ' <button onclick="qaAbort()" style="font-size:9px;padding:2px 8px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--red);cursor:pointer">Stop</button>' +
+    qaQueueBadge + '</div>';
+}
+
+function _qaBuildAssistantHtml(text, opts) {
+  const body = opts?.isError ? escHtml(text) : renderMd(text);
+  const style = opts?.isError
+    ? 'color:' + (opts?.color || 'var(--red)')
+    : 'border-left-color:' + (opts?.borderColor || 'var(--blue)');
+  const pad = opts?.isError ? '' : 'padding-right:24px;';
+  return '<div class="modal-qa-a" style="' + style + '">' +
+    (opts?.isError ? '' : llmCopyBtn()) +
+    body +
+    '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right;' + pad + '">' + opts.elapsed + 's</div>' +
+    '</div>';
+}
+
+function _qaMutateThreadHtml(key, mutate) {
+  const tmp = document.createElement('div');
+  tmp.innerHTML = _qaIsActiveSession(key) ? _qaThreadHtml() : ((_qaSessions.get(key) || {}).threadHtml || '');
+  mutate(tmp);
+  const html = tmp.innerHTML;
+  if (_qaIsActiveSession(key)) {
+    const thread = _qaThreadEl();
+    if (thread) {
+      thread.innerHTML = html;
+      thread.scrollTop = thread.scrollHeight;
+    }
+    _showThreadWrap();
+  }
+  return html;
+}
+
+function _qaResumeQueuedMessages() {
+  if (!_qaSessionKey || _qaProcessing || _qaQueue.length === 0) return;
+  const next = _qaQueue.shift();
+  const thread = _qaThreadEl();
+  if (thread) {
+    const queuedEl = thread.querySelector('.qa-queued-item');
+    if (queuedEl) queuedEl.remove();
+    _renderQaUserMessage(thread, next.message, next.selection);
+  }
+  _qaSaveActiveSessionState();
+  _processQaMessage(next.message, next.selection);
+}
+
 function modalAskAboutSelection() {
   document.getElementById('ask-selection-btn').style.display = 'none';
 
@@ -91,16 +261,14 @@ function clearQaSelection() {
 function _initQaSession() {
   var key = _modalFilePath || _modalDocContext.title || '';
   if (!key || _qaSessionKey === key) return;
+  if (_qaSessionKey && _qaSessionKey !== key) _qaSaveActiveSessionState();
   _qaSessionKey = key;
-  // Clear notification badge on the source card when reopening
   const card = findCardForFile(_modalFilePath);
   if (card) clearNotifBadge(card);
   var prior = _qaSessions.get(key);
+  _qaLoadSessionState(key);
   if (prior) {
-    _qaHistory = prior.history;
-    document.getElementById('modal-qa-thread').innerHTML = prior.threadHtml;
     if (prior.docContext) {
-      // Preserve freshly-fetched content and title — prior session may have stale/empty content
       const freshContent = _modalDocContext.content;
       const freshTitle = _modalDocContext.title;
       _modalDocContext = Object.assign({}, prior.docContext, {
@@ -111,11 +279,13 @@ function _initQaSession() {
     }
     if (prior.filePath) _modalFilePath = prior.filePath;
     _showThreadWrap();
-    // Defer scroll — container just transitioned from display:none, layout not yet computed
     requestAnimationFrame(function() {
       var thread = document.getElementById('modal-qa-thread');
       if (thread) thread.scrollTop = thread.scrollHeight;
     });
+    if (_qaQueue.length > 0 && !_qaProcessing) {
+      setTimeout(_qaResumeQueuedMessages, 0);
+    }
   } else {
     _qaHistory = [];
     document.getElementById('modal-qa-thread').innerHTML = '';
@@ -127,9 +297,13 @@ function _initQaSession() {
 }
 
 function clearQaConversation() {
+  const runtime = _qaGetRuntime(_qaSessionKey);
+  if (_qaAbortController) _qaAbortController.abort();
+  if (runtime?.abortController && runtime.abortController !== _qaAbortController) runtime.abortController.abort();
   _qaHistory = [];
   _qaQueue = [];
   _qaProcessing = false;
+  _qaAbortController = null;
   document.getElementById('modal-qa-thread').innerHTML = '';
   var wrap = document.getElementById('modal-qa-thread-wrap');
   var expandBar = document.getElementById('qa-expand-bar');
@@ -137,6 +311,7 @@ function clearQaConversation() {
   if (expandBar) expandBar.style.display = 'none';
   if (_qaSessionKey) {
     _qaSessions.delete(_qaSessionKey);
+    _qaRuntime.set(_qaSessionKey, { history: [], processing: false, abortController: null, queue: [] });
     _saveQaSessions();
   }
 }
@@ -164,7 +339,6 @@ function modalSend() {
   var thread = document.getElementById('modal-qa-thread');
   const selection = _modalDocContext.selection || '';
 
-  // Clear input immediately so user can type next message
   input.value = '';
   _modalDocContext.selection = '';
   document.getElementById('modal-qa-pill').style.display = 'none';
@@ -174,63 +348,79 @@ function modalSend() {
       showToast('cmd-toast', 'Queue full — wait for current response', false);
       return;
     }
-    // Queue the message — show only grey queued indicator (blue bubble shows when processing starts)
     _qaQueue.push({ message, selection });
-    const preview = escHtml(message.length > 60 ? message.slice(0, 57) + '...' : message);
-    thread.insertAdjacentHTML('beforeend', '<div class="qa-queued-item" style="color:var(--muted);font-size:10px;padding:4px 8px">Queued: "' + preview + '"</div>');
+    thread.insertAdjacentHTML('beforeend', _qaBuildQueuedHtml(message));
     thread.scrollTop = thread.scrollHeight;
     _showThreadWrap();
+    _qaSaveActiveSessionState();
     return;
   }
 
-  // Show message in thread when processing starts (not when queued)
   _renderQaUserMessage(thread, message, selection);
-
+  _qaSaveActiveSessionState();
   _processQaMessage(message, selection);
 }
 
-async function _processQaMessage(message, selection) {
-  const thread = document.getElementById('modal-qa-thread');
-  const btn = document.getElementById('modal-send-btn');
-  _qaProcessing = true;
-
-  // Capture state now — closeModal may null these while we're awaiting
-  const capturedFilePath = _modalFilePath;
-  const capturedDocContext = { ..._modalDocContext };
+async function _processQaMessage(message, selection, opts) {
+  const sessionKey = opts?.sessionKey || _qaSessionKey;
+  if (!sessionKey) return;
+  const runtime = _qaGetRuntime(sessionKey);
+  if (!runtime) return;
+
+  const prior = _qaSessions.get(sessionKey);
+  const capturedFilePath = opts?.filePath !== undefined ? opts.filePath : (prior?.filePath || _modalFilePath);
+  const capturedDocContext = Object.assign({}, prior?.docContext || {}, opts?.docContext || (_qaIsActiveSession(sessionKey) ? _modalDocContext : {}));
+  const isActiveSession = _qaIsActiveSession(sessionKey);
+
+  runtime.processing = true;
+  const abortController = new AbortController();
+  runtime.abortController = abortController;
+  if (isActiveSession) {
+    _qaProcessing = true;
+    _qaAbortController = abortController;
+  }
 
-  // Show processing badge on the source card
   const sourceCard = findCardForFile(capturedFilePath);
   if (sourceCard) showNotifBadge(sourceCard, 'processing');
 
   const loadingId = 'chat-loading-' + Date.now();
-  const qaQueueBadge = _qaQueue.length > 0 ? ' <span style="font-size:9px;color:var(--muted);background:var(--surface);padding:1px 5px;border-radius:8px;border:1px solid var(--border)">+' + _qaQueue.length + ' queued</span>' : '';
-  _qaAbortController = new AbortController();
-  thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-loading" id="' + loadingId + '">' +
-    '<div class="dot-pulse"><span></span><span></span><span></span></div> ' +
-    '<span id="' + loadingId + '-text">Thinking...</span> ' +
-    '<span id="' + loadingId + '-time" style="font-size:10px;color:var(--muted)"></span>' +
-    ' <button onclick="qaAbort()" style="font-size:9px;padding:2px 8px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--red);cursor:pointer">Stop</button>' +
-    qaQueueBadge + '</div>');
-  thread.scrollTop = thread.scrollHeight;
+  const loadingHtml = _qaBuildLoadingHtml(loadingId, runtime.queue.length);
+  const startThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+    tmp.insertAdjacentHTML('beforeend', loadingHtml);
+  });
+  _qaPersistSession(sessionKey, {
+    threadHtml: startThreadHtml,
+    docContext: capturedDocContext,
+    filePath: capturedFilePath,
+    history: runtime.history,
+    queue: runtime.queue,
+  });
 
-  const isPlanEdit = _modalFilePath && _modalFilePath.match(/^plans\/.*\.md$/);
+  const isPlanEdit = capturedFilePath && capturedFilePath.match(/^plans\/.*\.md$/);
   const qaStartTime = Date.now();
   const qaPhases = isPlanEdit
     ? [[0,'Reading plan...'],[3000,'Analyzing structure...'],[8000,'Researching context...'],[15000,'Drafting revisions...'],[30000,'Writing updated plan...'],[60000,'Still working (large document)...'],[120000,'Deep edit in progress...'],[300000,'Almost there...']]
     : [[0,'Thinking...'],[3000,'Reading document...'],[8000,'Analyzing...'],[20000,'Still working...'],[60000,'Taking a while...']];
   const qaTimer = setInterval(() => {
     const elapsed = Date.now() - qaStartTime;
-    const timeEl = document.getElementById(loadingId + '-time');
-    const textEl = document.getElementById(loadingId + '-text');
+    const timeEl = _qaIsActiveSession(sessionKey) ? document.getElementById(loadingId + '-time') : null;
+    const textEl = _qaIsActiveSession(sessionKey) ? document.getElementById(loadingId + '-text') : null;
     if (timeEl) timeEl.textContent = Math.floor(elapsed / 1000) + 's';
-    if (textEl) { for (let i = qaPhases.length - 1; i >= 0; i--) { if (elapsed >= qaPhases[i][0]) { textEl.textContent = qaPhases[i][1]; break; } } }
+    if (textEl) {
+      for (let i = qaPhases.length - 1; i >= 0; i--) {
+        if (elapsed >= qaPhases[i][0]) {
+          textEl.textContent = qaPhases[i][1];
+          break;
+        }
+      }
+    }
   }, 500);
 
   try {
     const res = await fetch('/api/doc-chat', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      signal: _qaAbortController ? _qaAbortController.signal : undefined,
+      signal: abortController.signal,
       body: JSON.stringify({
         message,
         document: capturedDocContext.content,
@@ -242,109 +432,141 @@ async function _processQaMessage(message, selection) {
     });
     const data = await res.json();
     clearInterval(qaTimer);
-    const loadingEl = document.getElementById(loadingId);
-    if (loadingEl) loadingEl.remove();
+    const qaElapsed = Math.round((Date.now() - qaStartTime) / 1000);
+    let sessionDocContext = { ...capturedDocContext };
 
     if (data.ok) {
       const borderColor = data.edited ? 'var(--green)' : 'var(--blue)';
       const suffix = data.edited ? '\n\n\u2713 Document saved.' : '';
-      const qaElapsed = Math.round((Date.now() - qaStartTime) / 1000);
-      const qaTimeLabel = '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right;padding-right:24px">' + qaElapsed + 's</div>';
-      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="border-left-color:' + borderColor + '">' + llmCopyBtn() + renderMd(data.answer + suffix) + qaTimeLabel + '</div>');
+      const answerHtml = _qaBuildAssistantHtml(data.answer + suffix, { borderColor, elapsed: qaElapsed });
+      const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+        const loadingEl = tmp.querySelector('#' + loadingId);
+        if (loadingEl) loadingEl.remove();
+        tmp.insertAdjacentHTML('beforeend', answerHtml);
+      });
 
-      // Track conversation history
-      _qaHistory.push({ role: 'user', text: message });
-      _qaHistory.push({ role: 'assistant', text: data.answer });
+      runtime.history.push({ role: 'user', text: message });
+      runtime.history.push({ role: 'assistant', text: data.answer });
+      if (_qaIsActiveSession(sessionKey)) _qaHistory = runtime.history.slice();
 
-      // Notify sidebar page link
       _qaNotifySidebar(capturedFilePath);
-
-      // Execute any CC actions (dispatch, note, etc.)
       if (data.actions && data.actions.length > 0) {
-        for (const action of data.actions) { await ccExecuteAction(action); }
+        for (const action of data.actions) await ccExecuteAction(action);
       }
 
-      // Refresh modal body if document was edited
       if (data.edited && data.content) {
         const display = data.content.replace(/^---[\s\S]*?---\n*/m, '');
         const isJson = capturedFilePath && capturedFilePath.endsWith('.json');
-        const body = document.getElementById('modal-body');
-        if (isJson) {
-          body.textContent = display;
-        } else {
-          body.innerHTML = renderMd(display);
-          body.style.fontFamily = "'Segoe UI', system-ui, sans-serif";
-          body.style.whiteSpace = 'normal';
+        sessionDocContext.content = display;
+        sessionDocContext.selection = '';
+        if (_qaIsActiveSession(sessionKey)) {
+          const body = document.getElementById('modal-body');
+          if (isJson) {
+            body.textContent = display;
+          } else {
+            body.innerHTML = renderMd(display);
+            body.style.fontFamily = "'Segoe UI', system-ui, sans-serif";
+            body.style.whiteSpace = 'normal';
+          }
+          _modalDocContext.content = display;
         }
-        _modalDocContext.content = display;
       }
+
+      _qaPersistSession(sessionKey, {
+        threadHtml: updatedThreadHtml,
+        docContext: sessionDocContext,
+        filePath: capturedFilePath,
+        history: runtime.history,
+        queue: runtime.queue,
+      });
     } else {
-      const qaElapsedErr = Math.round((Date.now() - qaStartTime) / 1000);
-      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(data.error || 'Failed') + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedErr + 's</div></div>');
+      const errorHtml = _qaBuildAssistantHtml('Error: ' + (data.error || 'Failed'), { color: 'var(--red)', isError: true, elapsed: qaElapsed });
+      const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+        const loadingEl = tmp.querySelector('#' + loadingId);
+        if (loadingEl) loadingEl.remove();
+        tmp.insertAdjacentHTML('beforeend', errorHtml);
+      });
+      _qaPersistSession(sessionKey, {
+        threadHtml: updatedThreadHtml,
+        docContext: sessionDocContext,
+        filePath: capturedFilePath,
+        history: runtime.history,
+        queue: runtime.queue,
+      });
     }
   } catch (e) {
     clearInterval(qaTimer);
-    const loadingEl = document.getElementById(loadingId);
-    if (loadingEl) loadingEl.remove();
     const qaElapsedExc = Math.round((Date.now() - qaStartTime) / 1000);
-    if (e.name === 'AbortError') {
-      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--muted)">Stopped<div style="font-size:9px;margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>');
-    } else {
-      thread.insertAdjacentHTML('beforeend', '<div class="modal-qa-a" style="color:var(--red)">Error: ' + escHtml(e.message) + '<div style="font-size:9px;color:var(--muted);margin-top:4px;text-align:right">' + qaElapsedExc + 's</div></div>');
-    }
+    const messageHtml = e.name === 'AbortError'
+      ? _qaBuildAssistantHtml('Stopped', { color: 'var(--muted)', isError: true, elapsed: qaElapsedExc })
+      : _qaBuildAssistantHtml('Error: ' + e.message, { color: 'var(--red)', isError: true, elapsed: qaElapsedExc });
+    const updatedThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+      const loadingEl = tmp.querySelector('#' + loadingId);
+      if (loadingEl) loadingEl.remove();
+      tmp.insertAdjacentHTML('beforeend', messageHtml);
+    });
+    _qaPersistSession(sessionKey, {
+      threadHtml: updatedThreadHtml,
+      docContext: capturedDocContext,
+      filePath: capturedFilePath,
+      history: runtime.history,
+      queue: runtime.queue,
+    });
   }
 
-  _qaProcessing = false;
-  _qaAbortController = null;
-  thread.scrollTop = thread.scrollHeight;
-
-  // Clear processing badge on source card (unless more messages queued)
-  if (_qaQueue.length === 0) {
-    const doneCard = findCardForFile(capturedFilePath);
-    if (doneCard) clearNotifBadge(doneCard);
+  runtime.processing = false;
+  runtime.abortController = null;
+  if (_qaIsActiveSession(sessionKey)) {
+    _qaProcessing = false;
+    _qaAbortController = null;
   }
 
-  // Save session (persists even if modal was closed during processing)
-  const modalIsOpen = document.getElementById('modal').classList.contains('open');
-  if (_qaSessionKey) {
-    // Use captured values if closeModal nulled the globals during processing
-    const sessionFilePath = _modalFilePath || capturedFilePath;
-    const sessionDocContext = _modalDocContext.title ? { ..._modalDocContext } : { ...capturedDocContext, ..._modalDocContext, title: capturedDocContext.title };
-    _qaSessions.set(_qaSessionKey, {
-      history: _qaHistory,
-      threadHtml: thread.innerHTML,
-      docContext: sessionDocContext,
-      filePath: sessionFilePath,
-    });
-    _saveQaSessions();
-    // Show notification badge on source card when modal was closed during processing
-    if (!modalIsOpen) {
-      const card = findCardForFile(sessionFilePath);
-      if (card) showNotifBadge(card, _qaQueue.length > 0 ? 'processing' : 'done');
-      _qaSessionKey = '';
+  if (runtime.queue.length === 0) {
+    const doneCard = findCardForFile(capturedFilePath);
+    if (_qaIsActiveSession(sessionKey)) {
+      if (doneCard) clearNotifBadge(doneCard);
+    } else if (doneCard) {
+      showNotifBadge(doneCard, 'done');
     }
+  } else {
+    const pendingCard = findCardForFile(capturedFilePath);
+    if (pendingCard) showNotifBadge(pendingCard, 'processing');
   }
 
-  // Process next queued message
-  if (_qaQueue.length > 0) {
-    const next = _qaQueue.shift();
-    // Remove the queued indicator and show the blue user bubble now that it's processing
-    const queuedEl = thread.querySelector('.qa-queued-item');
-    if (queuedEl) queuedEl.remove();
-    _renderQaUserMessage(thread, next.message, next.selection);
-    _processQaMessage(next.message, next.selection);
-  } else if (modalIsOpen) {
+  if (runtime.queue.length > 0) {
+    const next = runtime.queue.shift();
+    const nextThreadHtml = _qaMutateThreadHtml(sessionKey, tmp => {
+      const queuedEl = tmp.querySelector('.qa-queued-item');
+      if (queuedEl) queuedEl.remove();
+      tmp.insertAdjacentHTML('beforeend', _qaBuildUserMessageHtml(next.message, next.selection));
+    });
+    _qaPersistSession(sessionKey, {
+      threadHtml: nextThreadHtml,
+      docContext: (_qaSessions.get(sessionKey) || {}).docContext || capturedDocContext,
+      filePath: capturedFilePath,
+      history: runtime.history,
+      queue: runtime.queue,
+    });
+    if (_qaIsActiveSession(sessionKey)) _qaQueue = _qaCloneQueue(runtime.queue);
+    _processQaMessage(next.message, next.selection, {
+      sessionKey,
+      filePath: capturedFilePath,
+      docContext: (_qaSessions.get(sessionKey) || {}).docContext || capturedDocContext,
+    });
+  } else if (_qaIsActiveSession(sessionKey)) {
+    _qaQueue = [];
     document.getElementById('modal-qa-input')?.focus();
   }
 }
 
 function qaAbort() {
-  if (_qaAbortController) {
-    _qaAbortController.abort();
-    _qaAbortController = null;
+  const runtime = _qaGetRuntime(_qaSessionKey);
+  if (runtime?.abortController) {
+    runtime.abortController.abort();
+    runtime.abortController = null;
   }
-  // Don't reset _qaProcessing here — the catch block in _processQaMessage handles it,
-  // avoiding a double-drain race on _qaQueue from a microtask gap.
+  if (_qaAbortController) _qaAbortController = null;
+  // Don't reset _qaProcessing here — the catch block in _processQaMessage handles it.
   // Don't clear _qaQueue — queued messages auto-process after abort.
 }
 

package/dashboard/js/modal.js

@@ -13,24 +13,17 @@ function closeModal() {
   const resetBtn = document.getElementById('modal-settings-reset');
   if (resetBtn) resetBtn.remove();
   // Save Q&A session for this document (persist across modal open/close)
-  if (_qaSessionKey && (_qaHistory.length > 0 || _qaQueue.length > 0)) {
-    _qaSessions.set(_qaSessionKey, {
-      history: _qaHistory,
-      threadHtml: (document.getElementById('modal-qa-thread') || {}).innerHTML || '',
-      docContext: { ..._modalDocContext },
-      filePath: _modalFilePath,
-    });
-    _saveQaSessions();
+  if (_qaSessionKey && (_qaHistory.length > 0 || _qaQueue.length > 0 || _qaProcessing)) {
+    _qaSaveActiveSessionState();
   }
   // If still processing, show animated badge on the source card
   if (_qaProcessing && _modalFilePath) {
     const card = findCardForFile(_modalFilePath);
     if (card) showNotifBadge(card, 'processing');
   }
-  // Reset UI state but don't kill processing/queue — they run in background
+  // Reset active UI state but don't kill background processing — it is tracked per session
+  _qaResetActiveState();
   _modalDocContext = { title: '', content: '', selection: '' };
-  // Keep session key alive if processing is in flight — result will save when it completes
-  if (!_qaProcessing) _qaSessionKey = '';
   document.getElementById('modal-qa-input').value = '';
   document.getElementById('modal-qa-input').placeholder = 'Ask about this document (or select text first)...';
   document.getElementById('modal-qa-pill').style.display = 'none';

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.1026",
+  "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"