@yemi33/minions 0.1.2298 → 0.1.2300

package/dashboard.js

@@ -11444,25 +11444,19 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
   // W-mq03l6zh0006f0a1-d — read-only diagnostics surface for the per-org ADO
   // throttle tracker. Returns { orgs: { [orgBase]: { throttled, retryAfter,
-  // consecutiveHits } } }. Prefers the per-org getter ado.getAdoThrottleStateAll
-  // when present (introduced by W-mq03l6zh0006f0a1-b). Falls back to the
-  // process-global ado.getAdoThrottleState() under the synthetic key `global`
-  // when the per-org getter is not present, so the endpoint stays live across
-  // the staged rollout of the per-org isolation work.
+  // consecutiveHits } } }. Uses getAdoThrottleState().perOrg, the per-org map
+  // exposed by the aggregate getter (W-mq03l6zh0006f0a1-b).
   async function handleDiagnosticsAdoThrottle(req, res) {
     try {
       let orgs = {};
-      if (typeof ado.getAdoThrottleStateAll === 'function') {
-        const all = ado.getAdoThrottleStateAll() || {};
+      if (typeof ado.getAdoThrottleState === 'function') {
+        const all = ado.getAdoThrottleState().perOrg || {};
         // Defensive copy — handler must never expose internal mutable state.
         for (const [k, v] of Object.entries(all)) {
           if (v && typeof v === 'object') {
             orgs[k] = { throttled: !!v.throttled, retryAfter: Number(v.retryAfter) || 0, consecutiveHits: Number(v.consecutiveHits) || 0 };
           }
         }
-      } else if (typeof ado.getAdoThrottleState === 'function') {
-        const v = ado.getAdoThrottleState() || {};
-        orgs.global = { throttled: !!v.throttled, retryAfter: Number(v.retryAfter) || 0, consecutiveHits: Number(v.consecutiveHits) || 0 };
       }
       return jsonReply(res, 200, { orgs });
     } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }

package/engine/ado.js

@@ -2683,14 +2683,6 @@ const getAdoThrottleState = (orgBase) => {
   return { throttled, retryAfter, consecutiveHits, perOrg };
 };
 
-/** Returns the per-org tracker state map keyed by canonical orgBase. */
-const getAdoThrottleStateAll = () => {
-  const out = {};
-  for (const [key, tracker] of _adoThrottlesByOrg) {
-    out[key] = tracker.getState();
-  }
-  return out;
-};
 
 /**
  * Query ADO for an open PR on a specific branch.
@@ -2955,7 +2947,6 @@ module.exports = {
   _setAdoTokenAuthNoteWriterForTest, // exported for testing
   isAdoThrottled,
   getAdoThrottleState,
-  getAdoThrottleStateAll,
   fetchAdoPrMetadata,
   prExists, // issue #246 — confirm a loose ref points at a PR (not a work item) before stamping
   fetchSinglePrBuildStatus,

package/engine/dispatch.js

@@ -577,7 +577,7 @@ function isRetryableFailureReason(reason = '', failureClass = '') {
       FAILURE_CLASS.INVALID_MANAGED_SPAWN, // W-mpbhxg3b000u8411 — managed-spawn.json failed validation; re-running with the same wrong file won't fix it
       FAILURE_CLASS.MANAGED_SPAWN_HEALTHCHECK_FAILED, // W-mpbhxg3b000u8411 — healthcheck timed out; agent must fix the spec or the service it spawned
       FAILURE_CLASS.INJECTION_FLAGGED, // F5 (W-mpeklod3000we69c) — agent spotted a prompt-injection attempt in spliced untrusted content; a human must review the source before re-dispatch
-      FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, // P-a3f9b204 — live-checkout refused to spawn because operator localPath is dirty; mechanical retry won't fix it (operator must commit/stash/discard)
+      FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, // P-a3f9b204 — live-checkout refused to spawn because operator localPath is dirty; mechanical retry won't fix it (operator must commit/stash/discard). NOTE (W-mqzmkoqt000hbca2): engine.js#spawnAgent ALWAYS passes an explicit `agentRetryable` for this class, so this Set entry is never the actual gate — when auto-cleanup (liveCheckoutAutoReset/AutoStash) is enabled the engine overrides to retryable. Kept as a defensive safety net for any caller that omits the explicit override.
       FAILURE_CLASS.LIVE_CHECKOUT_MID_OPERATION, // P-a7f3c1d9 — live-checkout refused to spawn because the operator tree is mid-operation (in-progress merge/rebase/cherry-pick/bisect or detached HEAD); mechanical retry won't fix it (operator must finish/abort the op or checkout a branch)
       FAILURE_CLASS.LIVE_CHECKOUT_BLOB_FETCH, // PL-live-checkout-reliability-hardening — live-checkout `git checkout <existing-branch>` failed hydrating the tree through the auth-less GVFS cache server (blobless partial clone, headless); deterministic, so mechanical retry just reproduces it (operator must hydrate the branch with their own creds, then re-dispatch)
       FAILURE_CLASS.OUTPUT_TRUNCATED, // P-8e4c2a17 — agent stdout exceeded the hard capture cap before the terminal result event; mechanical retry just reproduces the overflow (agent must reduce output volume or the task must be split)

package/engine/lifecycle.js

@@ -3607,24 +3607,25 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config, runtimeN
 function updateAgentHistory(agentId, dispatchItem, result) {
 
   const historyPath = path.join(AGENTS_DIR, agentId, 'history.md');
-  let history = safeRead(historyPath) || '# Agent History\n\n';
   const entry = `### ${ts()} — ${result}\n` +
     `- **Task:** ${dispatchItem.task}\n` +
     `- **Type:** ${dispatchItem.type}\n` +
     `- **Project:** ${dispatchItem.meta?.project?.name || 'central'}\n` +
     `- **Branch:** ${dispatchItem.meta?.branch || 'none'}\n` +
     `- **Dispatch ID:** ${dispatchItem.id}\n\n`;
-  const headerEnd = history.indexOf('\n\n');
-  if (headerEnd >= 0) {
-    history = history.slice(0, headerEnd + 2) + entry + history.slice(headerEnd + 2);
-  } else {
-    history += entry;
-  }
-  const entries = history.split('### ').filter(Boolean);
-  const header = entries[0].startsWith('#') ? entries.shift() : '# Agent History\n\n';
-  const trimmed = entries.slice(0, 20);
-  history = header + trimmed.map(e => '### ' + e).join('');
-  shared.safeWrite(historyPath, history);
+  shared.mutateTextFileLocked(historyPath, (history) => {
+    history = history || '# Agent History\n\n';
+    const headerEnd = history.indexOf('\n\n');
+    if (headerEnd >= 0) {
+      history = history.slice(0, headerEnd + 2) + entry + history.slice(headerEnd + 2);
+    } else {
+      history += entry;
+    }
+    const entries = history.split('### ').filter(Boolean);
+    const header = entries[0].startsWith('#') ? entries.shift() : '# Agent History\n\n';
+    const trimmed = entries.slice(0, 20);
+    return header + trimmed.map(e => '### ' + e).join('');
+  }, { defaultValue: '# Agent History\n\n' });
   log('info', `Updated history for ${agentId}`);
 }
 

package/engine.js

@@ -2437,8 +2437,21 @@ async function spawnAgent(dispatchItem, config) {
       // burned all maxRetries. The dedicated counter is touched ONLY here (on a
       // dirty failure) and cleared on a successful prepareLiveCheckout below;
       // neither discovery nor the retry re-queue clears it.
+      //
+      // W-mqzmkoqt000hbca2 — AUTO-CLEANUP EXCEPTION: the two-strike cap assumes
+      // the dirty tree is operator-owned and only a human can clear it. But when
+      // `liveCheckoutAutoReset` or `liveCheckoutAutoStash` is configured (per-project
+      // or fleet-wide), the engine itself re-cleans the tree on every dispatch
+      // attempt, so a recurring dirty failure (e.g. a transiently failing
+      // auto-reset/stash) is NOT operator-owned. In that case we skip the
+      // two-strike cap and stay retryable — the next attempt re-runs auto-cleanup.
+      // The normal `maxRetries` cap in dispatch.js still bounds the retries.
       const _priorDirtyAttempts = Number(dispatchItem.meta?.item?._liveCheckoutDirtyAttempts) || 0;
       const _alreadyDirtyFailed = _priorDirtyAttempts >= 1;
+      const _autoCleanupEnabled =
+        shared.resolveLiveCheckoutAutoReset(project, engineConfig) ||
+        (typeof _liveCheckout.resolveLiveCheckoutAutoStash === 'function' &&
+          !!_liveCheckout.resolveLiveCheckoutAutoStash({ project, engine: engineConfig }));
       const _alertBody = [
         '# Live-checkout refused: dirty worktree',
         '',
@@ -2457,9 +2470,11 @@ async function spawnAgent(dispatchItem, config) {
         ...(_dirtyFiles.length > 0 ? _dirtyFiles : ['(none reported)']),
         '```',
         '',
-        _alreadyDirtyFailed
-          ? 'Recovery: dirty state persisted across retries — commit, stash, or discard the changes in the project checkout, then re-dispatch the work item.'
-          : 'This dispatch will be retried once automatically in case the dirty state is transient. If dirty again on retry, commit, stash, or discard the changes, then re-dispatch.',
+        _autoCleanupEnabled
+          ? 'Auto-cleanup (`liveCheckoutAutoReset`/`liveCheckoutAutoStash`) is active — the engine re-cleans the tree on each attempt, so this dispatch will be retried automatically (subject to the normal retry cap).'
+          : (_alreadyDirtyFailed
+            ? 'Recovery: dirty state persisted across retries — commit, stash, or discard the changes in the project checkout, then re-dispatch the work item.'
+            : 'This dispatch will be retried once automatically in case the dirty state is transient. If dirty again on retry, commit, stash, or discard the changes, then re-dispatch.'),
       ].join('\n');
       try { writeInboxAlert(`live-checkout-dirty-${_wiIdForAlert}`, _alertBody); }
       catch (e) { log('warn', `live-checkout: writeInboxAlert failed: ${e.message}`); }
@@ -2487,10 +2502,12 @@ async function spawnAgent(dispatchItem, config) {
         id,
         DISPATCH_RESULT.ERROR,
         _dirtyMsg.slice(0, 800),
-        _alreadyDirtyFailed
-          ? 'Live-checkout dirty state persisted across retries — operator must commit/stash/discard before re-dispatch.'
-          : 'Live-checkout dirty tree retried once automatically; if dirty persists, operator must commit/stash/discard.',
-        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, agentRetryable: !_alreadyDirtyFailed },
+        _autoCleanupEnabled
+          ? 'Live-checkout dirty tree with auto-cleanup active — will retry (engine re-cleans each attempt; normal retry cap applies).'
+          : (_alreadyDirtyFailed
+            ? 'Live-checkout dirty state persisted across retries — operator must commit/stash/discard before re-dispatch.'
+            : 'Live-checkout dirty tree retried once automatically; if dirty persists, operator must commit/stash/discard.'),
+        { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, agentRetryable: _autoCleanupEnabled || !_alreadyDirtyFailed },
       );
       cleanupTempAgent(agentId);
       return null;
@@ -5661,7 +5678,7 @@ function reconcileItemsWithPrs(items, allPrs, { onlyIds } = {}) {
 // ─── Inbox Consolidation (extracted to engine/consolidation.js) ──────────────
 
 const { consolidateInbox } = require('./engine/consolidation');
-const { pollPrStatus, pollPrHumanComments, reconcilePrs, checkLiveReviewStatus: adoCheckLiveReview, checkLiveBuildAndConflict: adoCheckLiveBuildAndConflict, needsAdoPollRetry, getAdoToken, isAdoThrottled, getAdoThrottleStateAll } = require('./engine/ado');
+const { pollPrStatus, pollPrHumanComments, reconcilePrs, checkLiveReviewStatus: adoCheckLiveReview, checkLiveBuildAndConflict: adoCheckLiveBuildAndConflict, needsAdoPollRetry, getAdoToken, isAdoThrottled, getAdoThrottleState } = require('./engine/ado');
 const { pollPrStatus: ghPollPrStatus, pollPrHumanComments: ghPollPrHumanComments, reconcilePrs: ghReconcilePrs, checkLiveReviewStatus: ghCheckLiveReview, checkLiveBuildAndConflict: ghCheckLiveBuildAndConflict, isGhThrottled } = require('./engine/github');
 const { reconcileSharedBranchPrs } = require('./engine/shared-branch-pr-reconcile');
 
@@ -9770,7 +9787,7 @@ async function tickInner() {
       // Per-org throttle skip happens inside forEachActivePr (one log line per skipped project).
       // Top-level short-circuit: when every known ADO org is throttled, skip the whole phase
       // with one log line to avoid the per-project iteration cost.
-      const adoThrottleStates = getAdoThrottleStateAll() || {};
+      const adoThrottleStates = getAdoThrottleState().perOrg || {};
       const adoOrgCount = Object.keys(adoThrottleStates).length;
       const allAdoThrottled = adoOrgCount > 0 && Object.values(adoThrottleStates).every(s => s && s.throttled);
       if (allAdoThrottled) {
@@ -9850,7 +9867,7 @@ async function tickInner() {
       // Per-org throttle skip happens inside forEachActivePr (one log line per skipped project).
       // Top-level short-circuit: when every known ADO org is throttled, skip the whole phase
       // with one log line to avoid the per-project iteration cost.
-      const adoThrottleStates = getAdoThrottleStateAll() || {};
+      const adoThrottleStates = getAdoThrottleState().perOrg || {};
       const adoOrgCount = Object.keys(adoThrottleStates).length;
       const allAdoThrottled = adoOrgCount > 0 && Object.values(adoThrottleStates).every(s => s && s.throttled);
       if (allAdoThrottled) {

package/package.json

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