@yemi33/minions 0.1.531 → 0.1.533

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.533 (2026-04-07)
+
+### Fixes
+- convert blocking spawnSync/execSync to async execAsync (#447)
+
+## 0.1.532 (2026-04-07)
+
+### Fixes
+-  meeting cards show doc-chat processing dots and notification badges
+
 ## 0.1.531 (2026-04-07)
 
 ### Fixes

package/dashboard/js/render-meetings.js

@@ -48,7 +48,7 @@ function renderMeetings(meetings) {
     const dt = m.completedAt || m.createdAt;
     const timeStr = dt ? new Date(dt).toLocaleString(undefined, { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' }) : '';
 
-    return '<div style="background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:12px 16px;margin-bottom:8px;cursor:pointer" onclick="openMeetingDetail(\'' + escHtml(m.id) + '\')">' +
+    return '<div data-file="meetings/' + escHtml(m.id) + '.json" style="background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:12px 16px;margin-bottom:8px;cursor:pointer;position:relative" onclick="openMeetingDetail(\'' + escHtml(m.id) + '\')">' +
       '<div style="display:flex;justify-content:space-between;align-items:center">' +
         '<strong style="font-size:13px">' + escHtml(m.title) + '</strong>' +
         '<div style="display:flex;align-items:center;gap:8px">' +
@@ -78,6 +78,7 @@ function renderMeetings(meetings) {
     el.innerHTML += '<div style="text-align:center;margin-top:8px"><button class="pr-pager-btn" style="font-size:10px" onclick="_toggleArchivedMeetings()">' +
       (_showArchived ? 'Hide' : 'Show') + ' ' + archived.length + ' archived</button></div>';
   }
+  restoreNotifBadges();
 }
 
 function _mtgPrev() { if (_mtgPage > 0) { _mtgPage--; refresh(); } }

package/dashboard.js

@@ -22,7 +22,7 @@ const shared = require('./engine/shared');
 const queries = require('./engine/queries');
 const os = require('os');
 
-const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, getProjects: _getProjects, DONE_STATUSES, WI_STATUS } = shared;
+const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS } = shared;
 const { getAgents, getAgentDetail, getPrdInfo, getWorkItems, getDispatchQueue,
   getSkills, getInbox, getNotesWithMeta, getPullRequests,
   getEngineLog, getMetrics, getKnowledgeBaseEntries, timeSince,
@@ -1381,9 +1381,6 @@ const server = http.createServer(async (req, res) => {
       if (!body.title || !body.title.trim()) return jsonReply(res, 400, { error: 'title is required' });
       // Write as a work item with type 'plan' — user must explicitly execute plan-to-prd after reviewing
       const wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      let items = [];
-      const existing = safeRead(wiPath);
-      if (existing) { try { items = JSON.parse(existing); } catch {} }
       const id = 'W-' + shared.uid();
       const item = {
         id, title: body.title, type: 'plan',
@@ -1393,8 +1390,7 @@ const server = http.createServer(async (req, res) => {
       };
       if (body.project) item.project = body.project;
       if (body.agent) item.agent = body.agent;
-      items.push(item);
-      safeWrite(wiPath, items);
+      mutateWorkItems(wiPath, items => { items.push(item); });
       return jsonReply(res, 200, { ok: true, id, agent: body.agent || '' });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
@@ -1465,18 +1461,18 @@ const server = http.createServer(async (req, res) => {
       }
       for (const wiPath of wiSyncPaths) {
         try {
-          const items = safeJson(wiPath);
-          const wi = items.find(w => w.sourcePlan === body.source && w.id === body.itemId);
-          if (wi && wi.status === 'pending') {
-            if (body.name !== undefined) wi.title = 'Implement: ' + body.name;
-            if (body.description !== undefined) wi.description = body.description;
-            if (body.priority !== undefined) wi.priority = body.priority;
-            if (body.estimated_complexity !== undefined) {
-              wi.type = body.estimated_complexity === 'large' ? 'implement:large' : 'implement';
+          mutateWorkItems(wiPath, items => {
+            const wi = items.find(w => w.sourcePlan === body.source && w.id === body.itemId);
+            if (wi && wi.status === 'pending') {
+              if (body.name !== undefined) wi.title = 'Implement: ' + body.name;
+              if (body.description !== undefined) wi.description = body.description;
+              if (body.priority !== undefined) wi.priority = body.priority;
+              if (body.estimated_complexity !== undefined) {
+                wi.type = body.estimated_complexity === 'large' ? 'implement:large' : 'implement';
+              }
+              workItemSynced = true;
             }
-            safeWrite(wiPath, items);
-            workItemSynced = true;
-          }
+          });
         } catch (e) { console.error('work item sync:', e.message); }
       }
 
@@ -1500,26 +1496,21 @@ const server = http.createServer(async (req, res) => {
 
       // Also remove any materialized work item for this plan item
       let cancelled = false;
+      const allWiPaths = [path.join(MINIONS_DIR, 'work-items.json')];
       for (const proj of PROJECTS) {
-        const wiPath = shared.projectWorkItemsPath(proj);
+        allWiPaths.push(shared.projectWorkItemsPath(proj));
+      }
+      for (const wiPath of allWiPaths) {
         try {
-          const items = safeJson(wiPath);
-          const before = items.length;
-          const filtered = items.filter(w => !(w.sourcePlan === body.source && w.id === body.itemId));
-          if (filtered.length < before) {
-            safeWrite(wiPath, filtered);
-            cancelled = true;
-          }
+          mutateWorkItems(wiPath, items => {
+            const filtered = items.filter(w => !(w.sourcePlan === body.source && w.id === body.itemId));
+            if (filtered.length < items.length) {
+              cancelled = true;
+              return filtered;
+            }
+          });
         } catch (e) { console.error('work item cleanup:', e.message); }
       }
-      // Also check central work-items
-      const centralPath = path.join(MINIONS_DIR, 'work-items.json');
-      try {
-        const items = safeJson(centralPath);
-        const before = items.length;
-        const filtered = items.filter(w => !(w.sourcePlan === body.source && w.id === body.itemId));
-        if (filtered.length < before) { safeWrite(centralPath, filtered); cancelled = true; }
-      } catch (e) { console.error('central work item cleanup:', e.message); }
 
       // Clean dispatch entries for this item
       cleanDispatchEntries(d =>
@@ -2130,52 +2121,51 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       mutateJsonFileLocked(dispatchPath, (dispatch) => {
         for (const wiPath of wiPaths) {
           try {
-            const items = safeJson(wiPath);
-            if (!items) continue;
-            let changed = false;
-            for (const w of items) {
-              if (w.sourcePlan !== body.file) continue;
-              // Keep completed items as-is, reset everything else to pending.
-              if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
-
-              if (w.status === WI_STATUS.DISPATCHED) {
-                // Kill the agent working on this item, if any.
-                const activeEntry = (dispatch.active || []).find(d => d.meta?.item?.id === w.id || d.meta?.dispatchKey?.includes(w.id));
-                if (activeEntry) {
-                  const statusPath = path.join(MINIONS_DIR, 'agents', activeEntry.agent, 'status.json');
-                  try {
-                    const agentStatus = JSON.parse(safeRead(statusPath) || '{}');
-                    if (agentStatus.pid) {
-                      try {
-                        const safePid = shared.validatePid(agentStatus.pid);
-                        if (process.platform === 'win32') {
-                          require('child_process').execFileSync('taskkill', ['/PID', String(safePid), '/F', '/T'], { stdio: 'pipe', timeout: 5000, windowsHide: true });
-                        } else {
-                          process.kill(safePid, 'SIGTERM');
-                        }
-                      } catch { /* process may be dead or invalid PID */ }
-                    }
-                    agentStatus.status = 'idle';
-                    delete agentStatus.currentTask;
-                    delete agentStatus.dispatched;
-                    safeWrite(statusPath, agentStatus);
-                  } catch (e) { console.error('agent reset:', e.message); }
-                  killedAgents.add(activeEntry.agent);
+            mutateWorkItems(wiPath, items => {
+              let changed = false;
+              for (const w of items) {
+                if (w.sourcePlan !== body.file) continue;
+                // Keep completed items as-is, reset everything else to pending.
+                if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
+
+                if (w.status === WI_STATUS.DISPATCHED) {
+                  // Kill the agent working on this item, if any.
+                  const activeEntry = (dispatch.active || []).find(d => d.meta?.item?.id === w.id || d.meta?.dispatchKey?.includes(w.id));
+                  if (activeEntry) {
+                    const statusPath = path.join(MINIONS_DIR, 'agents', activeEntry.agent, 'status.json');
+                    try {
+                      const agentStatus = JSON.parse(safeRead(statusPath) || '{}');
+                      if (agentStatus.pid) {
+                        try {
+                          const safePid = shared.validatePid(agentStatus.pid);
+                          if (process.platform === 'win32') {
+                            require('child_process').execFileSync('taskkill', ['/PID', String(safePid), '/F', '/T'], { stdio: 'pipe', timeout: 5000, windowsHide: true });
+                          } else {
+                            process.kill(safePid, 'SIGTERM');
+                          }
+                        } catch { /* process may be dead or invalid PID */ }
+                      }
+                      agentStatus.status = 'idle';
+                      delete agentStatus.currentTask;
+                      delete agentStatus.dispatched;
+                      safeWrite(statusPath, agentStatus);
+                    } catch (e) { console.error('agent reset:', e.message); }
+                    killedAgents.add(activeEntry.agent);
+                  }
                 }
-              }
 
-              if (w.status !== WI_STATUS.PAUSED) reset++;
-              w.status = WI_STATUS.PAUSED;
-              w._pausedBy = 'prd-pause';
-              delete w._resumedAt;
-              delete w.dispatched_at;
-              delete w.dispatched_to;
-              delete w.failReason;
-              delete w.failedAt;
-              changed = true;
-              if (w.id) resetItemIds.add(w.id);
-            }
-            if (changed) safeWrite(wiPath, items);
+                if (w.status !== WI_STATUS.PAUSED) reset++;
+                w.status = WI_STATUS.PAUSED;
+                w._pausedBy = 'prd-pause';
+                delete w._resumedAt;
+                delete w.dispatched_at;
+                delete w.dispatched_to;
+                delete w.failReason;
+                delete w.failedAt;
+                changed = true;
+                if (w.id) resetItemIds.add(w.id);
+              }
+            });
           } catch (e) { console.error('reset work items:', e.message); }
         }
 
@@ -2220,13 +2210,15 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       const config = queries.getConfig();
       for (const p of getProjects(config)) {
         const projWiPath = projectWorkItemsPath(p);
-        const projItems = safeJson(projWiPath);
-        if (!projItems) continue;
-        const filtered = projItems.filter(w => {
-          if (w.sourcePlan !== body.file) return true; // different plan, keep
-          return completedStatuses.has(w.status); // keep completed, remove pending/failed
-        });
-        if (filtered.length < projItems.length) safeWrite(projWiPath, filtered);
+        try {
+          mutateWorkItems(projWiPath, items => {
+            const filtered = items.filter(w => {
+              if (w.sourcePlan !== body.file) return true; // different plan, keep
+              return completedStatuses.has(w.status); // keep completed, remove pending/failed
+            });
+            if (filtered.length < items.length) return filtered;
+          });
+        } catch { /* project may not have work items */ }
       }
 
       // Delete old PRD — agent will write replacement at same path
@@ -2234,30 +2226,29 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       // Queue plan-to-prd regeneration with instructions to preserve completed items
       const wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      let items = [];
-      const existing = safeRead(wiPath);
-      if (existing) { try { items = JSON.parse(existing); } catch {} }
-
-      // Dedup: check if already queued
-      const alreadyQueued = items.find(w =>
-        w.type === 'plan-to-prd' && w.planFile === plan.source_plan && (w.status === 'pending' || w.status === 'dispatched')
-      );
-      if (alreadyQueued) return jsonReply(res, 200, { id: alreadyQueued.id, alreadyQueued: true });
 
       const completedContext = completedItems.length > 0
         ? `\n\n**Previously completed items (preserve their status in the new PRD):**\n${completedItems.map(i => `- ${i.id}: ${i.name} [${i.status}]`).join('\n')}`
         : '';
 
       const id = 'W-' + shared.uid();
-      items.push({
-        id, title: `Regenerate PRD: ${plan.plan_summary || plan.source_plan}`,
-        type: 'plan-to-prd', priority: 'high',
-        description: `Plan file: plans/${plan.source_plan}\nTarget PRD filename: ${body.file}\nRegeneration requested by user after plan revision.${completedContext}`,
-        status: 'pending', created: new Date().toISOString(), createdBy: 'dashboard:regenerate',
-        project: plan.project || '', planFile: plan.source_plan,
-        _targetPrdFile: body.file,
+      let alreadyQueuedId = null;
+      mutateWorkItems(wiPath, items => {
+        // Dedup: check if already queued
+        const alreadyQueued = items.find(w =>
+          w.type === 'plan-to-prd' && w.planFile === plan.source_plan && (w.status === 'pending' || w.status === 'dispatched')
+        );
+        if (alreadyQueued) { alreadyQueuedId = alreadyQueued.id; return; }
+        items.push({
+          id, title: `Regenerate PRD: ${plan.plan_summary || plan.source_plan}`,
+          type: 'plan-to-prd', priority: 'high',
+          description: `Plan file: plans/${plan.source_plan}\nTarget PRD filename: ${body.file}\nRegeneration requested by user after plan revision.${completedContext}`,
+          status: 'pending', created: new Date().toISOString(), createdBy: 'dashboard:regenerate',
+          project: plan.project || '', planFile: plan.source_plan,
+          _targetPrdFile: body.file,
+        });
       });
-      safeWrite(wiPath, items);
+      if (alreadyQueuedId) return jsonReply(res, 200, { id: alreadyQueuedId, alreadyQueued: true });
       return jsonReply(res, 200, { id, file: plan.source_plan });
     } catch (e) { return jsonReply(res, 500, { error: e.message }); }
   }
@@ -2334,27 +2325,26 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       for (const wiInfo of wiPaths) {
         try {
-          const items = safeJson(wiInfo.path);
-          const filtered = [];
-          for (const w of items) {
-            if (w.sourcePlan === body.source) {
-              materializedPlanItemIds.add(w.id);
-              if (w.status === 'pending' || w.status === 'failed') {
-                // Delete — will re-materialize on next tick with updated plan data
-                reset++;
-                deletedItemIds.push(w.id);
+          mutateWorkItems(wiInfo.path, items => {
+            const filtered = [];
+            for (const w of items) {
+              if (w.sourcePlan === body.source) {
+                materializedPlanItemIds.add(w.id);
+                if (w.status === 'pending' || w.status === 'failed') {
+                  // Delete — will re-materialize on next tick with updated plan data
+                  reset++;
+                  deletedItemIds.push(w.id);
+                } else {
+                  // dispatched or done — leave alone
+                  kept++;
+                  filtered.push(w);
+                }
               } else {
-                // dispatched or done — leave alone
-                kept++;
                 filtered.push(w);
               }
-            } else {
-              filtered.push(w);
             }
-          }
-          if (filtered.length < items.length) {
-            safeWrite(wiInfo.path, filtered);
-          }
+            if (filtered.length < items.length) return filtered;
+          });
         } catch (e) { console.error('work item sync:', e.message); }
       }
 
@@ -2396,13 +2386,13 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       }
       for (const wiPath of wiPaths) {
         try {
-          const items = safeJsonArr(wiPath);
-          if (!items) continue;
-          const filtered = items.filter(w => w.sourcePlan !== body.file);
-          if (filtered.length < items.length) {
-            cleaned += items.length - filtered.length;
-            safeWrite(wiPath, filtered);
-          }
+          mutateWorkItems(wiPath, items => {
+            const filtered = items.filter(w => w.sourcePlan !== body.file);
+            if (filtered.length < items.length) {
+              cleaned += items.length - filtered.length;
+              return filtered;
+            }
+          });
         } catch (e) { console.error('plan cleanup:', e.message); }
       }
 
@@ -2417,16 +2407,14 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       if (prdSourcePlan) {
         try {
           const centralPath = path.join(MINIONS_DIR, 'work-items.json');
-          const centralItems = safeJson(centralPath) || [];
-          let changed = false;
-          for (const w of centralItems) {
-            if (w.type === 'plan-to-prd' && w.status === 'done' && w.planFile === prdSourcePlan) {
-              w.status = 'cancelled';
-              w._cancelledBy = 'prd-deleted';
-              changed = true;
+          mutateWorkItems(centralPath, items => {
+            for (const w of items) {
+              if (w.type === 'plan-to-prd' && w.status === 'done' && w.planFile === prdSourcePlan) {
+                w.status = 'cancelled';
+                w._cancelledBy = 'prd-deleted';
+              }
             }
-          }
-          if (changed) safeWrite(centralPath, centralItems);
+          });
         } catch (e) { console.error('plan-to-prd cleanup:', e.message); }
       }
 
@@ -2521,19 +2509,17 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       // Create a work item to revise the plan
       const wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      let items = [];
-      const existing = safeRead(wiPath);
-      if (existing) { try { items = JSON.parse(existing); } catch {} }
       const id = 'W-' + shared.uid();
-      items.push({
-        id, title: 'Revise plan: ' + (plan.plan_summary || body.file),
-        type: 'plan-to-prd', priority: 'high',
-        description: 'Revision requested on plan file: ' + (body.file.endsWith('.json') ? 'prd/' : 'plans/') + body.file + '\n\nFeedback:\n' + body.feedback + '\n\nRevise the plan to address this feedback. Read the existing plan, apply the feedback, and overwrite the file with the updated version. Set status back to "awaiting-approval".',
-        status: 'pending', created: new Date().toISOString(), createdBy: 'dashboard:revision',
-        project: plan.project || '',
-        planFile: body.file,
+      mutateWorkItems(wiPath, items => {
+        items.push({
+          id, title: 'Revise plan: ' + (plan.plan_summary || body.file),
+          type: 'plan-to-prd', priority: 'high',
+          description: 'Revision requested on plan file: ' + (body.file.endsWith('.json') ? 'prd/' : 'plans/') + body.file + '\n\nFeedback:\n' + body.feedback + '\n\nRevise the plan to address this feedback. Read the existing plan, apply the feedback, and overwrite the file with the updated version. Set status back to "awaiting-approval".',
+          status: 'pending', created: new Date().toISOString(), createdBy: 'dashboard:revision',
+          project: plan.project || '',
+          planFile: body.file,
+        });
       });
-      safeWrite(wiPath, items);
       return jsonReply(res, 200, { ok: true, status: 'revision-requested', workItemId: id });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
@@ -2624,22 +2610,23 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
       const deletedItemIds = [];
       for (const wiInfo of wiPaths) {
         try {
-          const items = safeJson(wiInfo.path);
-          const filtered = [];
-          for (const w of items) {
-            if (w.sourcePlan === body.source) {
-              if (w.status === 'pending' || w.status === 'failed') {
-                reset++;
-                deletedItemIds.push(w.id);
+          mutateWorkItems(wiInfo.path, items => {
+            const filtered = [];
+            for (const w of items) {
+              if (w.sourcePlan === body.source) {
+                if (w.status === 'pending' || w.status === 'failed') {
+                  reset++;
+                  deletedItemIds.push(w.id);
+                } else {
+                  kept++;
+                  filtered.push(w);
+                }
               } else {
-                kept++;
                 filtered.push(w);
               }
-            } else {
-              filtered.push(w);
             }
-          }
-          if (filtered.length < items.length) safeWrite(wiInfo.path, filtered);
+            if (filtered.length < items.length) return filtered;
+          });
         } catch (e) { console.error('work item deletion:', e.message); }
       }
       for (const itemId of deletedItemIds) {
@@ -2650,22 +2637,21 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       // Step 4: Dispatch plan-to-prd to regenerate PRD from revised plan
       const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-      let centralItems = [];
-      try { centralItems = JSON.parse(safeRead(centralWiPath) || '[]'); } catch {}
       const wiId = 'W-' + shared.uid();
-      centralItems.push({
-        id: wiId,
-        title: 'Regenerate PRD from revised plan: ' + sourcePlanFile,
-        type: 'plan-to-prd',
-        priority: 'high',
-        description: `The source plan \`${sourcePlanFile}\` has been revised. Convert it into a fresh PRD JSON.\n\nRevision instruction: ${body.instruction}\n\nRead the revised plan, generate updated PRD items (missing_features), and write to \`prd/${body.source}\`. Set status to "approved". Include \`"source_plan": "${sourcePlanFile}"\` in the JSON root.\n\nPreserve items that are already done (status "implemented" or "complete"). Reset or replace items that were pending/failed.`,
-        status: 'pending',
-        created: new Date().toISOString(),
-        createdBy: 'dashboard:revise-and-regenerate',
-        project: prd.project || '',
-        planFile: sourcePlanFile,
+      mutateWorkItems(centralWiPath, items => {
+        items.push({
+          id: wiId,
+          title: 'Regenerate PRD from revised plan: ' + sourcePlanFile,
+          type: 'plan-to-prd',
+          priority: 'high',
+          description: `The source plan \`${sourcePlanFile}\` has been revised. Convert it into a fresh PRD JSON.\n\nRevision instruction: ${body.instruction}\n\nRead the revised plan, generate updated PRD items (missing_features), and write to \`prd/${body.source}\`. Set status to "approved". Include \`"source_plan": "${sourcePlanFile}"\` in the JSON root.\n\nPreserve items that are already done (status "implemented" or "complete"). Reset or replace items that were pending/failed.`,
+          status: 'pending',
+          created: new Date().toISOString(),
+          createdBy: 'dashboard:revise-and-regenerate',
+          project: prd.project || '',
+          planFile: sourcePlanFile,
+        });
       });
-      safeWrite(centralWiPath, centralItems);
 
       return jsonReply(res, 200, {
         ok: true,
@@ -3728,24 +3714,27 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const projects = shared.getProjects(CONFIG);
       const paths = [path.join(MINIONS_DIR, 'work-items.json')];
       for (const p of projects) paths.push(shared.projectWorkItemsPath(p));
+      let found = null;
       for (const wiPath of paths) {
-        const items = JSON.parse(safeRead(wiPath) || '[]');
-        const item = items.find(i => i.id === id);
-        if (!item) continue;
-        item._humanFeedback = { rating, comment: comment || '', at: new Date().toISOString() };
-        safeWrite(wiPath, items);
-        const agent = item.dispatched_to || item.agent || 'unknown';
-        const feedbackNote = '# Human Feedback on ' + id + '\n\n' +
-          '**Rating:** ' + (rating === 'up' ? '👍 Good' : '👎 Needs improvement') + '\n' +
-          '**Item:** ' + (item.title || id) + '\n' +
-          '**Agent:** ' + agent + '\n' +
-          (comment ? '**Feedback:** ' + comment + '\n' : '');
-        const inboxPath = path.join(MINIONS_DIR, 'notes', 'inbox', agent + '-feedback-' + new Date().toISOString().slice(0, 10) + '-' + shared.uid().slice(0, 4) + '.md');
-        safeWrite(inboxPath, feedbackNote);
-        invalidateStatusCache();
-        return jsonReply(res, 200, { ok: true });
+        mutateWorkItems(wiPath, items => {
+          const item = items.find(i => i.id === id);
+          if (item && !found) {
+            item._humanFeedback = { rating, comment: comment || '', at: new Date().toISOString() };
+            found = { agent: item.dispatched_to || item.agent || 'unknown', title: item.title || id };
+          }
+        });
+        if (found) break;
       }
-      return jsonReply(res, 404, { error: 'Work item not found' });
+      if (!found) return jsonReply(res, 404, { error: 'Work item not found' });
+      const feedbackNote = '# Human Feedback on ' + id + '\n\n' +
+        '**Rating:** ' + (rating === 'up' ? '👍 Good' : '👎 Needs improvement') + '\n' +
+        '**Item:** ' + found.title + '\n' +
+        '**Agent:** ' + found.agent + '\n' +
+        (comment ? '**Feedback:** ' + comment + '\n' : '');
+      const inboxPath = path.join(MINIONS_DIR, 'notes', 'inbox', found.agent + '-feedback-' + new Date().toISOString().slice(0, 10) + '-' + shared.uid().slice(0, 4) + '.md');
+      safeWrite(inboxPath, feedbackNote);
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true });
     }},
 
     // Pinned notes

package/engine/ado.js

@@ -5,7 +5,7 @@
 
 const path = require('path');
 const shared = require('./shared');
-const { exec, getAdoOrgBase, addPrLink, log, ts, dateStamp, PR_STATUS } = shared;
+const { exec, execAsync, getAdoOrgBase, addPrLink, log, ts, dateStamp, PR_STATUS } = shared;
 const { getPrs } = require('./queries');
 const { mutateJsonFileLocked } = shared;
 
@@ -21,7 +21,7 @@ function engine() {
 let _adoTokenCache = { token: null, expiresAt: 0 };
 let _adoTokenFailedUntil = 0; // backoff: skip azureauth calls until this timestamp
 
-function getAdoToken() {
+async function getAdoToken() {
   if (_adoTokenCache.token && Date.now() < _adoTokenCache.expiresAt) {
     return _adoTokenCache.token;
   }
@@ -30,8 +30,9 @@ function getAdoToken() {
   try {
     // azureauth supports multiple --mode flags as an ordered fallback chain:
     // tries IWA (Integrated Windows Auth) first, falls back to broker if unavailable.
-    const token = exec('azureauth ado token --mode iwa --mode broker --output token --timeout 1', {
-      timeout: 15000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true    }).trim();
+    // Uses execAsync to avoid blocking the event loop on Windows (spawnSync ETIMEDOUT).
+    const token = (await execAsync('azureauth ado token --mode iwa --mode broker --output token --timeout 1', {
+      timeout: 15000, encoding: 'utf-8', windowsHide: true    })).trim();
     if (token && token.startsWith('eyJ')) {
       _adoTokenCache = { token, expiresAt: Date.now() + 30 * 60 * 1000 };
       _adoTokenFailedUntil = 0;
@@ -56,7 +57,7 @@ async function adoFetch(url, token, _retryCount = 0) {
     // Invalidate cached token — it's likely expired
     _adoTokenCache = { token: null, expiresAt: 0 };
     if (_retryCount < MAX_RETRIES) {
-      const freshToken = getAdoToken();
+      const freshToken = await getAdoToken();
       if (freshToken) {
         log('info', 'ADO token expired mid-session — refreshed and retrying');
         return adoFetch(url, freshToken, _retryCount + 1);
@@ -132,7 +133,7 @@ async function forEachActivePr(config, token, callback) {
 // ─── PR Status Polling ───────────────────────────────────────────────────────
 
 async function pollPrStatus(config) {
-  const token = getAdoToken();
+  const token = await getAdoToken();
   if (!token) {
     log('warn', 'Skipping PR status poll — no ADO token available');
     return;
@@ -287,7 +288,7 @@ async function pollPrStatus(config) {
 // ─── Poll Human Comments on PRs ──────────────────────────────────────────────
 
 async function pollPrHumanComments(config) {
-  const token = getAdoToken();
+  const token = await getAdoToken();
   if (!token) return;
 
   const totalUpdated = await forEachActivePr(config, token, async (project, pr, prNum, orgBase) => {
@@ -361,7 +362,7 @@ async function pollPrHumanComments(config) {
  * in pull-requests.json, and add them. Matches PRs to work items by branch name.
  */
 async function reconcilePrs(config) {
-  const token = getAdoToken();
+  const token = await getAdoToken();
   if (!token) {
     log('warn', 'Skipping PR reconciliation — no ADO token available');
     return;
@@ -486,19 +487,19 @@ async function reconcilePrs(config) {
 }
 
 /**
- * Fetch live review status for a single PR from ADO (synchronous).
+ * Fetch live review status for a single PR from ADO (async).
  * Returns 'approved', 'changes-requested', 'waiting', or 'pending'.
  * Returns null if the check fails (token unavailable, API error).
  * Used as a pre-dispatch gate to avoid dispatching reviews for already-approved PRs.
  */
-function checkLiveReviewStatus(pr, project) {
+async function checkLiveReviewStatus(pr, project) {
   try {
-    const token = getAdoToken();
+    const token = await getAdoToken();
     if (!token) return null;
     const orgBase = shared.getAdoOrgBase(project);
     const prNum = (pr.id || '').replace(/^PR-/, '');
     const url = `${orgBase}/${project.adoProject}/_apis/git/repositories/${project.repositoryId}/pullrequests/${prNum}?api-version=7.1`;
-    const result = exec(`curl -s --max-time 4 -H "Authorization: Bearer ${token}" "${url}"`, { encoding: 'utf-8', timeout: 5000, windowsHide: true });
+    const result = await execAsync(`curl -s --max-time 4 -H "Authorization: Bearer ${token}" "${url}"`, { encoding: 'utf-8', timeout: 5000, windowsHide: true });
     const prData = JSON.parse(result);
     const votes = (prData.reviewers || []).map(r => r.vote).filter(v => v !== undefined);
     if (votes.length === 0) return 'pending';

package/engine/github.js

@@ -5,7 +5,7 @@
  */
 
 const shared = require('./shared');
-const { exec, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeWrite, mutateJsonFileLocked, MINIONS_DIR, addPrLink, getPrLinks, log, ts, dateStamp, PR_STATUS } = shared;
+const { exec, execAsync, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeWrite, mutateJsonFileLocked, MINIONS_DIR, addPrLink, getPrLinks, log, ts, dateStamp, PR_STATUS } = shared;
 const { getPrs } = require('./queries');
 const path = require('path');
 
@@ -69,10 +69,10 @@ function resetSlugBackoff(slug) {
 }
 
 /** Run a `gh api` call and parse JSON result. Returns null on failure. */
-function ghApi(endpoint, slug) {
+async function ghApi(endpoint, slug) {
   try {
     const cmd = `gh api "repos/${slug}${endpoint}"`;
-    const result = exec(cmd, { timeout: 30000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    const result = await execAsync(cmd, { timeout: 30000, encoding: 'utf-8' });
     return JSON.parse(result);
   } catch (e) {
     log('warn', `GitHub API error (${endpoint}): ${e.message}`);
@@ -84,8 +84,8 @@ function ghApi(endpoint, slug) {
  * Run a `gh api` call with per-slug backoff tracking. Returns null on failure.
  * On success, resets the slug's backoff. On failure, increments it.
  */
-function ghApiWithBackoff(endpoint, slug) {
-  const result = ghApi(endpoint, slug);
+async function ghApiWithBackoff(endpoint, slug) {
+  const result = await ghApi(endpoint, slug);
   if (result === null) {
     recordSlugFailure(slug);
   } else {
@@ -112,7 +112,7 @@ async function forEachActiveGhPr(config, callback) {
     if (activePrs.length === 0) continue;
 
     // Probe repo accessibility before iterating PRs — avoids N warnings per inaccessible repo
-    const probe = ghApi('', slug);
+    const probe = await ghApi('', slug);
     if (probe === null) {
       recordSlugFailure(slug);
       continue;
@@ -171,7 +171,7 @@ async function forEachActiveGhPr(config, callback) {
       if (updated) {
         // Also update title/author/branch if still placeholder
         if (pr.title.includes('polling...') || pr.agent === 'human') {
-          const prData = ghApi(`/pulls/${prNum}`, slug);
+          const prData = await ghApi(`/pulls/${prNum}`, slug);
           if (prData) {
             if (pr.title.includes('polling...')) pr.title = (prData.title || pr.title).slice(0, 120);
             if (pr.agent === 'human' && prData.user?.login) pr.agent = prData.user.login;
@@ -203,7 +203,7 @@ async function forEachActiveGhPr(config, callback) {
 
 async function pollPrStatus(config) {
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
-    const prData = ghApi(`/pulls/${prNum}`, slug);
+    const prData = await ghApi(`/pulls/${prNum}`, slug);
     if (!prData) return false;
 
     let updated = false;
@@ -243,7 +243,7 @@ async function pollPrStatus(config) {
     }
 
     // Review status from GitHub reviews
-    const reviews = ghApi(`/pulls/${prNum}/reviews`, slug);
+    const reviews = await ghApi(`/pulls/${prNum}/reviews`, slug);
     if (reviews && Array.isArray(reviews)) {
       // Get latest review per user
       const latestByUser = new Map();
@@ -306,7 +306,7 @@ async function pollPrStatus(config) {
 
     // Check status / checks
     if (prData.state === 'open' && prData.head?.sha) {
-      const checksData = ghApi(`/commits/${prData.head.sha}/check-runs`, slug);
+      const checksData = await ghApi(`/commits/${prData.head.sha}/check-runs`, slug);
       if (checksData && checksData.check_runs) {
         const runs = checksData.check_runs;
         let buildStatus = 'none';
@@ -352,11 +352,11 @@ async function pollPrStatus(config) {
 async function pollPrHumanComments(config) {
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
     // Get issue comments (general PR comments)
-    const comments = ghApi(`/issues/${prNum}/comments`, slug);
+    const comments = await ghApi(`/issues/${prNum}/comments`, slug);
     if (!comments || !Array.isArray(comments)) return false;
 
     // Also get review comments (inline code comments)
-    const reviewComments = ghApi(`/pulls/${prNum}/comments`, slug);
+    const reviewComments = await ghApi(`/pulls/${prNum}/comments`, slug);
     const allComments = [
       ...(comments || []).map(c => ({ ...c, _type: 'issue' })),
       ...(Array.isArray(reviewComments) ? reviewComments : []).map(c => ({ ...c, _type: 'review' }))
@@ -438,7 +438,7 @@ async function reconcilePrs(config) {
     if (isSlugInBackoff(slug)) continue;
 
     // Fetch open PRs
-    const prsData = ghApi('/pulls?state=open&per_page=100', slug);
+    const prsData = await ghApi('/pulls?state=open&per_page=100', slug);
     if (!prsData || !Array.isArray(prsData)) {
       recordSlugFailure(slug);
       continue;
@@ -541,12 +541,12 @@ async function reconcilePrs(config) {
  * Fetch live review status for a single PR from GitHub. Returns 'approved', 'changes-requested',
  * 'waiting', or 'pending'. Returns null if the check fails.
  */
-function checkLiveReviewStatus(pr, project) {
+async function checkLiveReviewStatus(pr, project) {
   try {
     const slug = getRepoSlug(project);
     if (!slug) return null;
     const prNum = (pr.id || '').replace(/^PR-/, '');
-    const reviews = ghApi(`/pulls/${prNum}/reviews`, slug);
+    const reviews = await ghApi(`/pulls/${prNum}/reviews`, slug);
     if (!reviews || !Array.isArray(reviews)) return null;
     const latestByUser = new Map();
     for (const r of reviews) {

package/engine/lifecycle.js

@@ -689,7 +689,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
 
 // ─── Post-Completion Hooks ──────────────────────────────────────────────────
 
-function updatePrAfterReview(agentId, pr, project, config) {
+async function updatePrAfterReview(agentId, pr, project, config) {
 
   if (!pr?.id) return;
 
@@ -707,7 +707,7 @@ function updatePrAfterReview(agentId, pr, project, config) {
       const checkFn = host === 'github'
         ? require('./github').checkLiveReviewStatus
         : require('./ado').checkLiveReviewStatus;
-      const liveStatus = checkFn(pr, projectObj);
+      const liveStatus = await checkFn(pr, projectObj);
       // Use live status only if it's a decisive verdict (not 'pending' — review may not have propagated yet)
       if (liveStatus && liveStatus !== 'pending') postReviewStatus = liveStatus;
     }
@@ -1142,7 +1142,7 @@ function handleDecompositionResult(stdout, meta, config) {
   return 0;
 }
 
-function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
+async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
 
   const type = dispatchItem.type;
   const meta = dispatchItem.meta;
@@ -1319,7 +1319,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
     }
   }
 
-  if (type === WORK_TYPE.REVIEW) updatePrAfterReview(agentId, meta?.pr, meta?.project, config);
+  if (type === WORK_TYPE.REVIEW) await updatePrAfterReview(agentId, meta?.pr, meta?.project, config);
   if (type === WORK_TYPE.FIX) updatePrAfterFix(meta?.pr, meta?.project, meta?.source);
   checkForLearnings(agentId, config.agents[agentId], dispatchItem.task);
   if (effectiveSuccess) {

package/engine/shared.js

@@ -304,7 +304,7 @@ function writeToInbox(agentId, slug, content, _inboxDir) {
 // ── Process Spawning ────────────────────────────────────────────────────────
 // All child process calls go through these to ensure windowsHide: true
 
-const { execSync: _execSync, spawnSync: _spawnSync, spawn: _spawn } = require('child_process');
+const { execSync: _execSync, spawnSync: _spawnSync, spawn: _spawn, exec: _cbExec } = require('child_process');
 
 function exec(cmd, opts = {}) {
   return _execSync(cmd, { windowsHide: true, ...opts });
@@ -322,6 +322,31 @@ function execSilent(cmd, opts = {}) {
   return _execSync(cmd, { stdio: 'pipe', windowsHide: true, ...opts });
 }
 
+/**
+ * Async version of exec() — runs a shell command without blocking the event loop.
+ * Returns a Promise that resolves with { stdout, stderr } or rejects on error/timeout.
+ * Drop-in replacement for sync `exec()` in async contexts.
+ *
+ * @param {string} cmd - Shell command to run
+ * @param {object} opts - Options (same as child_process.exec: timeout, cwd, encoding, env, etc.)
+ * @returns {Promise<string>} stdout (trimmed if encoding is set)
+ */
+function execAsync(cmd, opts = {}) {
+  const { timeout, ...rest } = opts;
+  return new Promise((resolve, reject) => {
+    const child = _cbExec(cmd, { windowsHide: true, encoding: 'utf8', ...rest, timeout: timeout || 30000 }, (err, stdout, stderr) => {
+      if (err) {
+        err.stderr = stderr;
+        err.stdout = stdout;
+        return reject(err);
+      }
+      resolve(stdout);
+    });
+    // Safety: ensure child is killed if parent process exits
+    child.unref && child.unref();
+  });
+}
+
 /**
  * Detect the default branch for a git repo. Tries in order:
  * 1. The configured mainBranch (if it exists as a local or remote ref)
@@ -787,6 +812,7 @@ module.exports = {
   uniquePath,
   writeToInbox,
   exec,
+  execAsync,
   execSilent,
   resolveMainBranch,
   run,

package/engine/timeout.js

@@ -149,8 +149,8 @@ function checkTimeouts(config) {
 
         completeDispatch(item.id, isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR, 'Completed (detected from output)');
 
-        // Run post-completion hooks via shared helper
-        runPostCompletionHooks(item, item.agent, isSuccess ? 0 : 1, liveLog, config);
+        // Run post-completion hooks via shared helper (async — fire and forget in timeout context)
+        runPostCompletionHooks(item, item.agent, isSuccess ? 0 : 1, liveLog, config).catch(e => log('warn', 'post-completion hooks: ' + e.message));
 
         if (hasProcess) {
           shared.killImmediate(activeProcesses.get(item.id)?.proc);

package/engine.js

@@ -24,7 +24,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./engine/shared');
-const { exec, execSilent, runFile, ts, ENGINE_DEFAULTS: DEFAULTS,
+const { exec, execAsync, execSilent, runFile, ts, ENGINE_DEFAULTS: DEFAULTS,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT } = shared;
 const queries = require('./engine/queries');
 
@@ -141,6 +141,10 @@ const activeProcesses = new Map(); // dispatchId → { proc, agentId, startedAt
 // tempAgents imported from engine/routing.js
 let engineRestartGraceUntil = 0; // timestamp — suppress orphan detection until this time
 
+// Per-tick cache of refs that failed to fetch — avoids repeating 30s ETIMEDOUT for same missing ref
+// Cleared at the start of each tick cycle (see tickInner)
+const _failedRefCache = new Set();
+
 // Resolve dependency plan item IDs to their PR branches
 function resolveDependencyBranches(depIds, sourcePlan, project, config) {
   const results = []; // [{ branch, prId }]
@@ -171,9 +175,9 @@ function resolveDependencyBranches(depIds, sourcePlan, project, config) {
 }
 
 // Find an existing worktree already checked out on a given branch
-function findExistingWorktree(repoDir, branchName) {
+async function findExistingWorktree(repoDir, branchName) {
   try {
-    const out = exec(`git worktree list --porcelain`, { cwd: repoDir, stdio: 'pipe', timeout: 10000 }).toString();
+    const out = await execAsync(`git worktree list --porcelain`, { cwd: repoDir, timeout: 10000 });
     const branchRef = `branch refs/heads/${branchName}`;
     const lines = out.split('\n');
     for (let i = 0; i < lines.length; i++) {
@@ -215,17 +219,17 @@ function removeStaleIndexLock(rootDir) {
   } catch (e) { log('warn', 'git: ' + e.message); }
 }
 
-function runWorktreeAdd(rootDir, worktreePath, args, gitOpts, worktreeCreateRetries) {
+async function runWorktreeAdd(rootDir, worktreePath, args, gitOpts, worktreeCreateRetries) {
   let lastErr = null;
   const retries = Math.max(0, Number(worktreeCreateRetries) || 0);
   for (let attempt = 0; attempt <= retries; attempt++) {
     try {
       if (attempt > 0) {
-        try { exec('git worktree prune', { ...gitOpts, cwd: rootDir, timeout: 15000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+        try { await execAsync('git worktree prune', { ...gitOpts, cwd: rootDir, timeout: 15000 }); } catch (e) { log('warn', 'git: ' + e.message); }
         removeStaleIndexLock(rootDir);
         log('warn', `Retrying git worktree add (attempt ${attempt + 1}/${retries + 1}) for ${path.basename(worktreePath)}`);
       }
-      exec(`git worktree add "${worktreePath}" ${args}`, { ...gitOpts, cwd: rootDir });
+      await execAsync(`git worktree add "${worktreePath}" ${args}`, { ...gitOpts, cwd: rootDir });
       return;
     } catch (err) {
       lastErr = err;
@@ -235,14 +239,14 @@ function runWorktreeAdd(rootDir, worktreePath, args, gitOpts, worktreeCreateRetr
   if (lastErr) throw lastErr;
 }
 
-function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts) {
+async function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts) {
   if (!branchName) return false;
-  const existingWt = findExistingWorktree(rootDir, branchName);
+  const existingWt = await findExistingWorktree(rootDir, branchName);
   if (existingWt && fs.existsSync(existingWt)) return true;
   if (!fs.existsSync(worktreePath)) return false;
   try {
-    exec(`git -C "${worktreePath}" rev-parse --is-inside-work-tree`, { ...gitOpts, timeout: 10000 });
-    exec(`git -C "${worktreePath}" rev-parse --abbrev-ref HEAD`, { ...gitOpts, timeout: 10000 });
+    await execAsync(`git -C "${worktreePath}" rev-parse --is-inside-work-tree`, { ...gitOpts, timeout: 10000 });
+    await execAsync(`git -C "${worktreePath}" rev-parse --abbrev-ref HEAD`, { ...gitOpts, timeout: 10000 });
     log('warn', `Recovered partially-created worktree for ${branchName} at ${worktreePath}`);
     return true;
   } catch {
@@ -250,7 +254,7 @@ function recoverPartialWorktree(rootDir, worktreePath, branchName, gitOpts) {
   }
 }
 
-function spawnAgent(dispatchItem, config) {
+async function spawnAgent(dispatchItem, config) {
   const { id, agent: agentId, prompt: taskPrompt, type, meta } = dispatchItem;
   const claudeConfig = config.claude || {};
   const engineConfig = config.engine || {};
@@ -279,12 +283,12 @@ function spawnAgent(dispatchItem, config) {
     worktreePath = path.resolve(rootDir, engineConfig.worktreeRoot || '../worktrees', wtDirName);
 
     // If branch is already checked out in an existing worktree, reuse it
-    const existingWt = findExistingWorktree(rootDir, branchName);
+    const existingWt = await findExistingWorktree(rootDir, branchName);
     if (existingWt) {
       worktreePath = existingWt;
       log('info', `Reusing existing worktree for ${branchName}: ${existingWt}`);
-      try { exec(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
-      try { exec(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: existingWt }); } catch (e) { log('warn', 'git: ' + e.message); }
+      try { await execAsync(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
+      try { await execAsync(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: existingWt }); } catch (e) { log('warn', 'git: ' + e.message); }
     } else if (['meeting', 'ask', 'explore', 'plan-to-prd', 'plan'].includes(type)) {
       // Read-only tasks — no worktree needed, run in rootDir
       log('info', `${type}: read-only task, no worktree needed — running in rootDir`);
@@ -295,18 +299,18 @@ function spawnAgent(dispatchItem, config) {
         if (!fs.existsSync(worktreePath)) {
           const isSharedBranch = meta?.branchStrategy === 'shared-branch' || meta?.useExistingBranch;
           // Prune stale worktree entries before creating (handles leftover entries from crashed runs)
-          try { exec(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+          try { await execAsync(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
           // Remove stale index.lock before creating worktree (Windows crashes can leave this behind)
           removeStaleIndexLock(rootDir);
 
           if (isSharedBranch) {
             log('info', `Creating worktree for shared branch: ${worktreePath} on ${branchName}`);
-            try { exec(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
+            try { await execAsync(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
             try {
-              runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
+              await runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
             } catch (eShared) {
               if (eShared.message?.includes('already used by worktree') || eShared.message?.includes('already checked out')) {
-                const existingWtPath = findExistingWorktree(rootDir, branchName);
+                const existingWtPath = await findExistingWorktree(rootDir, branchName);
                 if (existingWtPath && fs.existsSync(existingWtPath)) {
                   log('info', `Shared branch ${branchName} already checked out at ${existingWtPath} — reusing`);
                   worktreePath = existingWtPath;
@@ -315,42 +319,42 @@ function spawnAgent(dispatchItem, config) {
                 // Branch doesn't exist yet (first item in plan) — create it from main
                 const mainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
                 log('info', `Shared branch ${branchName} not found — creating from ${mainRef}`);
-                runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, worktreeCreateRetries);
+                await runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, worktreeCreateRetries);
               } else { throw eShared; }
             }
           } else {
             log('info', `Creating worktree: ${worktreePath} on branch ${branchName}`);
             const mainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
             try {
-              runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, worktreeCreateRetries);
+              await runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, worktreeCreateRetries);
             } catch (e1) {
               const branchExists = e1.message?.includes('already exists');
               log('warn', `Worktree -b failed for ${branchName}: ${e1.message?.split('\n')[0]}`);
               if (!branchExists) {
                 // Transient error (lock, timeout) — prune, clean, and retry -b once more
                 log('info', `Retrying -b create after prune for ${branchName}`);
-                try { exec(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
+                try { await execAsync(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
                 removeStaleIndexLock(rootDir);
                 // Clean up partial worktree directory from failed attempt
                 try { if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true }); } catch { /* optional */ }
                 try {
-                  runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, 0);
+                  await runWorktreeAdd(rootDir, worktreePath, `-b "${branchName}" ${mainRef}`, _worktreeGitOpts, 0);
                 } catch (e1b) {
                   log('error', `Worktree -b retry also failed for ${branchName}: ${e1b.message?.split('\n')[0]}`);
                   throw e1b;
                 }
               } else {
                 // Branch already exists — try checkout without -b
-                try { exec(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
+                try { await execAsync(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
                 try {
-                  runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
+                  await runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
                   log('info', `Reusing existing branch: ${branchName}`);
                 } catch (e2) {
                   // "already checked out" or "already used by worktree" — find and reuse or recover
                   const alreadyUsed = e2.message?.includes('already checked out') || e2.message?.includes('already used by worktree')
                     || e1.message?.includes('already checked out') || e1.message?.includes('already used by worktree');
                   if (alreadyUsed) {
-                    const existingWtPath = findExistingWorktree(rootDir, branchName);
+                    const existingWtPath = await findExistingWorktree(rootDir, branchName);
                     if (existingWtPath && fs.existsSync(existingWtPath)) {
                       // Bug fix: read dispatch under file lock so check-and-act is atomic
                       let activelyUsed = false;
@@ -369,12 +373,12 @@ function spawnAgent(dispatchItem, config) {
                       worktreePath = existingWtPath;
                     } else if (existingWtPath && !fs.existsSync(existingWtPath)) {
                       log('warn', `Branch ${branchName} tracked in missing dir ${existingWtPath} — pruning and recreating`);
-                      try { exec(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-                      runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
+                      try { await execAsync(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+                      await runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
                       log('info', `Recovered worktree for ${branchName} after stale entry prune`);
                     } else {
-                      try { exec(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-                      runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
+                      try { await execAsync(`git worktree prune`, { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+                      await runWorktreeAdd(rootDir, worktreePath, `"${branchName}"`, _worktreeGitOpts, worktreeCreateRetries);
                     }
                   } else {
                     throw e2;
@@ -385,10 +389,10 @@ function spawnAgent(dispatchItem, config) {
           }
         } else if (meta?.branchStrategy === 'shared-branch') {
           log('info', `Pulling latest on shared branch ${branchName}`);
-          try { exec(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: worktreePath }); } catch (e) { log('warn', 'git: ' + e.message); }
+          try { await execAsync(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: worktreePath }); } catch (e) { log('warn', 'git: ' + e.message); }
         }
       } catch (err) {
-        if (recoverPartialWorktree(rootDir, worktreePath, branchName, _gitOpts)) {
+        if (await recoverPartialWorktree(rootDir, worktreePath, branchName, _gitOpts)) {
           cwd = worktreePath;
           log('warn', `Proceeding with recovered worktree after add failure for ${branchName}`);
         } else {
@@ -407,11 +411,17 @@ function spawnAgent(dispatchItem, config) {
         try {
           const depBranches = resolveDependencyBranches(depIds, meta?.item?.sourcePlan, project, config);
           for (const { branch: depBranch, prId } of depBranches) {
+            // Skip refs already known to be missing this tick (avoids repeated 30s ETIMEDOUT)
+            if (_failedRefCache.has(depBranch)) {
+              log('warn', `Skipping dependency ${depBranch} — already failed to fetch this tick`);
+              continue;
+            }
             try {
-              exec(`git fetch origin "${depBranch}"`, { ..._gitOpts, cwd: rootDir });
-              exec(`git merge "origin/${depBranch}" --no-edit`, { ..._gitOpts, cwd: worktreePath });
+              await execAsync(`git fetch origin "${depBranch}"`, { ..._gitOpts, cwd: rootDir });
+              await execAsync(`git merge "origin/${depBranch}" --no-edit`, { ..._gitOpts, cwd: worktreePath });
               log('info', `Merged dependency branch ${depBranch} (${prId}) into worktree ${branchName}`);
             } catch (mergeErr) {
+              _failedRefCache.add(depBranch);
               log('warn', `Failed to merge dependency ${depBranch} into ${branchName}: ${mergeErr.message}`);
             }
           }
@@ -704,7 +714,7 @@ function spawnAgent(dispatchItem, config) {
     }
 
     // Parse output and run all post-completion hooks
-    const { resultSummary, autoRecovered } = runPostCompletionHooks(dispatchItem, agentId, code, stdout, config);
+    const { resultSummary, autoRecovered } = await runPostCompletionHooks(dispatchItem, agentId, code, stdout, config);
 
     // Move from active to completed in dispatch (single source of truth for agent status)
     // autoRecovered: agent failed (e.g. heartbeat timeout) but created PRs — treat as success
@@ -2351,6 +2361,7 @@ async function tickInner() {
 
   const config = getConfig();
   tickCount++;
+  _failedRefCache.clear(); // Reset per-tick failed-ref cache
 
   // Helper: run a phase, log + continue on error
   const safe = (label, fn) => { try { fn(); } catch (e) { log('warn', `${label}: ${e.message}`); } };
@@ -2563,7 +2574,7 @@ async function tickInner() {
   for (const item of toDispatch) {
     if (!dispatched.has(item.id)) {
       let proc;
-      try { proc = spawnAgent(item, config); } catch (spawnErr) {
+      try { proc = await spawnAgent(item, config); } catch (spawnErr) {
         log('error', `spawnAgent exception for ${item.id}: ${spawnErr.message}`);
         proc = null;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.531",
+  "version": "0.1.533",
   "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"