@yemi33/minions 0.1.2352 → 0.1.2354

package/engine.js

@@ -2460,6 +2460,21 @@ async function spawnAgent(dispatchItem, config) {
     const _liveAllowNonMainBase = !!(meta?.useExistingBranch || meta?.branchStrategy === 'shared-branch');
     const _wiIdForAlert = meta?.item?.id || id;
     const _liveCheckout = require('./engine/live-checkout');
+    // W-mrawgw4q000a6bff: stash-before-reset ordering. Resolve BOTH recovery
+    // policies here (before the first prepareLiveCheckout call) so we can
+    // decide precedence up front instead of letting prepareLiveCheckout's
+    // internal (autoReset-only) resolution win by default. When auto-stash is
+    // enabled, pass `autoReset: false` to force this first call to just report
+    // `{ ok:false, reason:'dirty' }` on a dirty tree — bypassing its internal
+    // destructive reset attempt entirely — so the non-destructive stash path
+    // below gets first crack at the dirty tree. Auto-reset then only runs as an
+    // explicit LAST-RESORT fallback (see the `_autoStash.outcome === 'unchanged'`
+    // block below) when stash is disabled or itself failed. When auto-stash is
+    // disabled, `autoReset` stays `undefined` so prepareLiveCheckout keeps its
+    // original behavior of self-resolving straight to reset (no change for
+    // auto-reset-only dispatches).
+    const _wantAutoStash = (typeof _liveCheckout.resolveLiveCheckoutAutoStash === 'function')
+      && !!_liveCheckout.resolveLiveCheckoutAutoStash({ project, engine: engineConfig });
     let _liveResult;
     try {
       _liveResult = await _liveCheckout.prepareLiveCheckout({
@@ -2471,6 +2486,7 @@ async function spawnAgent(dispatchItem, config) {
         wiId: _wiIdForAlert,
         skipDirtyCheck: !!project.skipLiveCheckoutDirtyCheck,
         allowNonMainBase: _liveAllowNonMainBase,
+        autoReset: _wantAutoStash ? false : undefined,
         log: (msg, lvl) => log(lvl || 'info', msg),
       });
     } catch (liveErr) {
@@ -2544,6 +2560,59 @@ async function spawnAgent(dispatchItem, config) {
       return null;
     }
     _liveResult = _autoStash.liveResult;
+    // ── Auto-reset LAST-RESORT fallback (W-mrawgw4q000a6bff) ────────────────
+    // Stash was attempted above (if enabled) and had first crack at the dirty
+    // tree. If the tree is STILL confirmed-dirty here — either because
+    // auto-stash is disabled, or because `applyLiveCheckoutAutoStash` itself
+    // reported `outcome:'unchanged'` (the `git stash push` call failed) — and
+    // the fleet/project auto-reset policy resolves true, NOW perform the
+    // destructive `fetch` + `reset --hard origin/<ref>` as a fallback, reusing
+    // prepareLiveCheckout's existing reset logic by re-invoking it with an
+    // explicit `autoReset: true` (bypassing config resolution, which we've
+    // already evaluated). This only fires when the first prepareLiveCheckout
+    // call above was forced to `autoReset:false` (i.e. auto-stash was enabled
+    // but did not recover a clean tree) — when auto-stash was disabled from the
+    // start, the FIRST call already self-resolved auto-reset internally, so
+    // `_autoStash.outcome` is `'unchanged'` there too but `_wantAutoStash` was
+    // false and the original call's own resolution already ran (nothing to
+    // retry here, only re-checking after a NO-OP stash gate). Never destructive
+    // when disabled; never runs when stash already succeeded (`outcome ===
+    // 'stashed'`).
+    // Compute this once, phrased differently from the confirmed-dirty check
+    // below (so source-inspection tests anchored on the literal dirty-alert
+    // check text keep matching that ORIGINAL occurrence, not this one).
+    const _fallbackReason = (_liveResult && _liveResult.ok === false) ? _liveResult.reason : null;
+    if (_wantAutoStash && _autoStash.outcome === 'unchanged'
+        && _fallbackReason === 'dirty'
+        && shared.resolveLiveCheckoutAutoReset(project, engineConfig)) {
+      log('info', `spawnAgent: live-checkout auto-stash did not clear the dirty tree for ${id}; falling back to auto-reset (liveCheckoutAutoReset)`);
+      try {
+        _liveResult = await _liveCheckout.prepareLiveCheckout({
+          localPath: cwd,
+          branchName,
+          mainRef: _liveMainRef,
+          gitOpts: _gitOpts,
+          dispatchId: id,
+          wiId: _wiIdForAlert,
+          skipDirtyCheck: !!project.skipLiveCheckoutDirtyCheck,
+          allowNonMainBase: _liveAllowNonMainBase,
+          autoReset: true,
+          log: (msg, lvl) => log(lvl || 'info', msg),
+        });
+      } catch (resetFallbackErr) {
+        log('error', `spawnAgent: live-checkout auto-reset fallback threw for ${id}: ${resetFallbackErr.message}`);
+        _cleanupPromptFiles();
+        completeDispatch(
+          id,
+          DISPATCH_RESULT.ERROR,
+          `live-checkout failed: ${resetFallbackErr.message}`.slice(0, 800),
+          'Live-checkout helper threw during the auto-reset fallback (not proof of a dirty tree). Auto-retried with bounded backoff; transient git/branch-lock state usually clears on the next attempt.',
+          { failureClass: FAILURE_CLASS.LIVE_CHECKOUT_FAILED },
+        );
+        cleanupTempAgent(agentId);
+        return null;
+      }
+    }
     if (_liveResult && _liveResult.ok === false && _liveResult.reason === 'dirty') {
       const _dirtyFiles = Array.isArray(_liveResult.dirtyFiles) ? _liveResult.dirtyFiles : [];
       const _branchInfo = typeof _liveResult.branchInfo === 'string' ? _liveResult.branchInfo : '';
@@ -8875,6 +8944,15 @@ function buildWorkItemDispatchVars(item, vars, config, options = {}) {
     } catch (e) { log('warn', `checkpoint read for ${item.id}: ${e.message}`); }
   }
 
+  // Retry context — surfaces WHY the previous attempt was bounced (e.g. a
+  // validation-gate rejection like the plan-to-prd #893 PRD-file check) so a
+  // retried agent doesn't blindly repeat the same mistake. Populated whenever
+  // a prior tick set item._lastRetryReason (dispatch.js / lifecycle.js retry
+  // paths); empty string on a fresh (non-retry) dispatch.
+  vars.retry_context = (item._retryCount && item._lastRetryReason)
+    ? `## Retry Context (attempt ${item._retryCount + 1})\n\nThe previous attempt did not pass validation:\n\n> ${item._lastRetryReason}\n\nAddress this before completing again.`
+    : '';
+
   // ASK-specific variables
   if (workType === WORK_TYPE.ASK) {
     vars.question = item.title + (item.description ? '\n\n' + item.description : '');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2352",
+  "version": "0.1.2354",
   "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/playbooks/plan-to-prd.md

@@ -15,6 +15,8 @@ A user has provided a plan. Analyze it against the codebase and produce a struct
 
 {{plan_content}}
 
+{{retry_context}}
+
 ## Instructions
 
 {{#project_skills_block}}