@yemi33/minions 0.1.1006 → 0.1.1008

package/CHANGELOG.md

@@ -1,8 +1,11 @@
 # Changelog
 
-## 0.1.1006 (2026-04-16)
+## 0.1.1008 (2026-04-16)
 
 ### Features
+- fix duplicate PR creation + cancel stale review dispatches on PR close (#1137)
+- intercept /loop skill invocations in CC and convert to watches (#1140)
+- add cancel work item endpoint, UI button, and CC action (#1136)
 - cap pendingContexts in cooldowns.json to prevent bloat (#1126)
 - fix stopAfter=0 watch expiry — run forever for all conditions (#1117)
 - fix doc-chat Clear chat not persisting session deletion to localStorage (#1102)
@@ -20,11 +23,10 @@
 -  add quality standard reminder to all agent and CC prompts
 - surface in-flight tool calls in lastAction (#1064)
 - implement dashboard loop/watch management panel
-- reassign tasks when preferred agent is busy too long
-- wire agentBusyReassignMs into settings UI and persist
--  ADO throttle detection, poll guards, and dashboard banner (#1051)
 
 ### Fixes
+-  harden audited state transitions
+- scrub stale temp agent IDs from metrics.json (#1129)
 -  harden repo-scoped PR identity handling
 -  only gate reviews/fixes when no free agent slots remain
 -  extend auto-link fallback to ADO projects
@@ -43,8 +45,6 @@
 -  build fix sets fixDispatched to block same-tick conflict fix
 -  ENGINE_DEFAULTS undefined in tick + playbook empty-var false positives
 -  defer review setCooldown to post-gating in discoverWork
--  move review verdict check before updateWorkItemStatus(DONE)
--  address review feedback — move writeToInbox outside lock, add absolute condition auto-expire
 
 ### Other
 - refactor: migrate PR links to array format and consolidate shared helpers

package/dashboard/js/command-center.js

@@ -860,6 +860,13 @@ async function ccExecuteAction(action, targetTabId) {
         status.style.color = 'var(--orange)';
         break;
       }
+      case 'cancel-work-item': {
+        await _ccFetch('/api/work-items/cancel', { id: action.id, source: action.source || '', reason: action.reason || 'cc' });
+        status.innerHTML = '&#10003; Cancelled work item: <strong>' + escHtml(action.id) + '</strong>';
+        status.style.color = 'var(--orange)';
+        wakeEngine();
+        break;
+      }
       case 'plan-edit': {
         // Read the plan, send instruction to doc-chat, show version actions
         var normalizedFile = normalizePlanFile(action.file);

package/dashboard/js/render-work-items.js

@@ -70,6 +70,7 @@ function wiRow(item) {
       ((item.status === 'pending' || item.status === 'failed' || item.status === 'needs-human-review') ? '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();editWorkItem(\'' + escHtml(item.id) + '\',\'' + escHtml(item._source || '') + '\')" title="Edit work item">&#x270E;</button>' : '') +
       ((item.status === 'done' || item.status === 'failed' || item.status === 'needs-human-review') ? '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--muted);border-color:var(--border);margin-right:4px" onclick="event.stopPropagation();archiveWorkItem(\'' + escHtml(item.id) + '\',\'' + escHtml(item._source || '') + '\')" title="Archive work item">&#x1F4E6;</button>' : '') +
       ((item.status === 'done' || item.status === 'failed' || item.status === 'needs-human-review') && !item._humanFeedback ? '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();feedbackWorkItem(\'' + escHtml(item.id) + '\',\'' + escHtml(item._source || '') + '\')" title="Give feedback">&#x1F44D;&#x1F44E;</button>' : (item._humanFeedback ? '<span style="font-size:9px" title="Feedback given">' + (item._humanFeedback.rating === 'up' ? '&#x1F44D;' : '&#x1F44E;') + '</span> ' : '')) +
+      ((item.status === 'pending' || item.status === 'dispatched' || item.status === 'queued' || item.status === 'failed' || item.status === 'needs-human-review') ? '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--orange);border-color:var(--orange);margin-right:4px" onclick="event.stopPropagation();cancelWorkItem(\'' + escHtml(item.id) + '\',\'' + escHtml(item._source || '') + '\')" title="Cancel work item and kill agent">&#x1F6AB;</button>' : '') +
       '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--red);border-color:var(--red)" onclick="event.stopPropagation();deleteWorkItem(\'' + escHtml(item.id) + '\',\'' + escHtml(item._source || '') + '\')" title="Delete work item and kill agent">&#x2715;</button>' +
     '</td>' +
   '</tr>';
@@ -209,6 +210,21 @@ async function deleteWorkItem(id, source) {
   } catch (e) { showToast('cmd-toast', 'Delete error: ' + e.message, false); refresh(); }
 }
 
+async function cancelWorkItem(id, source) {
+  if (!confirm('Cancel work item ' + id + '? This will kill any running agent and mark it cancelled.')) return;
+  markDeleted('wi:' + id);
+  var wiTable = document.getElementById('work-items-content');
+  (wiTable || document).querySelectorAll('tr').forEach(function(r) { if (r.textContent.includes(id)) r.remove(); });
+  showToast('cmd-toast', 'Work item cancelled', true);
+  try {
+    const res = await fetch('/api/work-items/cancel', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id, source: source || undefined })
+    });
+    if (!res.ok) { const d = await res.json().catch(() => ({})); showToast('cmd-toast', 'Cancel failed: ' + (d.error || 'unknown'), false); refresh(); }
+  } catch (e) { showToast('cmd-toast', 'Cancel error: ' + e.message, false); refresh(); }
+}
+
 async function archiveWorkItem(id, source) {
   markDeleted('wi:' + id);
   var wiTable = document.getElementById('work-items-content');

package/dashboard.js

@@ -607,6 +607,65 @@ function parseCCActions(text) {
   return { text: displayText, actions };
 }
 
+// ── /loop → create-watch safety net ──────────────────────────────────────────
+// CC sometimes invokes the /loop skill instead of emitting a create-watch action.
+// This pure function detects /loop invocation in CC response text and synthesizes
+// a create-watch action as a fallback. Returns null if no conversion needed.
+
+function _detectLoopInvocation(text, actions) {
+  if (!text) return null;
+  // If a create-watch action was already emitted, no fallback needed
+  if (actions && actions.some(a => a.type === 'create-watch')) return null;
+
+  // Check for /loop invocation patterns in CC response
+  const loopPatterns = [
+    /\/loop\b/i,
+    /\bloop skill\b/i,
+    /\bSkill.*\bloop\b/i,
+    /\bstarted.*\bloop\b/i,
+    /\bmonitoring.*\bloop\b/i,
+    /\binvok(?:e|ed|ing).*\bloop\b/i,
+  ];
+  if (!loopPatterns.some(p => p.test(text))) return null;
+
+  // Extract target — PR number or work item ID
+  const prMatch = text.match(/\bPR[- #]?(\d+)\b/i) || text.match(/\bpull[- ]request[- #]?(\d+)/i);
+  const wiMatch = text.match(/\bW-([a-z0-9]+)\b/);
+
+  let target = null, targetType = 'pr';
+  if (prMatch) {
+    target = prMatch[1];
+    targetType = 'pr';
+  } else if (wiMatch) {
+    target = 'W-' + wiMatch[1];
+    targetType = 'work-item';
+  }
+  if (!target) return null; // Can't synthesize without a target
+
+  // Extract interval (e.g. "every 15 minutes", "every 5m")
+  const intervalMatch = text.match(/every\s+(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?)\b/i);
+  let interval = '5m';
+  if (intervalMatch) interval = intervalMatch[1] + intervalMatch[2][0];
+
+  // Infer condition from keywords
+  let condition = 'any';
+  if (/\bbuild\b/i.test(text) && /\b(?:pass(?:es|ing|ed)?|green|succeed(?:s|ed)?|success)\b/i.test(text)) condition = 'build-pass';
+  else if (/\bbuild\b/i.test(text) && /\b(?:fail(?:s|ing|ed)?|red|broken|broke)\b/i.test(text)) condition = 'build-fail';
+  else if (/\bmerge[d]?\b/i.test(text)) condition = 'merged';
+  else if (/\bcomplete[d]?\b/i.test(text)) condition = 'completed';
+
+  return {
+    type: 'create-watch',
+    target,
+    targetType,
+    condition,
+    interval,
+    owner: 'human',
+    description: 'Auto-converted from /loop invocation',
+    stopAfter: condition === 'any' ? 0 : 1,
+  };
+}
+
 // ── Server-side CC action execution ──────────────────────────────────────────
 // Actions are executed server-side so all clients (frontend, curl, Teams) get the same behavior.
 // The frontend still shows status toasts but no longer needs to fire the API calls.
@@ -661,6 +720,7 @@ async function executeCCActions(actions) {
           const kbDir = path.join(MINIONS_DIR, 'knowledge', category);
           if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
           shared.safeWrite(path.join(kbDir, slug + '.md'), `# ${action.title}\n\n${action.content || action.description || ''}`);
+          queries.invalidateKnowledgeBaseCache();
           results.push({ type: 'knowledge', ok: true });
           break;
         }
@@ -1419,6 +1479,63 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
+  async function handleWorkItemsCancel(req, res) {
+    try {
+      const body = await readBody(req);
+      const { id, source, reason } = body;
+      if (!id) return jsonReply(res, 400, { error: 'id required' });
+
+      // Find the right work-items file
+      let wiPath;
+      if (!source || source === 'central') {
+        wiPath = path.join(MINIONS_DIR, 'work-items.json');
+      } else {
+        const proj = PROJECTS.find(p => p.name === source);
+        if (proj) wiPath = shared.projectWorkItemsPath(proj);
+      }
+      if (!wiPath) return jsonReply(res, 404, { error: 'source not found' });
+
+      let result = null;
+      mutateJsonFileLocked(wiPath, (items) => {
+        if (!Array.isArray(items)) items = [];
+        const item = items.find(i => i.id === id);
+        if (!item) { result = { code: 404, body: { error: 'item not found' } }; return items; }
+        // Reject already-done or already-cancelled items
+        if (DONE_STATUSES.has(item.status) || item.status === WI_STATUS.CANCELLED) {
+          result = { code: 400, body: { error: 'cannot cancel item with status: ' + item.status } };
+          return items;
+        }
+        item.status = WI_STATUS.CANCELLED;
+        item._cancelledBy = reason || 'user';
+        item.cancelledAt = new Date().toISOString();
+        result = { code: 200, body: { ok: true, item } };
+        return items;
+      });
+      if (!result) return jsonReply(res, 500, { error: 'unexpected state' });
+      if (result.code !== 200) return jsonReply(res, result.code, result.body);
+
+      // Clean dispatch entries + kill running agent (outside lock)
+      const dispatchRemoved = cleanDispatchEntries(d =>
+        d.meta?.item?.id === id ||
+        d.meta?.dispatchKey?.endsWith(id)
+      );
+
+      // Clean cooldown entries
+      try {
+        const cooldownPath = path.join(MINIONS_DIR, 'engine', 'cooldowns.json');
+        const cooldowns = safeJsonObj(cooldownPath);
+        let cleaned = false;
+        for (const key of Object.keys(cooldowns)) {
+          if (key.includes(id)) { delete cooldowns[key]; cleaned = true; }
+        }
+        if (cleaned) safeWrite(cooldownPath, cooldowns);
+      } catch (e) { console.error('cooldown cleanup on cancel:', e.message); }
+
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, id, dispatchRemoved });
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
   async function handleWorkItemsArchive(req, res) {
     try {
       const body = await readBody(req);
@@ -1758,13 +1875,18 @@ const server = http.createServer(async (req, res) => {
       if (!body.source || !body.itemId) return jsonReply(res, 400, { error: 'source and itemId required' });
       const planPath = resolvePlanPath(body.source);
       if (!fs.existsSync(planPath)) return jsonReply(res, 404, { error: 'plan file not found' });
-      const plan = safeJsonObj(planPath);
-      if (!plan) return jsonReply(res, 500, { error: 'failed to read plan file' });
-      const idx = (plan.missing_features || []).findIndex(f => f.id === body.itemId);
-      if (idx < 0) return jsonReply(res, 404, { error: 'item not found in plan' });
-
-      plan.missing_features.splice(idx, 1);
-      safeWrite(planPath, plan);
+      let removed = false;
+      mutateJsonFileLocked(planPath, (plan) => {
+        if (!plan || Array.isArray(plan) || typeof plan !== 'object') plan = { missing_features: [] };
+        const features = Array.isArray(plan.missing_features) ? plan.missing_features : [];
+        const idx = features.findIndex(f => f.id === body.itemId);
+        if (idx < 0) return plan;
+        features.splice(idx, 1);
+        plan.missing_features = features;
+        removed = true;
+        return plan;
+      }, { defaultValue: { missing_features: [] } });
+      if (!removed) return jsonReply(res, 404, { error: 'item not found in plan' });
 
       // Also remove any materialized work item for this plan item
       let cancelled = false;
@@ -2121,7 +2243,7 @@ const server = http.createServer(async (req, res) => {
     for (const cat of shared.KB_CATEGORIES) result[cat] = [];
     for (const e of entries) {
       if (!result[e.cat]) result[e.cat] = [];
-      result[e.cat].push({ file: e.file, category: e.cat, title: e.title, agent: e.agent, date: e.date, size: e.size, preview: e.preview });
+      result[e.cat].push({ file: e.file, category: e.cat, title: e.title, agent: e.agent, date: e.date, sortTs: e.sortTs, size: e.size, preview: e.preview });
     }
     const swept = safeJson(path.join(ENGINE_DIR, 'kb-swept.json'));
     if (swept) result.lastSwept = swept.timestamp;
@@ -2315,6 +2437,7 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       const summary = `${merged} duplicates merged, ${removed} stale removed, ${reclassified} reclassified${pruned ? ', ' + pruned + ' old swept files pruned' : ''}`;
       safeWrite(path.join(ENGINE_DIR, 'kb-swept.json'), JSON.stringify({ timestamp: new Date().toISOString(), summary }));
+      queries.invalidateKnowledgeBaseCache();
       global._kbSweepLastResult = { ok: true, summary, plan };
       global._kbSweepLastCompletedAt = Date.now();
     } catch (e) {
@@ -3160,6 +3283,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
       const kbFile = path.join(kbDir, name);
       safeWrite(kbFile, kbContent);
+      queries.invalidateKnowledgeBaseCache();
 
       // Move inbox item to archive
       const archiveDir = path.join(MINIONS_DIR, 'notes', 'archive');
@@ -3532,6 +3656,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
 
         const parsed = parseCCActions(result.text);
+        // Safety net: detect /loop invocation and convert to create-watch
+        const _loopWatch = _detectLoopInvocation(parsed.text, parsed.actions);
+        if (_loopWatch) {
+          parsed.actions.push(_loopWatch);
+          console.warn('[CC] /loop invocation detected — converted to create-watch');
+          try { shared.log('warn', '/loop invocation detected in CC response — auto-converted to create-watch'); } catch {}
+        }
         if (parsed.actions.length > 0) {
           parsed.actionResults = await executeCCActions(parsed.actions);
         }
@@ -3694,6 +3825,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
         // Send final result with actions — execute server-side first
         const { text: displayText, actions } = parseCCActions(result.text);
+        // Safety net: detect /loop invocation and convert to create-watch
+        const _loopWatch = _detectLoopInvocation(displayText, actions);
+        if (_loopWatch) {
+          actions.push(_loopWatch);
+          console.warn('[CC] /loop invocation detected — converted to create-watch');
+          try { shared.log('warn', '/loop invocation detected in CC response — auto-converted to create-watch'); } catch {}
+        }
         let actionResults;
         if (actions.length > 0) {
           actionResults = await executeCCActions(actions);
@@ -4244,6 +4382,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/work-items/update', desc: 'Edit a pending/failed work item', params: 'id, source?, title?, description?, type?, priority?, agent?, references?, acceptanceCriteria?', handler: handleWorkItemsUpdate },
     { method: 'POST', path: '/api/work-items/retry', desc: 'Reset a failed/dispatched item to pending', params: 'id, source?', handler: handleWorkItemsRetry },
     { method: 'POST', path: '/api/work-items/delete', desc: 'Remove a work item, kill agent, clear dispatch', params: 'id, source?', handler: handleWorkItemsDelete },
+    { method: 'POST', path: '/api/work-items/cancel', desc: 'Cancel a work item, kill agent, clear dispatch', params: 'id, source?, reason?', handler: handleWorkItemsCancel },
     { method: 'POST', path: '/api/work-items/archive', desc: 'Move a completed/failed work item to archive', params: 'id, source?', handler: handleWorkItemsArchive },
     { method: 'GET', path: '/api/work-items/archive', desc: 'List archived work items', handler: handleWorkItemsArchiveList },
     { method: 'POST', path: '/api/work-items/reopen', desc: 'Reopen a done/failed work item back to pending', params: 'id, project?, description?', handler: handleWorkItemsReopen },
@@ -4548,6 +4687,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       const header = '# ' + title + '\n\n*Created by human teammate on ' + new Date().toISOString().slice(0, 10) + '*\n\n';
       safeWrite(filePath, header + content);
+      queries.invalidateKnowledgeBaseCache();
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, path: filePath });
     }},

package/engine/ado.js

@@ -16,6 +16,10 @@ function engine() {
   return _engine;
 }
 
+// Lazy require for dispatch module (avoids circular dependency via engine)
+let _dispatch = null;
+function dispatchModule() { if (!_dispatch) _dispatch = require('./dispatch'); return _dispatch; }
+
 const stripRefsHeads = s => (s || '').replace('refs/heads/', '');
 const getAdoPrUrl = (project, prNumber) => {
   if (project.prUrlBase) return `${project.prUrlBase}${prNumber}`;
@@ -346,6 +350,10 @@ async function pollPrStatus(config) {
           delete pr.buildFixAttempts;
           delete pr.buildFixEscalated;
         }
+        // Cancel any pending review/fix dispatches — they're stale now that the PR is closed
+        try {
+          dispatchModule().cancelPendingDispatchesForPr(pr.id);
+        } catch (e) { log('warn', `Cancel dispatches for ${pr.id}: ${e.message}`); }
         await engine().handlePostMerge(pr, project, config, newStatus);
       }
     }

package/engine/cleanup.js

@@ -9,7 +9,7 @@ const shared = require('./shared');
 const queries = require('./queries');
 
 const { exec, execSilent, log, ts, ENGINE_DEFAULTS } = shared;
-const { safeJson, safeWrite, safeReadDir, mutateWorkItems, getProjects, projectWorkItemsPath, projectPrPath,
+const { safeJson, safeWrite, safeReadDir, mutateWorkItems, mutateJsonFileLocked, getProjects, projectWorkItemsPath, projectPrPath,
   sanitizeBranch, KB_CATEGORIES } = shared;
 const { getDispatch, getAgentStatus } = queries;
 
@@ -667,6 +667,9 @@ function runCleanup(config, verbose = false) {
     }
   } catch { /* optional — file may not exist */ }
 
+  // 14. Scrub stale temp agent keys from metrics.json
+  try { scrubStaleMetrics(); } catch { /* best-effort cleanup */ }
+
   if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed > 0) {
     log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.pidFiles} PID files`);
   }
@@ -674,9 +677,27 @@ function runCleanup(config, verbose = false) {
   return cleaned;
 }
 
+// ─── Metrics Scrub ──────────────────────────────────────────────────────────
+
+/** Remove stale temp-*, agent1, and _test-* keys from metrics.json.
+ *  Mirrors the guard in lifecycle.js updateMetrics() — cleans up keys
+ *  that were written before that guard existed. */
+function scrubStaleMetrics() {
+  const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
+  if (!fs.existsSync(metricsPath)) return;
+  mutateJsonFileLocked(metricsPath, metrics => {
+    for (const key of Object.keys(metrics)) {
+      if (key.startsWith('temp-') || key === 'agent1' || key.startsWith('_test')) {
+        delete metrics[key];
+      }
+    }
+  });
+}
+
 // ─── Exports ─────────────────────────────────────────────────────────────────
 
 module.exports = {
   runCleanup,
+  scrubStaleMetrics,
   worktreeDirMatchesBranch,  // exported for testing
 };

package/engine/dispatch.js

@@ -278,6 +278,31 @@ function updateAgentStatus(dispatchId, status, detail) {
   });
 }
 
+// ─── Cancel Pending Dispatches for Closed PR ───────────────────────────────
+
+/**
+ * Cancel all pending dispatch entries that reference a specific PR.
+ * Called when a PR transitions to merged/abandoned/closed — any pending
+ * review, fix, or re-review dispatches for that PR are stale and should
+ * not be spawned.
+ * @param {string} prId — PR identifier (e.g. 'PR-100')
+ * @returns {number} count of cancelled entries
+ */
+function cancelPendingDispatchesForPr(prId) {
+  if (!prId) return 0;
+  let cancelled = 0;
+  mutateDispatch((dispatch) => {
+    const before = dispatch.pending.length;
+    dispatch.pending = dispatch.pending.filter(d => d.meta?.pr?.id !== prId);
+    cancelled = before - dispatch.pending.length;
+    return dispatch;
+  });
+  if (cancelled > 0) {
+    log('info', `Cancelled ${cancelled} pending dispatch(es) for closed PR ${prId}`);
+  }
+  return cancelled;
+}
+
 // ─── Exports ─────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -287,4 +312,5 @@ module.exports = {
   completeDispatch,
   writeInboxAlert,
   updateAgentStatus,
+  cancelPendingDispatchesForPr,
 };

package/engine/github.js

@@ -16,6 +16,10 @@ function engine() {
   return _engine;
 }
 
+// Lazy require for dispatch module (avoids circular dependency via engine)
+let _dispatch = null;
+function dispatchModule() { if (!_dispatch) _dispatch = require('./dispatch'); return _dispatch; }
+
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 function isGitHub(project) {
@@ -327,6 +331,10 @@ async function pollPrStatus(config) {
           delete pr.buildFixAttempts;
           delete pr.buildFixEscalated;
         }
+        // Cancel any pending review/fix dispatches — they're stale now that the PR is closed
+        try {
+          dispatchModule().cancelPendingDispatchesForPr(pr.id);
+        } catch (e) { log('warn', `Cancel dispatches for ${pr.id}: ${e.message}`); }
         await engine().handlePostMerge(pr, project, config, newStatus);
       }
     }

package/engine/lifecycle.js

@@ -13,6 +13,7 @@ const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, ex
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
 const { isBranchActive } = require('./cooldown');
+const { worktreeDirMatchesBranch } = require('./cleanup');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
   MINIONS_DIR, ENGINE_DIR, PLANS_DIR, PRD_DIR, INBOX_DIR, AGENTS_DIR } = queries;
 
@@ -814,6 +815,8 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     });
   }
 
+  const entryBranch = meta?.branch || '';
+
   for (const [prPath, { name, project: targetProject, entries }] of newPrsByPath) {
     const linksToPersist = [];
     mutateJsonFileLocked(prPath, (data) => {
@@ -824,6 +827,28 @@ function syncPrsFromOutput(output, agentId, meta, config) {
       }
       for (const { prId, fullId, entry } of entries) {
         if (prs.some(p => p.id === fullId || (p.url && p.url === entry.url))) continue;
+
+        // Branch-level dedup: skip if an active PR already exists on the same branch.
+        // This prevents duplicate PRs when an agent retries and calls `gh pr create` again
+        // on the same branch (GitHub allows multiple PRs from one branch).
+        // Only block when the existing PR is active — abandoned/merged PRs don't conflict.
+        const branch = entry.branch || entryBranch;
+        if (branch) {
+          const existingOnBranch = prs.find(p => p.branch === branch && p.status === PR_STATUS.ACTIVE && p.id !== fullId);
+          if (existingOnBranch) {
+            log('warn', `Duplicate PR detected: ${fullId} on branch ${branch} — already tracked as ${existingOnBranch.id}. Skipping.`);
+            // Best-effort close the duplicate on GitHub (non-blocking, fire-and-forget)
+            try {
+              const ghSlug = output.match(/github\.com\/([^/]+\/[^/]+)/)?.[1];
+              if (ghSlug) {
+                execAsync(`gh pr close ${prId} --repo ${ghSlug} --comment "Closing duplicate — ${existingOnBranch.id} already tracks this branch."`, { timeout: 15000 })
+                  .catch(() => {});
+              }
+            } catch { /* best-effort */ }
+            continue;
+          }
+        }
+
         prs.push(entry);
         if (meta?.item?.id) {
           linksToPersist.push({ prId: fullId, itemId: meta.item.id, project: targetProject, prNumber: entry.prNumber, url: entry.url });
@@ -1041,8 +1066,10 @@ const PENDING_REBASES_PATH = path.join(ENGINE_DIR, 'pending-rebases.json');
 
 function queuePendingRebase(pr, project, mergedItemId) {
   mutateJsonFileLocked(PENDING_REBASES_PATH, (pending) => {
-    if (pending.some(e => e.prId === pr.id)) return; // already queued
+    const prDisplayId = shared.getPrDisplayId(pr);
+    if (pending.some(e => e.projectName === project.name && shared.getPrDisplayId(e.prId) === prDisplayId)) return pending; // already queued
     pending.push({ prId: pr.id, branch: pr.branch, projectName: project.name, mergedItemId, queuedAt: ts(), attempts: 0 });
+    return pending;
   }, { defaultValue: [] });
 }
 
@@ -1063,9 +1090,11 @@ async function processPendingRebases(config) {
     const project = shared.getProjects(config).find(p => p.name === entry.projectName);
     if (!project) continue;
 
-    const prs = safeJson(projectPrPath(project)) || [];
-    const pr = prs.find(p => p.id === entry.prId && p.status === PR_STATUS.ACTIVE);
+    const prs = getPrs(project);
+    const pr = shared.findPrRecord(prs, entry.prId, project);
+    if (pr && pr.id !== entry.prId) entry.prId = pr.id;
     if (!pr) continue; // PR closed/merged since queuing
+    if (pr.status !== PR_STATUS.ACTIVE) continue; // PR closed/merged since queuing
 
     const result = await rebaseBranchOntoMain(pr, project, config);
     if (!result.success) {
@@ -1096,12 +1125,11 @@ async function handlePostMerge(pr, project, config, newStatus) {
     const root = path.resolve(project.localPath);
     const wtRoot = path.resolve(root, config.engine?.worktreeRoot || '../worktrees');
     // Find worktrees matching this branch — dir format is {slug}-{branch}-{suffix}
-    const branchSlug = shared.sanitizeBranch(pr.branch).toLowerCase();
     try {
       const dirs = require('fs').readdirSync(wtRoot);
       for (const dir of dirs) {
         const dirLower = dir.toLowerCase();
-        if (dirLower.includes(branchSlug) || dir === pr.branch || dir === `bt-${prNum}`) {
+        if (worktreeDirMatchesBranch(dirLower, pr.branch) || dir === pr.branch || dir === `bt-${prNum}`) {
           const wtPath = path.join(wtRoot, dir);
           try {
             if (!require('fs').statSync(wtPath).isDirectory()) continue;
@@ -1778,7 +1806,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         // Find the worktree directory for this dispatch's branch
         const branchSlug = shared.sanitizeBranch ? shared.sanitizeBranch(meta.branch) : meta.branch.replace(/[^a-zA-Z0-9._\-\/]/g, '-');
         const dirs = fs.readdirSync(worktreeRoot).filter(d => {
-          return d.includes(branchSlug) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
+          return worktreeDirMatchesBranch(d.toLowerCase(), meta.branch) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
         });
         // Only remove if no other active dispatch uses this branch
         const dispatch = getDispatch();

package/engine/pipeline.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
+const queries = require('./queries');
 const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, ENGINE_DEFAULTS } = shared;
 const http = require('http');
 const { parseCronExpr, shouldRunNow } = require('./scheduler');
@@ -144,6 +145,46 @@ function resolveStageConfig(stage, run) {
   return resolved;
 }
 
+function collectPipelinePrRefs(pipeline, run) {
+  const refs = [];
+  const seen = new Set();
+  function addPrRef(resource) {
+    if (!resource) return;
+    let type = '';
+    let id = '';
+    let url = '';
+    if (typeof resource === 'string') {
+      id = resource.trim();
+      url = /^https?:\/\//i.test(id) ? id : '';
+    } else if (typeof resource === 'object') {
+      type = String(resource.type || '').trim().toLowerCase();
+      id = String(resource.label || resource.id || '').trim();
+      url = String(resource.url || '').trim();
+    } else {
+      return;
+    }
+    if (type && type !== 'pr') return;
+    const refId = id || url;
+    if (!refId && !url) return;
+    const prNumber = shared.getPrNumber({ id: refId, url });
+    if (!type && prNumber == null) return;
+    const key = url || refId;
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    refs.push({ id: refId, url });
+  }
+  for (const res of (pipeline?.monitoredResources || [])) addPrRef(res);
+  for (const stage of (pipeline?.stages || [])) {
+    for (const res of (stage?.monitoredResources || [])) addPrRef(res);
+  }
+  if (run) {
+    for (const [, stageState] of Object.entries(run.stages || {})) {
+      for (const prRef of (stageState.artifacts?.prs || [])) addPrRef(prRef);
+    }
+  }
+  return refs;
+}
+
 // ── Condition Evaluation ─────────────────────────────────────────────────────
 
 /**
@@ -186,27 +227,12 @@ function evaluateCondition(condition, ctx) {
       return pipelineRuns.length >= threshold;
     }
     case 'allBuildsGreen': {
-      // True when all PRs in monitoredResources (or run artifacts) have buildStatus 'passing'
-      const projects = shared.getProjects(config);
-      const allPrs = projects.reduce((acc, p) => {
-        return acc.concat(safeJson(shared.projectPrPath(p)) || []);
-      }, []);
-
-      // Collect PR IDs to check: from monitoredResources (type: 'pr') or run artifact PRs
-      const prIds = new Set();
-      for (const res of (pipeline?.monitoredResources || [])) {
-        const r = typeof res === 'string' ? { label: res } : res;
-        if (r.type === 'pr' && r.label) prIds.add(r.label);
-      }
-      // Also check PRs from run artifacts
-      if (run) {
-        for (const [, s] of Object.entries(run.stages || {})) {
-          for (const prId of (s.artifacts?.prs || [])) prIds.add(prId);
-        }
-      }
-      if (prIds.size === 0) return false; // no PRs to check = can't confirm green
-      for (const prId of prIds) {
-        const pr = allPrs.find(p => p.id === prId);
+      // True when all PRs in monitoredResources (pipeline-level or stage-level) or run artifacts have buildStatus 'passing'
+      const allPrs = queries.getPullRequests(config);
+      const prRefs = collectPipelinePrRefs(pipeline, run);
+      if (prRefs.length === 0) return false; // no PRs to check = can't confirm green
+      for (const prRef of prRefs) {
+        const pr = shared.findPrRecord(allPrs, prRef);
         if (!pr || pr.buildStatus !== 'passing') return false;
       }
       return true;

package/engine/teams.js

@@ -526,7 +526,7 @@ async function teamsNotifyPrEvent(pr, event, project, prFilePath) {
   if (!cfg.notifyEvents || !cfg.notifyEvents.includes(event)) return;
 
   // Dedup check — don't re-notify the same event
-  if (pr._teamsNotifiedEvents && pr._teamsNotifiedEvents.includes(event)) return;
+  if (!prFilePath && pr._teamsNotifiedEvents && pr._teamsNotifiedEvents.includes(event)) return;
 
   const card = cards.buildPrCard(pr, event, project);
 
@@ -535,24 +535,45 @@ async function teamsNotifyPrEvent(pr, event, project, prFilePath) {
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) return;
 
+  let claimedEvent = false;
+  let shouldPost = true;
   try {
-    await teamsPost(convKeys[0], card);
-    log('info', `Teams PR notification sent: ${event} for ${pr.id}`);
-
-    // Record dedup — update _teamsNotifiedEvents on PR via lock
     if (prFilePath) {
       mutateJsonFileLocked(prFilePath, (prs) => {
         if (!Array.isArray(prs)) return prs;
         const target = shared.findPrRecord(prs, pr);
-        if (target) {
-          if (!target._teamsNotifiedEvents) target._teamsNotifiedEvents = [];
-          if (!target._teamsNotifiedEvents.includes(event)) {
-            target._teamsNotifiedEvents.push(event);
-          }
+        if (!target) return prs;
+        if (!target._teamsNotifiedEvents) target._teamsNotifiedEvents = [];
+        if (target._teamsNotifiedEvents.includes(event)) {
+          shouldPost = false;
+          return prs;
         }
+        target._teamsNotifiedEvents.push(event);
+        claimedEvent = true;
+        return prs;
       }, { defaultValue: [] });
     }
+    if (!shouldPost) return;
+    await teamsPost(convKeys[0], card);
+    if (pr && typeof pr === 'object') {
+      if (!Array.isArray(pr._teamsNotifiedEvents)) pr._teamsNotifiedEvents = [];
+      if (!pr._teamsNotifiedEvents.includes(event)) pr._teamsNotifiedEvents.push(event);
+    }
+    log('info', `Teams PR notification sent: ${event} for ${pr.id}`);
   } catch (err) {
+    if (claimedEvent && prFilePath) {
+      try {
+        mutateJsonFileLocked(prFilePath, (prs) => {
+          if (!Array.isArray(prs)) return prs;
+          const target = shared.findPrRecord(prs, pr);
+          if (!target || !Array.isArray(target._teamsNotifiedEvents)) return prs;
+          target._teamsNotifiedEvents = target._teamsNotifiedEvents.filter(e => e !== event);
+          return prs;
+        }, { defaultValue: [] });
+      } catch (revertErr) {
+        log('warn', `Teams PR dedup revert failed for ${pr.id}: ${revertErr.message}`);
+      }
+    }
     log('warn', `Teams PR notification failed for ${pr.id}: ${err.message}`);
   }
 }

package/package.json

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

package/prompts/cc-system.md

@@ -91,11 +91,14 @@ Additional actions (all take `id` or `file` as primary key):
 - Schedules: schedule (id, title, cron, workType, project, agent, description, priority, enabled), delete-schedule (id)
 - Pipelines: create-pipeline (id, title, stages[], trigger, stopWhen, monitoredResources), edit-pipeline (id, title, stages, trigger), delete-pipeline (id), trigger-pipeline (id), abort-pipeline (id), retrigger-pipeline (id)
 - Meetings: add-meeting-note (id, note), advance-meeting (id), end-meeting (id), archive-meeting (id), unarchive-meeting (id), delete-meeting (id)
-- Work item ops: delete-work-item (id, source), archive-work-item (id), work-item-feedback (id, rating: up/down, comment), reopen-work-item (id, project[, description] — reopen a done/failed item back to pending)
+- Work item ops: delete-work-item (id, source), cancel-work-item (id, source?, reason? — cancel a pending/dispatched/failed item, kills running agent), archive-work-item (id), work-item-feedback (id, rating: up/down, comment), reopen-work-item (id, project[, description] — reopen a done/failed item back to pending)
 - PRD ops: edit-prd-item, remove-prd-item, reopen-prd-item (id, file — re-dispatches on existing branch)
 - **create-watch**: target, targetType (pr/work-item), condition (merged/build-fail/build-pass/completed/failed/status-change/any/new-comments/vote-change), interval ("15m", "1h", "30s" — default "5m"), owner (agent id or "human"), description, project, stopAfter (0=run forever, 1=expire on first match, N=expire after N matches), onNotMet (null=do nothing, "notify"=write to inbox each poll while condition not met)
+  **NEVER use the /loop skill for monitoring tasks.** Always use the `create-watch` action — it persists across engine restarts and appears in the Watches page. /loop runs ephemerally in the session and leaves no trace.
+  Trigger phrases: user says "keep an eye on X", "watch X every N min", "monitor X", "check X periodically", "ping me when X" → always emit `create-watch`.
   Example: user says "check PR 1065 build every 15 min until green" → `{"type":"create-watch","target":"1065","targetType":"pr","condition":"build-pass","interval":"15m","stopAfter":1,"description":"Watch PR 1065 build until green"}`
   Example: user says "ping me every 15 min while build is still failing" → `{"type":"create-watch","target":"1065","targetType":"pr","condition":"build-pass","interval":"15m","stopAfter":1,"onNotMet":"notify","description":"Watch PR 1065 build — notify each poll"}`
+  Example: user says "keep an eye on PR 200 every 5 min" → `{"type":"create-watch","target":"200","targetType":"pr","condition":"any","interval":"5m","stopAfter":0,"description":"Monitor PR 200"}`
 - **delete-watch**: id — remove a watch permanently
   Example: user says "stop watching PR 1065" → `{"type":"delete-watch","id":"watch-abc123"}`
 - **pause-watch**: id — pause a watch without deleting it (can be resumed later)