@yemi33/minions 0.1.1650 → 0.1.1652

package/CHANGELOG.md

@@ -1,13 +1,21 @@
 # Changelog
 
-## 0.1.1650 (2026-05-01)
+## 0.1.1652 (2026-05-01)
+
+### Other
+- Harden agent steering reliability
+
+## 0.1.1651 (2026-05-01)
+
+### Other
+- refactor: delegate orchestration policy
+
+## 0.1.1649 (2026-05-01)
 
 ### Features
-- reject premature task_complete for nonterminal summaries
 - ADO build poll repositoryId GUID handling
 
 ### Fixes
-- yemi33/minions#1927
 - yemi33/minions#1925
 
 ## 0.1.1648 (2026-05-01)

package/dashboard/js/live-stream.js

@@ -136,12 +136,14 @@ async function sendSteering() {
           try {
             const liveRes = await fetch('/api/agent/' + encodeURIComponent(currentAgentId) + '/live-output');
             const text = await liveRes.text();
-            // Check if there's new output after the [human-steering] line
+            // Check if there's runtime output after the [human-steering] line.
+            // Claude emits "assistant"; Copilot emits "assistant.message_delta"
+            // / "assistant.message", and either one proves the resume turn ran.
             const steerIdx = text.lastIndexOf('[human-steering]');
             if (steerIdx >= 0) {
-              const afterSteer = text.slice(steerIdx + 100);
-              // Look for assistant response (JSON with type:assistant or readable text)
-              if (afterSteer.length > 200 && (afterSteer.includes('"type":"assistant"') || afterSteer.includes('"type":"text"'))) {
+              const afterSteer = text.slice(steerIdx + '[human-steering]'.length);
+              const sawRuntimeOutput = /"type"\s*:\s*"(assistant(?:\.|")|tool\.|session\.task_complete"|result")/.test(afterSteer);
+              if (afterSteer.length > 20 && sawRuntimeOutput) {
                 clearInterval(ackInterval);
                 pending.textContent = '\u2713 Agent acknowledged';
                 pending.style.color = 'var(--green)';

package/engine/ado.js

@@ -372,6 +372,7 @@ async function forEachActivePr(config, token, callback) {
     }
 
     let projectUpdated = 0;
+    const updatedRecords = [];
     const orgBase = getAdoOrgBase(project);
 
     // Parallelize PR polling within each project (max 5 concurrent to avoid rate limits)
@@ -381,31 +382,36 @@ async function forEachActivePr(config, token, callback) {
       const results = await Promise.allSettled(batch.map(async (pr) => {
         const prNum = shared.getPrNumber(pr);
         if (!prNum) return false;
-        return callback(project, pr, prNum, orgBase, adoRepositoryId);
+        const before = shared.snapshotPrRecord(pr);
+        const updated = await callback(project, pr, prNum, orgBase, adoRepositoryId);
+        if (updated) return { before, after: shared.snapshotPrRecord(pr) };
+        return false;
       }));
       for (const r of results) {
-        if (r.status === 'fulfilled' && r.value) projectUpdated++;
+        if (r.status === 'fulfilled' && r.value) {
+          projectUpdated++;
+          updatedRecords.push(r.value);
+        }
         if (r.status === 'rejected') log('warn', `PR poll error: ${r.reason?.message || r.reason}`);
       }
     }
 
     if (projectUpdated > 0) {
       mutateJsonFileLocked(shared.projectPrPath(project), (currentPrs) => {
-        // Merge back updated PRs — preserve disk values that may have been changed
-        // by other writers between poll start and this write
-        for (const updatedPr of activePrs) {
-          const updatedPrNumber = shared.getPrNumber(updatedPr);
+        // Merge back only fields changed by callbacks; preserve concurrent disk updates.
+        for (const { before, after } of updatedRecords) {
+          const updatedPrNumber = shared.getPrNumber(after);
           const idx = currentPrs.findIndex(p =>
-            p.id === updatedPr.id
+            p.id === after.id
             || (updatedPrNumber != null && shared.getPrNumber(p) === updatedPrNumber)
           );
           if (idx >= 0) {
             // Never downgrade reviewStatus from 'approved' — it's a permanent terminal state
             // The disk version may have been set to 'approved' by another writer after we read
-            if (currentPrs[idx].reviewStatus === 'approved' && updatedPr.reviewStatus !== 'approved') {
-              updatedPr.reviewStatus = 'approved';
+            if (currentPrs[idx].reviewStatus === 'approved' && after.reviewStatus !== 'approved') {
+              after.reviewStatus = 'approved';
             }
-            currentPrs[idx] = updatedPr;
+            shared.applyPrFieldDelta(currentPrs[idx], before, after);
           }
           // Don't push if not found — it was deleted by another writer, respect that
         }
@@ -579,7 +585,6 @@ async function pollPrStatus(config) {
     const mergeCommitId = prData.lastMergeCommit?.commitId;
     let buildStatus = pr.buildStatus || 'none';
     let buildFailReason = pr.buildFailReason || '';
-    let buildStatuses = []; // for error log fetching
     let buildStatusResolved = true;
     let buildStatusStaleDetail = '';
 
@@ -603,11 +608,6 @@ async function pollPrStatus(config) {
             if (buildStatus === 'failing') {
               const failed = prBuilds.find(b => b.result === 'failed');
               buildFailReason = failed?.definition?.name || 'Build failed';
-              // Build fake status objects for error log fetching
-              buildStatuses = prBuilds.filter(b => b.result === 'failed').map(b => ({
-                state: 'failed', targetUrl: `${orgBase}/${project.adoProject}/_build/results?buildId=${b.id}`,
-                _buildId: String(b.id),
-              }));
             }
           } else if (allBuilds.length > 0 && pr.buildStatus) {
             // Stale merge-commit fallback — ADO returned builds for this PR's merge ref
@@ -674,20 +674,7 @@ async function pollPrStatus(config) {
         }
         updated = true;
 
-        // Fetch actual compiler/build error logs when transitioning to failing
         if (buildStatus === 'failing') {
-          const failedStatusObjs = buildStatuses.filter(s => s.state === 'failed' || s.state === 'error').slice(0, 10);
-          const logParts = [];
-          const seenBuildIds = new Set();
-          for (const failedStatusObj of failedStatusObjs) {
-            const errorLog = await fetchAdoBuildErrorLog(orgBase, project, failedStatusObj, token, pr, seenBuildIds);
-            if (errorLog) logParts.push(errorLog);
-          }
-          if (logParts.length > 0) {
-            pr.buildErrorLog = logParts.join('\n\n');
-            log('info', `PR ${pr.id}: fetched error logs from ${logParts.length} failing pipeline(s)`);
-          }
-
           // Teams notification for build failure — non-blocking
           try {
             const teams = require('./teams');
@@ -810,7 +797,7 @@ async function pollPrHumanComments(config) {
     const allNewDates = allHumanComments.filter(c => (new Date(c.date).getTime() || 0) > cutoffMs).map(c => c.date);
     if (allNewDates.length > 0 && newHumanComments.length === 0) {
       pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: allNewDates.sort().pop() };
-      return false;
+      return true;
     }
     if (newHumanComments.length === 0) return false;
 

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-01T01:28:04.266Z"
+  "cachedAt": "2026-05-01T02:33:34.697Z"
 }

package/engine/dispatch.js

@@ -20,8 +20,6 @@ const MINIONS_DIR = shared.MINIONS_DIR;
 // Lazy require to break circular dependency with engine.js
 let _lifecycle = null;
 function lifecycle() { if (!_lifecycle) _lifecycle = require('./lifecycle'); return _lifecycle; }
-let _recovery = null;
-function recovery() { if (!_recovery) _recovery = require('./recovery'); return _recovery; }
 
 // ─── Dispatch Mutation ───────────────────────────────────────────────────────
 
@@ -184,6 +182,16 @@ function isRetryableFailureReason(reason = '', failureClass = '') {
   return !nonRetryable.some(s => r.includes(s));
 }
 
+function normalizeRetryableDecision(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (['true', 'yes', '1'].includes(normalized)) return true;
+    if (['false', 'no', '0'].includes(normalized)) return false;
+  }
+  return undefined;
+}
+
 function isCompletedWorkItemForFailure(item) {
   return !!item && (
     item.status === WI_STATUS.DONE ||
@@ -234,6 +242,7 @@ function writeFailedAgentReport(item, reason, resultSummary, failureClass) {
 
 function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', resultSummary = '', opts = {}) {
   const { processWorkItemFailure = true, failureClass } = opts;
+  const agentRetryable = normalizeRetryableDecision(opts.agentRetryable ?? opts.retryable);
   let item = null;
 
   mutateDispatch((dispatch) => {
@@ -273,7 +282,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
     }
 
     // Update source work item status on failure + auto-retry with backoff
-    const retryableFailure = isRetryableFailureReason(reason, failureClass);
+    const retryableFailure = agentRetryable !== undefined ? agentRetryable : isRetryableFailureReason(reason, failureClass);
     let completedWorkItemFailure = false;
     if (processWorkItemFailure && result === DISPATCH_RESULT.ERROR && item.meta?.item?.id) {
       // If the live item cannot be resolved, keep the existing retry path.
@@ -295,9 +304,8 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
           if (wi) retries = wi._retryCount || 0;
         } catch (e) { log('warn', 'read retry count: ' + e.message); }
         const maxRetries = ENGINE_DEFAULTS.maxRetries;
-        // Use per-class retry limits from recovery.js when failureClass is available
-        const classAllowsRetry = failureClass ? recovery().shouldRetry(failureClass, retries) : (retries < maxRetries);
-        if (retryableFailure && classAllowsRetry) {
+        const withinSafetyCap = retries < maxRetries;
+        if (retryableFailure && withinSafetyCap) {
           log('info', `Dispatch error for ${item.meta.item.id} — auto-retry ${retries + 1}/${maxRetries}${failureClass ? ' [' + failureClass + ']' : ''}`);
           lifecycle().updateWorkItemStatus(item.meta, WI_STATUS.PENDING, '');
           // Remove this dispatch key from completed so dedupe doesn't block immediate redispatch.

package/engine/github.js

@@ -219,14 +219,19 @@ async function forEachActiveGhPr(config, callback) {
     resetSlugBackoff(slug);
 
     let projectUpdated = 0;
+    const updatedRecords = [];
 
     for (const pr of activePrs) {
       const prNum = shared.getPrNumber(pr);
       if (!prNum) continue;
 
       try {
+        const before = shared.snapshotPrRecord(pr);
         const updated = await callback(project, pr, prNum, slug);
-        if (updated) projectUpdated++;
+        if (updated) {
+          projectUpdated++;
+          updatedRecords.push({ before, after: shared.snapshotPrRecord(pr) });
+        }
       } catch (err) {
         log('warn', `GitHub: failed to poll PR ${pr.id}: ${err.message}`);
       }
@@ -234,15 +239,15 @@ async function forEachActiveGhPr(config, callback) {
 
     if (projectUpdated > 0) {
       mutateJsonFileLocked(projectPrPath(project), (currentPrs) => {
-        // Merge back updated PRs and deduplicate
-        for (const updatedPr of activePrs) {
-          const idx = currentPrs.findIndex(p => p.id === updatedPr.id);
+        // Merge back only fields changed by callbacks; preserve concurrent disk updates.
+        for (const { before, after } of updatedRecords) {
+          const idx = currentPrs.findIndex(p => p.id === after.id);
           if (idx >= 0) {
             // Never downgrade reviewStatus from 'approved' — it's a permanent terminal state
-            if (currentPrs[idx].reviewStatus === 'approved' && updatedPr.reviewStatus !== 'approved') {
-              updatedPr.reviewStatus = 'approved';
+            if (currentPrs[idx].reviewStatus === 'approved' && after.reviewStatus !== 'approved') {
+              after.reviewStatus = 'approved';
             }
-            currentPrs[idx] = updatedPr;
+            shared.applyPrFieldDelta(currentPrs[idx], before, after);
           }
         }
         // Remove duplicates — prefer merged/abandoned over active
@@ -265,6 +270,7 @@ async function forEachActiveGhPr(config, callback) {
   const centralPrs = safeJson(centralPath) || [];
   const activeCentral = centralPrs.filter(pr => PR_POLLABLE_STATUSES.has(pr.status) && pr.url);
   let centralUpdated = 0;
+  const updatedCentralRecords = [];
   for (const pr of activeCentral) {
     const ghMatch = pr.url.match(/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
     if (!ghMatch) continue;
@@ -272,14 +278,17 @@ async function forEachActiveGhPr(config, callback) {
     if (isSlugInBackoff(slug)) continue;
     const prNum = ghMatch[2];
     try {
+      const before = shared.snapshotPrRecord(pr);
       const updated = await callback(null, pr, prNum, slug);
       if (updated) {
         // Also update title/author/branch if still placeholder
-        if (pr.title.includes('polling...') || pr.agent === 'human' || pr.description === undefined) {
+        const currentTitle = pr.title || '';
+        if (!currentTitle || currentTitle.includes('polling...') || pr.agent === 'human' || pr.description === undefined) {
           const prData = await ghApi(`/pulls/${prNum}`, slug);
           if (prData) {
-            if (pr.title.includes('polling...') || /[{}"\[\]]/.test(pr.title) || /^[0-9a-f-]{8,}$/i.test(pr.title)) {
-              pr.title = (prData.title || pr.title).slice(0, 120);
+            const latestTitle = pr.title || '';
+            if (!latestTitle || latestTitle.includes('polling...') || /[{}"\[\]]/.test(latestTitle) || /^[0-9a-f-]{8,}$/i.test(latestTitle)) {
+              pr.title = (prData.title || latestTitle).slice(0, 120);
             }
             if (pr.description === undefined) pr.description = (prData.body || '').slice(0, 500);
             if (pr.agent === 'human' && prData.user?.login) pr.agent = prData.user.login;
@@ -291,6 +300,7 @@ async function forEachActiveGhPr(config, callback) {
           }
         }
         centralUpdated++;
+        updatedCentralRecords.push({ before, after: shared.snapshotPrRecord(pr) });
       }
     } catch (err) {
       log('warn', `GitHub: failed to poll central PR ${pr.id}: ${err.message}`);
@@ -299,9 +309,9 @@ async function forEachActiveGhPr(config, callback) {
   if (centralUpdated > 0) {
     mutateJsonFileLocked(centralPath, (currentPrs) => {
       // Only merge back central PRs that the callback actually modified
-      for (const updatedPr of activeCentral) {
-        const idx = currentPrs.findIndex(p => p.id === updatedPr.id);
-        if (idx >= 0) currentPrs[idx] = updatedPr;
+      for (const { before, after } of updatedCentralRecords) {
+        const idx = currentPrs.findIndex(p => p.id === after.id);
+        if (idx >= 0) shared.applyPrFieldDelta(currentPrs[idx], before, after);
       }
       return currentPrs;
     }, { defaultValue: [] });
@@ -487,15 +497,7 @@ async function pollPrStatus(config) {
           }
           updated = true;
 
-          // Fetch actual compiler/build error logs when transitioning to failing
           if (buildStatus === 'failing') {
-            const failedRuns = runs.filter(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
-            const errorLog = await fetchGhBuildErrorLog(slug, failedRuns);
-            if (errorLog) {
-              pr.buildErrorLog = errorLog;
-              log('info', `PR ${pr.id}: fetched ${errorLog.split('\n').length} lines of build error log`);
-            }
-
             // Teams notification for build failure — non-blocking
             try {
               const teams = require('./teams');
@@ -611,7 +613,7 @@ async function pollPrHumanComments(config) {
     const allNewDates = allCommentEntries.filter(c => (new Date(c.date).getTime() || 0) > cutoffMs).map(c => c.date);
     if (allNewDates.length > 0 && newComments.length === 0) {
       pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: allNewDates.sort().pop() };
-      return false; // agent comments only — don't trigger fix
+      return true; // agent comments only — persist cutoff without triggering fix
     }
     if (newComments.length === 0) return false;