@yemi33/minions 0.1.2353 → 0.1.2355

package/engine/live-checkout.js

@@ -1485,7 +1485,10 @@ async function restoreLiveCheckoutAtDispatchEnd(opts = {}) {
  * and the per-agent cli/model override pattern):
  *   1. If `project.liveCheckoutAutoStash` is an explicit boolean, use it.
  *   2. Else if `engine.liveCheckoutAutoStash` is an explicit boolean, use it.
- *   3. Else default false.
+ *   3. Else fall back to `shared.ENGINE_DEFAULTS.liveCheckoutAutoStash`
+ *      (default true as of W-mrawiym8000c42c9 — non-destructive, recoverable
+ *      via `git stash pop`, and now the first line of defense in the
+ *      dirty-tree recovery flow now that `liveCheckoutAutoReset` defaults off).
  *
  * Pure — no I/O. Tested in test/unit/live-checkout-auto-stash.test.js.
  *
@@ -1500,7 +1503,7 @@ function resolveLiveCheckoutAutoStash(opts = {}) {
   if (engine && typeof engine.liveCheckoutAutoStash === 'boolean') {
     return engine.liveCheckoutAutoStash;
   }
-  return false;
+  return shared.ENGINE_DEFAULTS.liveCheckoutAutoStash;
 }
 
 /**
@@ -1570,11 +1573,29 @@ async function performLiveCheckoutAutoStash(opts = {}) {
  *
  * Returns a discriminated outcome the caller acts on:
  *   - `{ outcome:'unchanged', liveResult }` — not dirty, disabled, or stash failed
- *     (caller falls through to the existing retry-once-then-fail dirty handling).
+ *     (caller falls through to the existing retry-once-then-fail dirty handling,
+ *     or — W-mrawgw4q000a6bff — to an explicit `liveCheckoutAutoReset` fallback
+ *     when that policy also resolves true; see engine.js spawnAgent).
  *   - `{ outcome:'stashed', liveResult }`   — stashed + re-preflighted; proceed.
  *   - `{ outcome:'threw', error }`           — the re-preflight threw; caller must
  *     fail the dispatch as LIVE_CHECKOUT_FAILED (engine-specific completion).
  *
+ * W-mrawgw4q000a6bff — stash-before-reset ordering + no auto-sync-to-origin.
+ * The re-preflight (step 2) is called with `autoReset:false` so a still-dirty
+ * tree after a successful stash NEVER silently falls through to a destructive
+ * reset here — reset is only ever triggered explicitly by the caller as a
+ * documented last-resort fallback. Also, by design, this function does NOT
+ * follow up a successful stash with a `git merge --ff-only origin/<mainRef>`
+ * to re-sync the branch: `liveCheckoutAutoStash`'s contract (see
+ * `resolveLiveCheckoutAutoStash` above) has only ever been "park the dirty
+ * changes so dispatch can proceed", never "keep the branch in sync with
+ * origin" — that stronger guarantee is what `liveCheckoutAutoReset` is for,
+ * and it is still available as an explicit opt-in for dispatches that need it
+ * (with stash getting first crack at the tree, non-destructively, per the new
+ * ordering). Adding an implicit ff-only sync here would blur that line and
+ * risk a "successful" stash silently leaving a merge commit or a still-dirty
+ * tree if the ff fails — so it was deliberately left out.
+ *
  * @param {object} opts
  * @returns {Promise<{outcome:'unchanged'|'stashed'|'threw', liveResult?:object, error?:Error}>}
  */
@@ -1583,6 +1604,7 @@ async function applyLiveCheckoutAutoStash(opts = {}) {
     liveResult, project, engine, localPath, branchName, mainRef,
     gitOpts, dispatchId, wiId, log,
     clearDirtyStamp, writeStashNote,
+    _git, // private injection for testing — forwarded to performLiveCheckoutAutoStash + the re-preflight prepareLiveCheckout call
   } = opts;
   const logFn = (typeof log === 'function') ? log : () => {};
   const reason = (liveResult && liveResult.ok === false) ? liveResult.reason : null;
@@ -1591,7 +1613,7 @@ async function applyLiveCheckoutAutoStash(opts = {}) {
   }
   let stashResult;
   try {
-    stashResult = await performLiveCheckoutAutoStash({ localPath, dispatchId, gitOpts, log });
+    stashResult = await performLiveCheckoutAutoStash({ localPath, dispatchId, gitOpts, log, _git });
   } catch (stashErr) {
     stashResult = { ok: false, error: stashErr && stashErr.message };
   }
@@ -1601,7 +1623,10 @@ async function applyLiveCheckoutAutoStash(opts = {}) {
   }
   let newLive;
   try {
-    newLive = await prepareLiveCheckout({ localPath, branchName, mainRef, gitOpts, dispatchId, wiId, log });
+    // autoReset:false — see the function doc above; a still-dirty tree after a
+    // successful stash must never silently fall through to a destructive reset
+    // inside this re-preflight.
+    newLive = await prepareLiveCheckout({ localPath, branchName, mainRef, gitOpts, dispatchId, wiId, log, autoReset: false, _git });
   } catch (stashLiveErr) {
     return { outcome: 'threw', error: stashLiveErr };
   }

package/engine/playbook.js

@@ -307,6 +307,7 @@ const PLAYBOOK_OPTIONAL_VARS = new Set([
   'references',           // only set when item.references has entries
   'acceptance_criteria',  // only set when item.acceptanceCriteria has entries
   'checkpoint_context',   // only set when resuming from a prior timeout
+  'retry_context',      // only set when retrying after a validation-gate failure (#893)
   // Host-specific identifiers — always one of {ado_*, github_*} is empty
   // (project is either ADO or GitHub, never both). Keeping them as warns
   // produces ~96 noise lines per day on a single-host project.

package/engine/pr-action.js

@@ -85,16 +85,20 @@ const PR_ACTION_FOLLOWUPS = Object.freeze([
   { kind: 'track-auto-fix', label: 'Track for auto-fix' },
 ]);
 
-/** Canonical `host:slug#number` id for a record/ref, or '' when unknowable. */
+/**
+ * Canonical `host:slug#number` id for a record/ref, or '' when unknowable.
+ *
+ * Thin wrapper over prResolve.prIdFromRef: normalizes the heterogeneous
+ * record shapes buildPrActionFollowups is called with — an explicit
+ * `record.prId`, a `record.ref` ref object, or a bare ref-shaped object
+ * (`{host, slug, number}`/`{id}`) — into the ref shape prIdFromRef expects,
+ * then delegates so the `host:slug#number` template literal has one owner.
+ */
 function _prIdForRecord(record) {
   if (!record) return '';
   if (record.prId) return record.prId;
   const ref = record.ref || record;
-  if (ref && ref.id) return ref.id;
-  if (ref && ref.host && ref.slug && (ref.number || ref.number === 0)) {
-    return `${ref.host}:${ref.slug}#${ref.number}`;
-  }
-  return '';
+  return prResolve.prIdFromRef(ref) || '';
 }
 
 /**
@@ -364,7 +368,8 @@ function buildPrActionPrompt(action, payload) {
     number: payload && payload.number,
     id: payload && payload.prId,
   };
-  const prId = ref.id || (ref.host && ref.slug && ref.number ? `${ref.host}:${ref.slug}#${ref.number}` : (payload && payload.slug ? `${payload.slug}#${payload.number}` : 'the pull request'));
+  const prId = prResolve.prIdFromRef(ref)
+    || (payload && payload.slug ? `${payload.slug}#${payload.number}` : 'the pull request');
   const guidance = PR_ACTION_GUIDANCE[act] || PR_ACTION_GUIDANCE.review;
 
   const sections = [