@yemi33/minions 0.1.1005 → 0.1.1007

package/CHANGELOG.md

@@ -1,8 +1,12 @@
 # Changelog
 
-## 0.1.1005 (2026-04-16)
+## 0.1.1007 (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)
 - remove DEFAULTS alias from timeout.js (#1101)
@@ -19,10 +23,6 @@
 -  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)
-- gate auto-fix conflict dispatch behind autoFixConflicts flag
 
 ### Fixes
 -  harden repo-scoped PR identity handling

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.
@@ -1419,6 +1478,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);
@@ -3532,6 +3648,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 +3817,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 +4374,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 },

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

@@ -8,7 +8,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { exec, execSilent, log, ts } = shared;
+const { exec, execSilent, log, ts, ENGINE_DEFAULTS } = shared;
 const { safeJson, safeWrite, safeReadDir, mutateWorkItems, getProjects, projectWorkItemsPath, projectPrPath,
   sanitizeBranch, KB_CATEGORIES } = shared;
 const { getDispatch, getAgentStatus } = queries;
@@ -597,11 +597,23 @@ function runCleanup(config, verbose = false) {
   } catch (e) { log('warn', 'prune doc-sessions: ' + e.message); }
 
   // 11. Cap cooldowns.json — keep at most 500 entries (on top of 24h TTL in cooldown.js)
+  //     Also trim pendingContexts arrays to ENGINE_DEFAULTS.maxPendingContexts to prevent bloat.
   cleaned.cooldowns = 0;
+  cleaned.pendingContextsTrimmed = 0;
   try {
     const cooldownPath = path.join(ENGINE_DIR, 'cooldowns.json');
     const cooldowns = safeJson(cooldownPath);
     if (cooldowns && typeof cooldowns === 'object') {
+      let dirty = false;
+      // Trim oversized pendingContexts arrays (one-time migration + ongoing cap)
+      const pendingCtxCap = ENGINE_DEFAULTS.maxPendingContexts;
+      for (const v of Object.values(cooldowns)) {
+        if (Array.isArray(v.pendingContexts) && v.pendingContexts.length > pendingCtxCap) {
+          v.pendingContexts = v.pendingContexts.slice(-pendingCtxCap);
+          cleaned.pendingContextsTrimmed++;
+          dirty = true;
+        }
+      }
       const entries = Object.entries(cooldowns);
       const COOLDOWN_CAP = 500;
       if (entries.length > COOLDOWN_CAP) {
@@ -610,6 +622,8 @@ function runCleanup(config, verbose = false) {
         const keep = Object.fromEntries(entries.slice(0, COOLDOWN_CAP));
         cleaned.cooldowns = entries.length - COOLDOWN_CAP;
         safeWrite(cooldownPath, keep);
+      } else if (dirty) {
+        safeWrite(cooldownPath, cooldowns);
       }
     }
   } catch (e) { log('warn', 'cap cooldowns: ' + e.message); }
@@ -653,8 +667,8 @@ function runCleanup(config, verbose = false) {
     }
   } catch { /* optional — file may not exist */ }
 
-  if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles > 0) {
-    log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pidFiles} PID files`);
+  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`);
   }
 
   return cleaned;

package/engine/cooldown.js

@@ -7,7 +7,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { safeJson, safeWrite, log } = shared;
+const { safeJson, safeWrite, log, ENGINE_DEFAULTS } = shared;
 const { ENGINE_DIR } = queries;
 
 const COOLDOWN_PATH = path.join(ENGINE_DIR, 'cooldowns.json');
@@ -37,6 +37,13 @@ function saveCooldowns() {
     for (const [k, v] of dispatchCooldowns) {
       if (now - v.timestamp > 24 * 60 * 60 * 1000) dispatchCooldowns.delete(k);
     }
+    // Trim pendingContexts arrays before writing to prevent bloat
+    const cap = ENGINE_DEFAULTS.maxPendingContexts;
+    for (const [, v] of dispatchCooldowns) {
+      if (Array.isArray(v.pendingContexts) && v.pendingContexts.length > cap) {
+        v.pendingContexts = v.pendingContexts.slice(-cap);
+      }
+    }
     const obj = Object.fromEntries(dispatchCooldowns);
     try {
       safeWrite(COOLDOWN_PATH, obj);
@@ -61,8 +68,11 @@ function setCooldown(key) {
 
 function setCooldownWithContext(key, context) {
   const existing = dispatchCooldowns.get(key);
-  const pendingContexts = existing?.pendingContexts || [];
+  let pendingContexts = existing?.pendingContexts || [];
   if (context) pendingContexts.push(context);
+  // Cap to last N entries to prevent unbounded growth (cooldowns.json bloat)
+  const cap = ENGINE_DEFAULTS.maxPendingContexts;
+  if (pendingContexts.length > cap) pendingContexts = pendingContexts.slice(-cap);
   dispatchCooldowns.set(key, {
     timestamp: Date.now(),
     failures: existing?.failures || 0,

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

@@ -814,6 +814,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 +826,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 });

package/engine/shared.js

@@ -569,6 +569,7 @@ const ENGINE_DEFAULTS = {
   ccModel: 'sonnet', // model for Command Center and doc-chat (sonnet, haiku, opus)
   ccEffort: null, // effort level for CC/doc-chat (null, 'low', 'medium', 'high')
   heartbeatTimeouts: {}, // populated after WORK_TYPE is defined (below)
+  maxPendingContexts: 20, // cap pendingContexts arrays in cooldowns.json to prevent unbounded growth
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
   // Teams integration — config.teams shape: { enabled, appId, appPassword, certPath, privateKeyPath, tenantId, notifyEvents, ccMirror, inboxPollInterval }
   // Auth modes: (1) appId + appPassword (client secret), or (2) appId + certPath + privateKeyPath + tenantId (certificate)

package/package.json

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