@yemi33/minions 0.1.1800 → 0.1.1802

package/dashboard.js

@@ -1929,16 +1929,52 @@ function fencedUntrustedBlock(label, content) {
   return `### ${label}\n${fence}text\n${value}\n${fence}`;
 }
 
+function _messageExplicitlyRequestsMonitoring(message) {
+  const text = String(message || '').toLowerCase();
+  if (!text.trim()) return false;
+  if (/\b(?:do\s+not|don't|dont|never|without|no\s+need\s+to)\s+(?:monitor(?:ing)?|watch(?:ing)?|poll(?:ing)?|check(?:ing)?|notify(?:ing)?|ping(?:ing)?|keep(?:ing)?\s+an\s+eye)\b/.test(text)) {
+    return false;
+  }
+  return [
+    /\bmonitor(?:ing)?\b/,
+    /\bwatch(?:ing)?\b/,
+    /\bkeep(?:ing)?\s+an\s+eye\s+on\b/,
+    /\bcheck(?:ing)?\s+(?:it|this|that|[^.?!\n]+)\s+periodically\b/,
+    /\bperiodically\s+check\b/,
+    /\bcheck(?:ing)?\s+[^.?!\n]+\bevery\s+\d+\s*(?:s|sec|seconds?|m|min|minutes?|h|hr|hours?)\b/,
+    /\bevery\s+\d+\s*(?:s|sec|seconds?|m|min|minutes?|h|hr|hours?)\b[^.?!\n]+\b(?:check|poll|monitor|watch)\b/,
+    /\bping\s+(?:me\s+)?(?:on|when|after)\b/,
+    /\bping\s+on\s+completion\b/,
+    /\bnotify\s+(?:me\s+)?(?:on|when|after)\b/,
+    /\blet\s+me\s+know\s+(?:when|once|if)\b/,
+    /\bpoll(?:ing)?\b/,
+  ].some(pattern => pattern.test(text));
+}
+
+function _isDispatchLikeCCAction(action) {
+  const type = String(action?.type || '').trim().toLowerCase();
+  return type === 'dispatch' || ['fix', 'explore', 'review', 'test'].includes(type);
+}
+
+function _filterImplicitPostDispatchActions(actions, humanMessage) {
+  if (!Array.isArray(actions) || actions.length === 0) return [];
+  if (_messageExplicitlyRequestsMonitoring(humanMessage)) return actions;
+  const dispatchIdx = actions.findIndex(_isDispatchLikeCCAction);
+  if (dispatchIdx < 0) return actions;
+  return actions.slice(0, dispatchIdx + 1);
+}
+
 // ── /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, toolUses) {
+function _detectLoopInvocation(text, actions, toolUses, humanMessage) {
   const observedToolUses = Array.isArray(toolUses) ? toolUses : [];
   if (!text && observedToolUses.length === 0) return null;
   // If a create-watch action was already emitted, no fallback needed
   if (actions && actions.some(a => a.type === 'create-watch')) return null;
+  if (humanMessage !== undefined && !_messageExplicitlyRequestsMonitoring(humanMessage)) return null;
 
   function _extractTargetFromValue(value, keyHint) {
     if (value == null) return null;
@@ -6509,12 +6545,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         const parsed = parseCCActions(result.text);
         const toolUses = Array.isArray(result.toolUses) ? result.toolUses : _extractToolUsesFromRaw(result.raw);
         // Safety net: detect /loop invocation and convert to create-watch
-        const _loopWatch = _detectLoopInvocation(parsed.text, parsed.actions, toolUses);
+        const _loopWatch = _detectLoopInvocation(parsed.text, parsed.actions, toolUses, body.message);
         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 {}
         }
+        parsed.actions = _filterImplicitPostDispatchActions(parsed.actions, body.message);
         if (parsed.actions.length > 0) {
           parsed.actionResults = await executeCCActions(parsed.actions);
         }
@@ -6834,14 +6871,15 @@ 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, _actionParseError } = parseCCActions(result.text);
+        let { text: displayText, actions, _actionParseError } = parseCCActions(result.text);
         // Safety net: detect /loop invocation and convert to create-watch
-        const _loopWatch = _detectLoopInvocation(displayText, actions, toolUses);
+        const _loopWatch = _detectLoopInvocation(displayText, actions, toolUses, body.message);
         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 {}
         }
+        actions = _filterImplicitPostDispatchActions(actions, body.message);
         let actionResults;
         if (actions.length > 0) {
           actionResults = await executeCCActions(actions);
@@ -8471,6 +8509,8 @@ module.exports = {
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,
   _ccValidateAction,
+  _messageExplicitlyRequestsMonitoring,
+  _filterImplicitPostDispatchActions,
   _findDuplicateWorkItemCreate: findDuplicateWorkItemCreate,
   _createWorkItemWithDedup: createWorkItemWithDedup,
   _resolveWorkItemsCreateTarget: resolveWorkItemsCreateTarget,

package/engine/cli.js

@@ -1079,14 +1079,14 @@ const commands = {
       return;
     }
     const dispatch = getDispatch();
-    const found = (dispatch.active || []).some(d => d.id === id);
-    if (!found) {
+    const item = (dispatch.active || []).find(d => d.id === id);
+    if (!item) {
       console.log(`  Dispatch "${id}" not found in active queue.`);
       const pending = (dispatch.pending || []).some(d => d.id === id);
       if (pending) console.log('  (It is in pending — it hasn\'t started yet.)');
       return;
     }
-    engine().completeDispatch(id, 'success');
+    engine().completeDispatch(id, DISPATCH_RESULT.SUCCESS, '', '', { processWorkItemSuccess: true });
     console.log(`  Marked ${id} as completed.`);
   },
 

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-08T16:56:04.298Z"
+  "cachedAt": "2026-05-08T17:22:37.672Z"
 }

package/engine/dispatch.js

@@ -322,12 +322,45 @@ function writeFailedAgentReport(item, reason, resultSummary, failureClass) {
   shared.writeToInbox(agentId, `agent-failure-${item.id}`, content, null, metadata);
 }
 
+function markCompletedSourceWorkItem(item) {
+  const meta = item?.meta;
+  const itemId = meta?.item?.id;
+  if (!itemId) return false;
+  const wiPath = lifecycle().resolveWorkItemPath(meta);
+  if (!wiPath) return false;
+  let found = false;
+  let terminal = false;
+  mutateWorkItems(wiPath, items => {
+    if (!Array.isArray(items)) return items;
+    const wi = items.find(i => i.id === itemId);
+    if (!wi) return items;
+    found = true;
+    if (wi.status === WI_STATUS.DONE) {
+      terminal = true;
+      return items;
+    }
+    wi.status = WI_STATUS.DONE;
+    delete wi.failReason;
+    delete wi.failedAt;
+    delete wi._retryCount;
+    if (!wi.completedAt) wi.completedAt = ts();
+    if (item.agent && !wi.dispatched_to) wi.dispatched_to = item.agent;
+    terminal = true;
+    return items;
+  });
+  if (!found) {
+    throw new Error(`source work item ${itemId} not found`);
+  }
+  return terminal;
+}
+
 // ─── Complete Dispatch ───────────────────────────────────────────────────────
 
 function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', resultSummary = '', opts = {}) {
-  const { processWorkItemFailure = true, failureClass } = opts;
+  const { processWorkItemFailure = true, processWorkItemSuccess = false, failureClass } = opts;
   const agentRetryable = normalizeRetryableDecision(opts.agentRetryable ?? opts.retryable);
   let item = null;
+  let completedSourceWorkItem = false;
 
   mutateDispatch((dispatch) => {
     // Check active list first
@@ -356,6 +389,10 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
         item.meta.completionReportPath = opts.structuredCompletion._path;
       }
     }
+    if (processWorkItemSuccess && result === DISPATCH_RESULT.SUCCESS && item.meta?.item?.id) {
+      if (item.agent) item.meta._agentId = item.agent;
+      completedSourceWorkItem = markCompletedSourceWorkItem(item);
+    }
     // Drop prompt (and sidecar file, if any) — completed entries don't need
     // replayable content and it would accumulate forever (#1167).
     try { deleteDispatchPromptSidecar(item); } catch { /* best-effort */ }
@@ -469,6 +506,13 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
       }
     }
 
+    if (completedSourceWorkItem) {
+      try {
+        lifecycle().syncPrdItemStatus(item.meta.item.id, WI_STATUS.DONE, item.meta.item?.sourcePlan);
+        log('info', `Work item ${item.meta.item.id} → ${WI_STATUS.DONE}`);
+      } catch (e) { log('warn', 'manual completion PRD sync: ' + e.message); }
+    }
+
     // Restore pendingFix on failed human-feedback fix so engine re-dispatches on next tick
     if (result === DISPATCH_RESULT.ERROR && item.meta?.source === 'pr-human-feedback') {
       const prId = item.meta.pr?.id;

package/package.json

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