@yemi33/minions 0.1.205 → 0.1.207

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.1.207 (2026-04-02)
+
+### Engine
+- engine.js
+- engine/lifecycle.js
+- engine/queries.js
+- engine/shared.js
+- engine/timeout.js
+
+### Dashboard
+- dashboard.js
+- dashboard/js/refresh.js
+- dashboard/js/render-plans.js
+- dashboard/js/settings.js
+
+## 0.1.206 (2026-04-02)
+
+### Other
+- minions.js
+
 ## 0.1.205 (2026-04-02)
 
 ### Engine

package/dashboard/js/refresh.js

@@ -1,90 +1,30 @@
 // refresh.js — Main refresh loop and initialization extracted from dashboard.html
 
 // Sidebar activity indicators — detect changes between refreshes
+// Registry: add one line per page. Counter returns a value; badge shows when value increases.
+const _pageCounters = {
+  home:      function(d) { return (d.dispatch?.completed || []).length; },
+  work:      function(d) { return (d.workItems || []).length + '|' + (d.workItems || []).filter(function(w) { return w.status === 'done' || w.status === 'failed'; }).length; },
+  plans:     function(d) { return (d.prdProgress?.complete || 0) + '|' + (d.plans || []).length; },
+  prs:       function(d) { return (d.pullRequests || []).filter(function(p) { return p.status === 'merged'; }).length; },
+  inbox:     function(d) { return (d.inbox?.items || []).length; },
+  meetings:  function(d) { return (d.meetings || []).reduce(function(s, m) { return s + (m.round || 0); }, 0); },
+  pipelines: function(d) { return (d.pipelines || []).reduce(function(s, p) { return s + (p.runs || []).length; }, 0); },
+  schedule:  function(d) { return (d.schedules || []).length; },
+  engine:    function(d) { return (d.dispatch?.active || []).length; },
+};
 let _prevCounts = {};
-let _prevEngineAlert = false;
 function _detectPageChanges(data) {
-  const counts = {
-    completions: (data.dispatch?.completed || []).length,
-    activeDispatches: (data.dispatch?.active || []).length,
-    workDone: (data.workItems || []).filter(w => w.status === 'done' || w.status === 'failed').length,
-    workTotal: (data.workItems || []).length,
-    workDispatched: (data.workItems || []).filter(w => w.status === 'dispatched').length,
-    prdComplete: data.prdProgress?.complete || 0,
-    prdInProgress: data.prdProgress?.inProgress || 0,
-    plansTotal: (data.plans || []).length,
-    prsTotal: (data.pullRequests || []).length,
-    prsMerged: (data.pullRequests || []).filter(p => p.status === 'merged').length,
-    prsReviewed: (data.pullRequests || []).filter(p => p.reviewStatus === 'approved' || p.reviewStatus === 'changes-requested').length,
-    inbox: (data.inbox?.items || []).length,
-    kbTotal: Object.values(data.knowledgeBase || {}).reduce((s, v) => s + (Array.isArray(v) ? v.length : 0), 0),
-    skillsTotal: (data.skills || []).length,
-    mcpTotal: (data.mcpServers || []).length,
-    scheduleTotal: (data.schedules || []).length,
-    pipelineRuns: (data.pipelines || []).reduce((s, p) => s + (p.runs || []).length, 0),
-    pipelineActive: (data.pipelines || []).filter(p => (p.runs || []).some(r => r.status === 'running')).length,
-    meetingRounds: (data.meetings || []).reduce((s, m) => s + (m.round || 0), 0),
-    meetingTotal: (data.meetings || []).length,
-  };
-  const changes = {};
-  if (_prevCounts.completions !== undefined) {
-    if (counts.completions > _prevCounts.completions || counts.activeDispatches > _prevCounts.activeDispatches) changes.home = true;
-    if (counts.workDone > _prevCounts.workDone || counts.workTotal > _prevCounts.workTotal || counts.workDispatched !== _prevCounts.workDispatched) changes.work = true;
-    if (counts.prdComplete > _prevCounts.prdComplete || counts.prdInProgress > _prevCounts.prdInProgress || counts.plansTotal > _prevCounts.plansTotal) changes.plans = true;
-    if (counts.prsTotal > _prevCounts.prsTotal || counts.prsMerged > _prevCounts.prsMerged || counts.prsReviewed > _prevCounts.prsReviewed) changes.prs = true;
-    if (counts.inbox > _prevCounts.inbox || counts.kbTotal > _prevCounts.kbTotal) changes.inbox = true;
-    if (counts.skillsTotal > _prevCounts.skillsTotal || counts.mcpTotal > _prevCounts.mcpTotal) changes.tools = true;
-    if (counts.scheduleTotal > _prevCounts.scheduleTotal) changes.schedule = true;
-    if (counts.pipelineRuns > _prevCounts.pipelineRuns || counts.pipelineActive > _prevCounts.pipelineActive) changes.pipelines = true;
-    if (counts.meetingRounds > _prevCounts.meetingRounds || counts.meetingTotal > _prevCounts.meetingTotal) changes.meetings = true;
+  var changes = {};
+  var counts = {};
+  for (var page in _pageCounters) {
+    counts[page] = String(_pageCounters[page](data));
+    if (_prevCounts[page] !== undefined && counts[page] !== _prevCounts[page]) changes[page] = true;
   }
   _prevCounts = counts;
-
-  // Engine page — only badge for genuine problems, not routine activity
-  const engineAlert = _isEngineAlertWorthy(data);
-  if (engineAlert && !_prevEngineAlert) changes.engine = true;
-  // Clear the engine badge when alert condition resolves
-  if (!engineAlert && _prevEngineAlert) {
-    const engineLink = document.querySelector('.sidebar-link[data-page="engine"]');
-    if (engineLink) clearNotifBadge(engineLink);
-  }
-  _prevEngineAlert = engineAlert;
-
   return changes;
 }
 
-/**
- * Determine if the engine state warrants a notification dot.
- * Returns true only for genuine problems:
- * - Engine stopped, stale, or in error state
- * - 3+ failed work items in the last hour
- * - Agent timeout/crash detected (error results in recent completions)
- */
-function _isEngineAlertWorthy(data) {
-  // 1. Engine not running (stopped, stale, or error)
-  const engineState = data.engine?.state || 'stopped';
-  if (engineState === 'stopped' || engineState === 'error') return true;
-  // Stale heartbeat (>2 min old while claiming running)
-  if (engineState === 'running' && data.engine?.heartbeat) {
-    if (Date.now() - data.engine.heartbeat > 120000) return true;
-  }
-
-  // 2. 3+ failed work items in the last hour
-  const oneHourAgo = Date.now() - 3600000;
-  const recentFailures = (data.workItems || []).filter(w =>
-    w.status === 'failed' && w.updated_at && new Date(w.updated_at).getTime() > oneHourAgo
-  );
-  if (recentFailures.length >= 3) return true;
-
-  // 3. Agent timeout/crash — 3+ error results in recent completed dispatches
-  const recentErrors = (data.dispatch?.completed || []).filter(d =>
-    d.result === 'error' && d.completed_at && new Date(d.completed_at).getTime() > oneHourAgo
-  );
-  if (recentErrors.length >= 3) return true;
-
-  return false;
-}
-
 function _processStatusUpdate(data) {
   // Detect fresh install — clear stale browser state if install ID changed
   if (data.installId) {
@@ -97,24 +37,15 @@ function _processStatusUpdate(data) {
   }
   document.getElementById('ts').textContent = new Date(data.timestamp).toLocaleTimeString();
   const engineState = (data.engine && data.engine.state) ? data.engine.state : 'stopped';
-
-  // Engine status FIRST — most critical indicator, must not be blocked by other render failures
-  renderEngineStatus(data.engine);
-
-  // Show setup banner if no projects linked (the key onboarding step)
-  const noProjects = !data.projects || data.projects.length === 0;
-  document.getElementById('setup-banner').style.display = (noProjects && engineState !== 'stopped') ? 'block' : 'none';
-
-  // Each render call wrapped so one failure doesn't block the rest
-  const _r = (fn) => { try { fn(); } catch (e) { console.error('render error:', e.message); } };
-  _r(() => renderAgents(data.agents));
-  _r(() => renderPrdProgress(data.prdProgress));
-  _r(() => _cachePrdItems(data.prdProgress));
-  _r(() => renderInbox(data.inbox));
-  _r(() => cmdUpdateAgentList(data.agents));
-  _r(() => cmdUpdateProjectList(data.projects || []));
-  _r(() => renderNotes(data.notes));
-  _r(() => renderPrd(data.prd, data.prdProgress));
+  document.getElementById('setup-banner').style.display = (!data.initialized && engineState !== 'stopped') ? 'block' : 'none';
+  renderAgents(data.agents);
+  renderPrdProgress(data.prdProgress);
+  _cachePrdItems(data.prdProgress);
+  renderInbox(data.inbox);
+  cmdUpdateAgentList(data.agents);
+  cmdUpdateProjectList(data.projects || []);
+  renderNotes(data.notes);
+  renderPrd(data.prd, data.prdProgress);
   // Auto-approve badge
   const autoEl = document.getElementById('auto-approve-badge');
   if (autoEl) autoEl.innerHTML = data.autoMode?.approvePlans
@@ -123,23 +54,24 @@ function _processStatusUpdate(data) {
   // Inbox consolidation threshold from config
   const threshEl = document.getElementById('inbox-threshold');
   if (threshEl && data.autoMode?.inboxThreshold) threshEl.textContent = data.autoMode.inboxThreshold;
-  _r(() => renderPrs(data.pullRequests || []));
-  _r(() => renderArchiveButtons(data.archivedPrds || []));
-  _r(() => renderDispatch(data.dispatch));
+  renderPrs(data.pullRequests || []);
+  renderArchiveButtons(data.archivedPrds || []);
+  renderEngineStatus(data.engine);
+  renderDispatch(data.dispatch);
   window._lastDispatch = data.dispatch;
   window._lastWorkItems = data.workItems || [];
   window._lastStatus = data;
-  _r(() => prunePrdRequeueState(window._lastWorkItems));
-  _r(() => renderEngineLog(data.engineLog || []));
-  _r(() => renderProjects(data.projects || []));
-  _r(() => renderMetrics(data.metrics || {}));
-  _r(() => renderWorkItems(data.workItems || []));
-  _r(() => renderSkills(data.skills || []));
-  _r(() => renderMcpServers(data.mcpServers || []));
-  _r(() => renderSchedules(data.schedules || []));
-  _r(() => renderMeetings(data.meetings || []));
-  _r(() => { if (typeof renderPipelines === 'function') renderPipelines(data.pipelines || []); });
-  _r(() => renderPinned(data.pinned || []));
+  prunePrdRequeueState(window._lastWorkItems);
+  renderEngineLog(data.engineLog || []);
+  renderProjects(data.projects || []);
+  renderMetrics(data.metrics || {});
+  renderWorkItems(data.workItems || []);
+  renderSkills(data.skills || []);
+  renderMcpServers(data.mcpServers || []);
+  renderSchedules(data.schedules || []);
+  renderMeetings(data.meetings || []);
+  if (typeof renderPipelines === 'function') renderPipelines(data.pipelines || []);
+  renderPinned(data.pinned || []);
   // Update sidebar counts
   const swi = document.getElementById('sidebar-wi');
   if (swi) swi.textContent = (data.workItems || []).length || '';
@@ -170,16 +102,7 @@ async function refresh() {
 refresh();
 
 // Poll for status updates (SSE caused HTTP/1.1 connection exhaustion — CC fetch would fail)
-var _refreshTimer = setInterval(refresh, 4000);
-document.addEventListener('visibilitychange', function() {
-  if (document.hidden) {
-    clearInterval(_refreshTimer);
-    _refreshTimer = null;
-  } else if (!_refreshTimer) {
-    refresh();
-    _refreshTimer = setInterval(refresh, 4000);
-  }
-});
+setInterval(refresh, 4000);
 
 // Wire sidebar navigation
 document.querySelectorAll('.sidebar-link').forEach(link => {

package/dashboard/js/render-plans.js

@@ -223,7 +223,7 @@ function renderPlans(plans) {
       actions = '<div class="plan-card-meta" style="margin-top:6px;color:var(--purple,#a855f7)">Revision in progress: ' + escHtml((p.revisionFeedback || '').slice(0, 100)) + '</div>';
     }
 
-    const executeBtn = isDraft && effectiveStatus === 'active' && !isArchived && !prdFile ? '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);font-weight:600" ' +
+    const executeBtn = isDraft && (effectiveStatus === 'active' || effectiveStatus === 'draft') && !isArchived && !prdFile ? '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);font-weight:600" ' +
       'onclick="event.stopPropagation();planExecute(\'' + escHtml(p.file) + '\',\'' + escHtml(p.project) + '\',this)">Execute</button>' : '';
     const showPause = effectiveStatus === 'in-progress' && prdFile && !isArchived;
     const showResume = (effectiveStatus === 'paused' || effectiveStatus === 'awaiting-approval') && prdFile && !isArchived;

package/dashboard/js/settings.js

@@ -54,6 +54,15 @@ async function openSettings() {
       settingsField('Output Format', 'set-outputFormat', c.outputFormat || 'stream-json', '', '') +
       settingsField('Allowed Tools', 'set-allowedTools', c.allowedTools || '', '', 'Comma-separated (empty = all)') +
     '</div>' +
+    '<div style="margin-bottom:16px">' +
+      '<label style="font-size:10px;color:var(--muted);display:block;margin-bottom:2px">Permission Mode <span style="opacity:0.6">(how agents handle tool approvals)</span></label>' +
+      '<select id="set-permissionMode" style="width:100%;padding:4px 6px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-size:12px">' +
+        '<option value="bypassPermissions"' + ((c.permissionMode || 'bypassPermissions') === 'bypassPermissions' ? ' selected' : '') + '>Bypass (recommended) — agents run without permission prompts</option>' +
+        '<option value="auto"' + ((c.permissionMode) === 'auto' ? ' selected' : '') + '>Auto — agents auto-approve safe tools, prompt for risky ones</option>' +
+        '<option value="default"' + ((c.permissionMode) === 'default' ? ' selected' : '') + '>Default — agents prompt for every tool (will hang without a human)</option>' +
+      '</select>' +
+      '<div style="font-size:9px;color:var(--muted);margin-top:2px">Non-bypass modes require a human watching the agent terminal to approve tool calls</div>' +
+    '</div>' +
 
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">Agents</h3>' +
     '<table style="width:100%;border-collapse:collapse;margin-bottom:16px;font-size:11px">' +
@@ -138,6 +147,7 @@ async function saveSettings() {
     const claudePayload = {
       outputFormat: document.getElementById('set-outputFormat').value,
       allowedTools: document.getElementById('set-allowedTools').value,
+      permissionMode: document.getElementById('set-permissionMode').value,
     };
 
     const agentsPayload = {};

package/dashboard.js

@@ -2711,7 +2711,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const { execSync: ex } = require('child_process');
       const detected = { name: path.basename(target), _found: [] };
       try {
-        const head = ex('git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || git symbolic-ref HEAD', { cwd: target, encoding: 'utf8', timeout: 5000 }).trim();
+        let head = '';
+        try {
+          head = ex('git symbolic-ref refs/remotes/origin/HEAD', { cwd: target, encoding: 'utf8', timeout: 5000 }).trim();
+        } catch {
+          head = ex('git symbolic-ref HEAD', { cwd: target, encoding: 'utf8', timeout: 5000 }).trim();
+        }
         detected.mainBranch = head.replace('refs/remotes/origin/', '').replace('refs/heads/', '');
       } catch { detected.mainBranch = 'main'; }
       try {
@@ -2982,6 +2987,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         for (const key of ['allowedTools', 'outputFormat']) {
           if (body.claude[key] !== undefined) config.claude[key] = String(body.claude[key]);
         }
+        if (body.claude.permissionMode !== undefined) {
+          const valid = ['bypassPermissions', 'auto', 'default'];
+          config.claude.permissionMode = valid.includes(body.claude.permissionMode) ? body.claude.permissionMode : 'bypassPermissions';
+        }
       }
 
       if (body.agents) {

package/engine/lifecycle.js

@@ -6,7 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
-const { safeRead, safeJson, safeWrite, safeReadDir, execSilent, projectPrPath, getPrLinks,
+const { safeRead, safeJson, safeWrite, safeReadDir, execSilent, projectPrPath, getPrLinks, addPrLink,
   mutateJsonFileLocked, log, ts, dateStamp } = shared;
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
@@ -58,7 +58,7 @@ function checkPlanCompletion(meta, config) {
   const unmaterialized = [...planFeatureIds].filter(id => {
     if (workItemById[id]) return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done'));
+    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
   });
   if (unmaterialized.length > 0) {
     log('info', `Plan ${planFile}: ${unmaterialized.length}/${planFeatureIds.size} feature(s) not yet materialized as work items: ${unmaterialized.join(', ')}`);
@@ -68,16 +68,16 @@ function checkPlanCompletion(meta, config) {
   // Check 2: every feature's work item must be done (or PRD item marked done externally)
   const notDone = [...planFeatureIds].filter(id => {
     const w = workItemById[id];
-    if (w && (w.status === 'done')) return false; // in-pr accepted for backward compat
+    if (w && (w.status === 'done' || w.status === 'in-pr')) return false; // in-pr accepted for backward compat
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done'));
+    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
   });
   if (notDone.length > 0) {
     log('info', `Plan ${planFile}: waiting for done on ${notDone.length}/${planFeatureIds.size} item(s): ${notDone.join(', ')}`);
     return;
   }
 
-  const doneItems = planItems.filter(w => w.status === 'done');
+  const doneItems = planItems.filter(w => w.status === 'done' || w.status === 'in-pr');
   const failedItems = planItems.filter(w => w.status === 'failed');
 
   // 1. Mark plan as completed
@@ -475,6 +475,7 @@ function updateWorkItemStatus(meta, status, reason) {
       }
     } else {
       target.status = status;
+      delete target._pendingReason;
       if (status === 'done') {
         delete target.failReason;
         delete target.failedAt;
@@ -534,7 +535,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
         for (const block of content) {
           if (block.type === 'tool_result' && block.content) {
             const text = typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
-            if (text.includes('pullRequestId') || text.includes('create_pull_request')) {
+            if (text.includes('pullRequestId') || text.includes('create_pull_request') || text.includes('/pull/') || text.includes('pullrequest/')) {
               while ((match = urlPattern.exec(text)) !== null) prMatches.add(match[1] || match[2]);
             }
           }
@@ -624,10 +625,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
       sourcePlan: meta?.item?.sourcePlan || '',
       itemType: meta?.item?.itemType || ''
     });
-    if (meta?.item?.id) {
-      const project = config ? shared.getProjects(config)[0] : null;
-      if (project) shared.linkPrToItem(project, fullId, meta.item.id);
-    }
+    if (meta?.item?.id) addPrLink(fullId, meta.item.id);
     added++;
   }
 
@@ -735,7 +733,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
   // Mark review as approved since it was merged
   pr.reviewStatus = 'approved';
 
-  // Resolve linked work item from PR.prdItems or PR branch name
+  // Resolve linked work item from pr-links or PR branch name
   let mergedItemId = getPrLinks()[pr.id];
   if (!mergedItemId && pr.branch) {
     const branchMatch = pr.branch.match(/(P-[a-z0-9]{6,})/i) || pr.branch.match(/(W-[a-z0-9]+)/i);
@@ -752,13 +750,13 @@ async function handlePostMerge(pr, project, config, newStatus) {
         const plan = safeJson(path.join(prdDir, pf));
         if (!plan?.missing_features) continue;
         const feature = plan.missing_features.find(f => f.id === mergedItemId);
-        if (feature && feature.status !== 'done') {
-          feature.status = 'done';
+        if (feature && feature.status !== 'implemented') {
+          feature.status = 'implemented';
           shared.safeWrite(path.join(prdDir, pf), plan);
           updated++;
         }
       }
-      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as done for ${pr.id}`);
+      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as implemented for ${pr.id}`);
     } catch (err) { log('warn', `Post-merge PRD update: ${err.message}`); }
 
     // Mark work item as done
@@ -1224,40 +1222,42 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
 
   if (isSuccess && meta?.item?.id && !skipDoneStatus) updateWorkItemStatus(meta, 'done', '');
 
-  // Auto-dispatch review work item after implement completes successfully
-  if (isSuccess && !skipDoneStatus && type === 'implement' && meta?.item?.id) {
-    const autoReview = config.engine?.autoReview ?? shared.ENGINE_DEFAULTS.autoReview;
-    if (autoReview) {
+  // Auto-dispatch evaluate work item after implement or fix completes successfully
+  if (isSuccess && !skipDoneStatus && (type === 'implement' || (type === 'fix' && meta?.item?._evalParentId)) && meta?.item?.id) {
+    const evalLoop = config.engine?.evalLoop ?? shared.ENGINE_DEFAULTS.evalLoop;
+    if (evalLoop) {
       try {
         const wiPath = resolveWiPath(meta);
         if (wiPath) {
           const items = safeJson(wiPath) || [];
-          // Dedup: skip if a review item already exists for this parent
-          const existing = items.find(i => i._evalParentId === meta.item.id && i.type === 'review');
+          // For fix items, target the original implement parent; for implement, target self
+          const evalTargetId = type === 'fix' ? meta.item._evalParentId : meta.item.id;
+          // Dedup: skip if an evaluate item already exists for this parent
+          const existing = items.find(i => i._evalParentId === evalTargetId && i.type === 'evaluate' && i.status === 'pending');
           if (existing) {
-            log('info', `Eval loop: review item ${existing.id} already exists for ${meta.item.id}, skipping`);
+            log('info', `Eval loop: evaluate item ${existing.id} already exists for ${evalTargetId}, skipping`);
           } else {
-            const parentItem = items.find(i => i.id === meta.item.id);
+            const parentItem = items.find(i => i.id === evalTargetId);
             const evalItem = {
               id: 'W-' + shared.uid(),
-              title: `Review: ${meta.item.title || meta.item.id}`,
-              type: 'review',
+              title: `Evaluate: ${parentItem?.title || meta.item.title || evalTargetId}`,
+              type: 'evaluate',
               priority: meta.item.priority || 'high',
               status: 'pending',
               created: ts(),
               createdBy: 'engine:eval-loop',
               project: meta.project?.name || meta.item.project,
-              branch_name: parentItem?.branch_name || meta.branch || null,
-              pr_url: parentItem?.pr_url || null,
+              branch_name: parentItem?.branch_name || meta.item.branch_name || meta.branch || null,
+              pr_url: parentItem?.pr_url || meta.item.pr_url || null,
               acceptance_criteria: parentItem?.acceptance_criteria || meta.item.acceptance_criteria || null,
-              _evalParentId: meta.item.id,
+              _evalParentId: evalTargetId,
             };
             if (parentItem?.sourcePlan) evalItem.sourcePlan = parentItem.sourcePlan;
             // Mark parent as eval-dispatched before writing to prevent duplicates on re-run
             if (parentItem) parentItem._evalDispatched = true;
             items.push(evalItem);
             shared.safeWrite(wiPath, items);
-            log('info', `Eval loop: created ${evalItem.id} for completed implement ${meta.item.id}`);
+            log('info', `Eval loop: created ${evalItem.id} for completed ${type} ${meta.item.id} (parent: ${evalTargetId})`);
           }
         }
       } catch (err) {
@@ -1266,14 +1266,14 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
     }
   }
 
-  // Review completion: parse verdict and handle review→fix iteration loop
-  if (isSuccess && type === 'review' && meta?.item?._evalParentId) {
+  // Evaluate completion: parse verdict and handle eval→fix iteration loop
+  if (isSuccess && type === 'evaluate' && meta?.item?._evalParentId) {
     try {
       const verdict = parseEvalVerdict(resultSummary || stdout);
-      const autoReview = config.engine?.autoReview ?? shared.ENGINE_DEFAULTS.autoReview;
+      const evalLoop = config.engine?.evalLoop ?? shared.ENGINE_DEFAULTS.evalLoop;
       const maxIter = config.engine?.evalMaxIterations ?? shared.ENGINE_DEFAULTS.evalMaxIterations;
 
-      if (verdict && !verdict.pass && autoReview) {
+      if (verdict && !verdict.pass && evalLoop) {
         const wiPath = resolveWiPath(meta);
         if (wiPath) {
           const items = safeJson(wiPath) || [];
@@ -1420,8 +1420,9 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
     }
   }
 
-  // Detect implement tasks that completed without creating a PR
-  if (isSuccess && (type === 'implement' || type === 'implement:large' || type === 'fix') && prsCreatedCount === 0 && meta?.item?.id) {
+  // Detect implement tasks that completed without creating a PR.
+  // Exempt: tasks operating on an existing PR (meta.pr set) or human feedback fix tasks.
+  if (isSuccess && (type === 'implement' || type === 'implement:large' || type === 'fix') && prsCreatedCount === 0 && meta?.item?.id && !meta.pr && meta.source !== 'pr-human-feedback') {
     // Check if a PR already exists linked to this work item (from a previous attempt)
     const projects = shared.getProjects(config);
     const existingPrFound = Object.values(getPrLinks()).includes(meta.item.id);

package/engine/queries.js

@@ -339,15 +339,21 @@ function collectSkillFiles(config) {
       try { return fs.statSync(path.join(claudeSkillsDir, d)).isDirectory(); } catch { return false; }
     });
     for (const d of dirs) {
+      // Check both <name>/SKILL.md and <name>/skills/SKILL.md (Claude Code uses both)
       const skillFile = path.join(claudeSkillsDir, d, 'SKILL.md');
+      const nestedSkillFile = path.join(claudeSkillsDir, d, 'skills', 'SKILL.md');
       if (fs.existsSync(skillFile)) {
         skillFiles.push({ file: 'SKILL.md', dir: path.join(claudeSkillsDir, d), scope: 'claude-code', skillName: d });
         seen.add(d);
+      } else if (fs.existsSync(nestedSkillFile)) {
+        skillFiles.push({ file: 'SKILL.md', dir: path.join(claudeSkillsDir, d, 'skills'), scope: 'claude-code', skillName: d });
+        seen.add(d);
       }
     }
   } catch { /* optional */ }
 
-  // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json → cache/<marketplace>/<plugin>/<version>/commands/*.md
+  // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json
+  // Plugins use commands/*.md and/or skills/<name>/SKILL.md and/or skills/SKILL.md
   try {
     const pluginsFile = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
     const registry = JSON.parse(safeRead(pluginsFile) || '{}');
@@ -355,16 +361,49 @@ function collectSkillFiles(config) {
       if (!Array.isArray(installs) || installs.length === 0) continue;
       const install = installs[0];
       if (!install.installPath) continue;
+      const pluginName = pluginKey.split('@')[0];
+
+      // commands/*.md (older style)
       const commandsDir = path.join(install.installPath, 'commands');
       try {
         const commands = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
         for (const cmd of commands) {
-          const name = pluginKey.split('@')[0] + ':' + cmd.replace('.md', '');
+          const name = pluginName + ':' + cmd.replace('.md', '');
           if (seen.has(name)) continue;
           skillFiles.push({ file: cmd, dir: commandsDir, scope: 'plugin', skillName: name });
           seen.add(name);
         }
       } catch { /* optional */ }
+
+      // skills/<name>/SKILL.md or skills/SKILL.md (newer style)
+      const skillsDir = path.join(install.installPath, 'skills');
+      try {
+        const entries = fs.readdirSync(skillsDir);
+        for (const entry of entries) {
+          const entryPath = path.join(skillsDir, entry);
+          if (entry === 'SKILL.md') {
+            // Flat: skills/SKILL.md
+            const name = pluginName;
+            if (!seen.has(name)) {
+              skillFiles.push({ file: 'SKILL.md', dir: skillsDir, scope: 'plugin', skillName: name });
+              seen.add(name);
+            }
+          } else {
+            try {
+              if (!fs.statSync(entryPath).isDirectory()) continue;
+            } catch { continue; }
+            // Nested: skills/<name>/SKILL.md
+            const nestedSkill = path.join(entryPath, 'SKILL.md');
+            if (fs.existsSync(nestedSkill)) {
+              const name = pluginName + ':' + entry;
+              if (!seen.has(name)) {
+                skillFiles.push({ file: 'SKILL.md', dir: entryPath, scope: 'plugin', skillName: name });
+                seen.add(name);
+              }
+            }
+          }
+        }
+      } catch { /* optional */ }
     }
   } catch { /* optional */ }
 

package/engine/shared.js

@@ -7,7 +7,7 @@ const fs = require('fs');
 const path = require('path');
 
 const MINIONS_DIR = path.resolve(__dirname, '..');
-const CENTRAL_WI_PATH = path.join(MINIONS_DIR, 'work-items.json');
+const PR_LINKS_PATH = path.join(MINIONS_DIR, 'engine', 'pr-links.json');
 const LOG_PATH = path.join(__dirname, 'log.json');
 
 // ── Timestamps & Logging ────────────────────────────────────────────────────
@@ -258,7 +258,6 @@ function gitEnv() {
  * Single source of truth — used by llm.js, consolidation.js, and lifecycle.js.
  */
 function parseStreamJsonOutput(raw, { maxTextLength = 0 } = {}) {
-  if (typeof raw !== 'string') raw = '';
   let text = '';
   let usage = null;
   let sessionId = null;
@@ -501,52 +500,45 @@ function parseSkillFrontmatter(content, filename) {
 // Never touched by polling loops — only written when a PR is first linked to a PRD item.
 
 function getPrLinks() {
-  // Derive from PR.prdItems (single source of truth)
   const links = {};
+  // Primary source: derive from all projects/*/pull-requests.json prdItems
+  const projectsDir = path.join(MINIONS_DIR, 'projects');
   try {
-    const projects = getProjects();
-    for (const project of projects) {
-      const prs = safeJson(projectPrPath(project)) || [];
-      for (const pr of prs) {
-        for (const itemId of (pr.prdItems || [])) {
-          if (!links[pr.id]) links[pr.id] = itemId;
+    const fs = require('fs');
+    for (const d of fs.readdirSync(projectsDir, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      try {
+        const prs = JSON.parse(fs.readFileSync(path.join(projectsDir, d.name, 'pull-requests.json'), 'utf8'));
+        for (const pr of prs) {
+          if (!pr.id) continue;
+          for (const itemId of (pr.prdItems || [])) {
+            if (itemId) links[pr.id] = itemId;
+          }
         }
-      }
+      } catch { /* missing or invalid */ }
+    }
+  } catch { /* projects dir missing */ }
+  // Fallback: static pr-links.json for entries not covered above
+  try {
+    const static_ = JSON.parse(require('fs').readFileSync(PR_LINKS_PATH, 'utf8'));
+    for (const [k, v] of Object.entries(static_)) {
+      if (!links[k]) links[k] = v;
     }
-  } catch { /* optional */ }
+  } catch { /* missing */ }
   return links;
 }
 
-/**
- * Locked mutation of a project's pull-requests.json.
- * Single source of truth for PR data including prdItems links.
- */
-function mutatePrs(project, mutateFn) {
-  const prPath = projectPrPath(project);
-  return mutateJsonFileLocked(prPath, (prs) => {
-    return mutateFn(Array.isArray(prs) ? prs : []);
-  }, { defaultValue: [] });
-}
-
-/**
- * Link a PR to a work item via PR.prdItems (single source of truth).
- * Uses file-locked mutation to prevent race conditions.
- */
-function linkPrToItem(project, prId, itemId) {
+function addPrLink(prId, itemId) {
   if (!prId || !itemId) return;
-  mutatePrs(project, (prs) => {
-    const pr = prs.find(p => p.id === prId);
-    if (pr) {
-      pr.prdItems = Array.isArray(pr.prdItems) ? pr.prdItems : [];
-      if (!pr.prdItems.includes(itemId)) pr.prdItems.push(itemId);
-    }
-    return prs;
-  });
+  const links = getPrLinks();
+  if (links[prId] === itemId) return; // already correct, no write needed
+  links[prId] = itemId;
+  safeWrite(PR_LINKS_PATH, links);
 }
 
 module.exports = {
   MINIONS_DIR,
-  CENTRAL_WI_PATH,
+  PR_LINKS_PATH,
   LOG_PATH,
   ts,
   logTs,
@@ -580,8 +572,7 @@ module.exports = {
   projectWorkItemsPath,
   projectPrPath,
   getPrLinks,
-  mutatePrs,
-  linkPrToItem,
+  addPrLink,
   nextWorkItemId,
   getAdoOrgBase,
   sanitizePath,

package/engine/timeout.js

@@ -256,11 +256,13 @@ function checkTimeouts(config) {
           item._retryCount = retries + 1;
           delete item.dispatched_at;
           delete item.dispatched_to;
+          delete item._pendingReason;
         } else {
           log('warn', `Reconcile: work item ${item.id} failed after ${retries} retries — marking as failed`);
           item.status = 'failed';
           item.failReason = 'Agent died or was killed (3 retries exhausted)';
           item.failedAt = ts();
+          delete item._pendingReason;
         }
         changed = true;
       }

package/engine.js

@@ -396,6 +396,7 @@ function spawnAgent(dispatchItem, config) {
         } else {
           log('error', `Failed to create worktree for ${branchName}: ${err.message}${err.stderr ? '\n' + err.stderr.toString().slice(0, 500) : ''}`);
           completeDispatch(id, 'error', 'Worktree creation failed: ' + (err.message || '').slice(0, 200));
+          try { updateMetrics(agentId, dispatchItem, 'error', null, 0, null); } catch { /* optional */ }
           return null;
         }
       }

package/minions.js

@@ -281,25 +281,34 @@ function findGitRepos(rootDir, maxDepth = 3) {
 }
 
 async function scanAndAdd({ root, depth } = {}) {
-  let scanRoot;
+  let scanRoots;
   if (root) {
-    scanRoot = path.resolve(root);
+    scanRoots = [path.resolve(root)];
   } else {
     const homeDir = process.env.USERPROFILE || process.env.HOME || '';
-    const answer = await ask('Where are your projects?', homeDir);
-    scanRoot = path.resolve(answer);
+    const answer = await ask('Where are your projects? (comma-separate for multiple)', homeDir);
+    scanRoots = answer.split(',').map(s => path.resolve(s.trim())).filter(Boolean);
   }
-  if (!fs.existsSync(scanRoot)) {
-    console.log(`  Directory not found: ${scanRoot}\n`);
+  // Validate all paths
+  const validRoots = [];
+  for (const r of scanRoots) {
+    if (fs.existsSync(r)) { validRoots.push(r); }
+    else { console.log(`  Directory not found (skipping): ${r}`); }
+  }
+  if (validRoots.length === 0) {
+    console.log('  No valid directories to scan.\n');
     rl.close();
     return;
   }
   const maxDepth = depth !== undefined ? (parseInt(depth, 10) || 4) : 4;
 
-  console.log(`\n  Scanning for git repos in: ${scanRoot}`);
-  console.log(`  Max depth: ${maxDepth}\n`);
-
-  const repos = findGitRepos(scanRoot, maxDepth);
+  let repos = [];
+  for (const scanRoot of validRoots) {
+    console.log(`\n  Scanning: ${scanRoot} (depth ${maxDepth})`);
+    repos.push(...findGitRepos(scanRoot, maxDepth));
+  }
+  // Deduplicate by resolved path
+  repos = [...new Map(repos.map(r => [path.resolve(r), r])).values()];
   if (repos.length === 0) {
     console.log('  No git repositories found.\n');
     rl.close();

package/package.json

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