@yemi33/minions 0.1.1801 → 0.1.1803

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1803 (2026-05-08)
+
+### Other
+- Guarantee Copilot steering delivery (#2225)
+
 ## 0.1.1800 (2026-05-08)
 
 ### Other

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/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-08T17:21:22.511Z"
+  "cachedAt": "2026-05-08T17:37:37.501Z"
 }

package/engine.js

@@ -407,6 +407,50 @@ function mergePendingSteeringEntries(...groups) {
   return merged;
 }
 
+function promoteCheckpointSteeringForClose(agentId, procInfo, runtime, liveOutputPath) {
+  if (!procInfo || procInfo._steeringMessage) return { status: 'none', entries: [] };
+  if (runtime?.capabilities?.midRunSessionId !== false) return { status: 'none', entries: [] };
+
+  const startedAtMs = Date.parse(procInfo.startedAt);
+  const runStartMs = Number.isFinite(startedAtMs) ? startedAtMs : 0;
+  const pendingPaths = new Set((procInfo._pendingSteeringFiles || []).map(entry => entry?.path || entry).filter(Boolean));
+  const deferredPaths = new Set((procInfo._deferredSteeringFiles || []).filter(Boolean));
+  const unread = steering.listUnreadSteeringMessages(agentId).filter(entry => entry.message.trim());
+  const entriesByPath = new Map(unread.map(entry => [entry.path, entry]));
+  const pendingDeferred = Array.from(deferredPaths)
+    .map(filePath => entriesByPath.get(filePath))
+    .filter(Boolean);
+  const lateCheckpoint = unread.filter(entry =>
+    entry.createdAtMs >= runStartMs
+    && !pendingPaths.has(entry.path)
+    && !deferredPaths.has(entry.path)
+  );
+  const checkpointEntries = mergePendingSteeringEntries(pendingDeferred, lateCheckpoint);
+  if (checkpointEntries.length === 0) {
+    delete procInfo._deferredSteeringFiles;
+    return { status: 'none', entries: [] };
+  }
+
+  if (!procInfo.sessionId) {
+    log('warn', `Steering: ${agentId} exited before a resumable sessionId was available - ${checkpointEntries.length} message(s) remain pending`);
+    try { fs.appendFileSync(liveOutputPath, `\n[steering-pending] Agent exited before a resumable session was available. Your message remains unread and will be retried on the next dispatch.\n`); } catch {}
+    return { status: 'pending', entries: checkpointEntries };
+  }
+
+  if (pendingDeferred.length > 0) {
+    log('info', `Steering: delivering ${pendingDeferred.length} deferred message(s) for ${agentId} at resumable checkpoint`);
+  }
+  if (lateCheckpoint.length > 0) {
+    log('info', `Steering: delivering ${lateCheckpoint.length} late checkpoint message(s) for ${agentId} at resumable checkpoint`);
+  }
+  procInfo._steeringMessage = checkpointEntries.map(entry => entry.message.trim()).join('\n\n');
+  procInfo._steeringSessionId = procInfo.sessionId;
+  procInfo._steeringEntry = checkpointEntries;
+  procInfo._steeringDeferredCheckpoint = true;
+  delete procInfo._deferredSteeringFiles;
+  return { status: 'promoted', entries: checkpointEntries };
+}
+
 // Resolve dependency plan item IDs to their PR branches
 function resolveDependencyBranches(depIds, sourcePlan, project, config) {
   const results = []; // [{ branch, prId }]
@@ -1193,6 +1237,7 @@ async function spawnAgent(dispatchItem, config) {
   const MAX_OUTPUT = 1024 * 1024; // 1MB
   let stdout = '';
   let stderr = '';
+  let steeringAckStdout = '';
   const sessionCaptureState = { sessionLineBuffer: '' };
   let _trustCheckDone = false;
   const _spawnTime = Date.now();
@@ -1207,6 +1252,7 @@ async function spawnAgent(dispatchItem, config) {
     const chunk = data.toString();
     realActivityMap.set(id, Date.now());
     if (stdout.length < MAX_OUTPUT) stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
+    if (steeringAckStdout.length < MAX_OUTPUT) steeringAckStdout += chunk.slice(0, MAX_OUTPUT - steeringAckStdout.length);
     try { fs.appendFileSync(liveOutputPath, chunk); } catch { /* optional */ }
 
     // Trust gate detection: check first 30s of output for trust/permission prompts
@@ -1254,26 +1300,8 @@ async function spawnAgent(dispatchItem, config) {
     }
 
     const procInfo = activeProcesses.get(id);
-    ackPendingSteeringFiles(agentId, procInfo, stdout);
-
-    if (procInfo?._deferredSteeringFiles?.length && procInfo.sessionId) {
-      const deferredPaths = new Set(procInfo._deferredSteeringFiles);
-      const pendingDeferred = steering.listUnreadSteeringMessages(agentId)
-        .filter(entry => deferredPaths.has(entry.path) && entry.message.trim());
-      if (pendingDeferred.length > 0) {
-        log('info', `Steering: delivering ${pendingDeferred.length} deferred message(s) for ${agentId} at resumable checkpoint`);
-        procInfo._steeringMessage = pendingDeferred.map(entry => entry.message.trim()).join('\n\n');
-        procInfo._steeringSessionId = procInfo.sessionId;
-        procInfo._steeringEntry = pendingDeferred;
-        procInfo._steeringDeferredCheckpoint = true;
-        delete procInfo._deferredSteeringFiles;
-      } else {
-        delete procInfo._deferredSteeringFiles;
-      }
-    } else if (procInfo?._deferredSteeringFiles?.length) {
-      log('warn', `Steering: ${agentId} exited before a resumable sessionId was available — message remains pending`);
-      try { fs.appendFileSync(liveOutputPath, `\n[steering-pending] Agent exited before a resumable session was available. Your message remains unread and will be retried on the next dispatch.\n`); } catch {}
-    }
+    ackPendingSteeringFiles(agentId, procInfo, steeringAckStdout);
+    promoteCheckpointSteeringForClose(agentId, procInfo, runtime, liveOutputPath);
 
     // Check if this was a steering kill — re-spawn with resume
     if (procInfo?._steeringMessage) {
@@ -1401,6 +1429,7 @@ async function spawnAgent(dispatchItem, config) {
         ),
       });
 
+      steeringAckStdout = '';
       // Live steering kills discard partial old output. Deferred checkpoint
       // steering keeps the completed turn output so completion parsing still
       // sees the original work if the follow-up only acknowledges steering.
@@ -1414,6 +1443,7 @@ async function spawnAgent(dispatchItem, config) {
         const chunk = data.toString();
         realActivityMap.set(id, Date.now());
         if (stdout.length < MAX_OUTPUT) stdout += chunk.slice(0, MAX_OUTPUT - stdout.length);
+        if (steeringAckStdout.length < MAX_OUTPUT) steeringAckStdout += chunk.slice(0, MAX_OUTPUT - steeringAckStdout.length);
         try { fs.appendFileSync(liveOutputPath, chunk); } catch { /* optional */ }
         const resumeInfo = activeProcesses.get(id);
         markRuntimeResumeOutputSeen(resumeInfo);
@@ -4719,6 +4749,7 @@ module.exports = {
   parseConflictFiles, pruneAncestorDeps, preflightMergeSimulation, // exported for testing
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, // exported for testing
   _maxTurnsForType, buildProjectContext, normalizeAc, _buildAgentSpawnFlags, _classifyAgentFailure, // exported for testing
+  promoteCheckpointSteeringForClose, // exported for testing
   normalizePrBranch, resolvePrBranch, prCausePart, getPrCauseHead, getPrCauseBase, getPrAutomationCauseKey, getPrAutomationDispatchKey, // exported for testing
 
   // Playbooks

package/package.json

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