@yemi33/minions 0.1.2289 → 0.1.2291

package/dashboard.js

@@ -6804,13 +6804,13 @@ const server = http.createServer(async (req, res) => {
       if (originWi) item._originWi = originWi;
       await copyWorkItemPrFields(item, body, null, { project: targetProject });
       // W-mq5wfh1v000e0da9 — Auto-enroll the PR into pull-requests.json when
-      // this is a `type: fix` WI carrying a structured PR pointer and the PR
-      // isn't tracked yet. Without this, the engine's `pr_not_found` gate
-      // skips the fix forever (engine.js dispatch loop). Idempotent — safe to
+      // this is a `type: fix/review/test` WI carrying a structured PR pointer and
+      // the PR isn't tracked yet. Without this, the engine's `pr_not_found` gate
+      // skips the WI forever (engine.js dispatch loop). Idempotent — safe to
       // call on every WI create. Failures are swallowed (best-effort belt;
       // engine.js#dispatch loop also calls this as defense-in-depth).
       try {
-        shared.autoEnrollPrFromFixWorkItem(item, targetProject, MINIONS_DIR);
+        shared.autoEnrollPrFromWorkItem(item, targetProject, MINIONS_DIR);
       } catch (e) {
         shared.log('warn', `auto-enroll PR for ${item.id}: ${e.message}`);
       }

package/engine/live-checkout.js

@@ -101,7 +101,6 @@ const shared = require('./shared');
 // still bounded. Threaded through `baseOpts` so every git call inherits it; the
 // injected `_git` mock in unit tests ignores opts so the seam is unaffected.
 const LIVE_CHECKOUT_GIT_MAX_BUFFER = 50 * 1024 * 1024;
-
 // PL-live-checkout-reliability-hardening — partial-clone / GVFS blob-fetch
 // signature match. On a Scalar/GVFS-managed ADO repo (blobless partial clone),
 // switching the working tree onto a branch whose tree differs from HEAD must
@@ -172,6 +171,7 @@ async function prepareLiveCheckout(opts = {}) {
     gitOpts,
     dispatchId, // accepted for caller bookkeeping; not used by the helper
     wiId,       // accepted for caller bookkeeping; used in the auto-reset note slug
+    skipDirtyCheck,  // #522: opt-out for GVFS repos where git status output exceeds maxBuffer
     log,
     autoReset,  // W-mqvejug6000eeb20: tri-state. `true`/`false` short-circuits the
                 // config-based resolution; `undefined` (the engine.js call shape)
@@ -212,6 +212,14 @@ async function prepareLiveCheckout(opts = {}) {
   const baseOpts = { cwd: localPath, maxBuffer: LIVE_CHECKOUT_GIT_MAX_BUFFER, ...(gitOpts || {}) };
 
   // ── Step 1: git status --porcelain=v1 -b. Bail early on dirty tree. ─────
+  // Skipped when `skipDirtyCheck:true` (issue #522): GVFS/VFS-for-Git repos
+  // report all un-hydrated virtual files as modified — this is normal GVFS
+  // behavior, not actual WIP. On repos with ~120k virtual dirty files the
+  // buffered `git status` output exceeds Node's default maxBuffer (~1MB) and
+  // throws before any agent spawns. Setting `skipDirtyCheck:true` via the
+  // project-level `skipLiveCheckoutDirtyCheck` config key bypasses the probe
+  // entirely so agents can dispatch normally on GVFS repos.
+  //
   // Porcelain v1 -b adds a `## <branch>` header line as the first output line
   // so callers get branch diagnostics for free alongside the file-status lines.
   // The file-status lines still use the two-char XY status code (e.g.
@@ -220,92 +228,94 @@ async function prepareLiveCheckout(opts = {}) {
   // trailing whitespace/CR per line — outer-trimming the whole blob would eat
   // the leading XY space on the first line. The `## ` header is separated out
   // before the dirtyFiles check so callers receive it as `branchInfo`.
-  const statusRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
-  const statusStr = typeof statusRaw === 'string' ? statusRaw : '';
-  const statusLines = statusStr
-    .split(/\r?\n/)
-    .map((line) => line.replace(/\s+$/, ''))
-    .filter((line) => line.length > 0);
-  const branchInfo = statusLines.find((line) => line.startsWith('## ')) || '';
-  const dirtyFiles = statusLines.filter((line) => !line.startsWith('## '));
-  if (dirtyFiles.length > 0) {
-    // W-mqvejug6000eeb20 — opt-in auto-reset. Default behavior is to bail with
-    // reason:'dirty' (spawnAgent translates to non-retryable LIVE_CHECKOUT_DIRTY
-    // and alerts the operator). When auto-reset is enabled — either the caller
-    // passed an explicit `autoReset` boolean, or the config-based resolver says
-    // so — we DISCARD the dirty state via `git fetch origin` + `git reset --hard
-    // origin/<branch>` and continue. This is destructive (the operator's
-    // uncommitted work is gone), which is why it is strictly opt-in.
-    let wantAutoReset = false;
-    if (typeof autoReset === 'boolean') {
-      wantAutoReset = autoReset;
-    } else {
-      const resolver = (typeof _resolveAutoReset === 'function') ? _resolveAutoReset : _defaultResolveAutoReset;
-      try { wantAutoReset = !!resolver(localPath); } catch { wantAutoReset = false; }
-    }
+  if (!skipDirtyCheck) {
+    const statusRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
+    const statusStr = typeof statusRaw === 'string' ? statusRaw : '';
+    const statusLines = statusStr
+      .split(/\r?\n/)
+      .map((line) => line.replace(/\s+$/, ''))
+      .filter((line) => line.length > 0);
+    const branchInfo = statusLines.find((line) => line.startsWith('## ')) || '';
+    const dirtyFiles = statusLines.filter((line) => !line.startsWith('## '));
+    if (dirtyFiles.length > 0) {
+      // W-mqvejug6000eeb20 — opt-in auto-reset. Default behavior is to bail with
+      // reason:'dirty' (spawnAgent translates to non-retryable LIVE_CHECKOUT_DIRTY
+      // and alerts the operator). When auto-reset is enabled — either the caller
+      // passed an explicit `autoReset` boolean, or the config-based resolver says
+      // so — we DISCARD the dirty state via `git fetch origin` + `git reset --hard
+      // origin/<branch>` and continue. This is destructive (the operator's
+      // uncommitted work is gone), which is why it is strictly opt-in.
+      let wantAutoReset = false;
+      if (typeof autoReset === 'boolean') {
+        wantAutoReset = autoReset;
+      } else {
+        const resolver = (typeof _resolveAutoReset === 'function') ? _resolveAutoReset : _defaultResolveAutoReset;
+        try { wantAutoReset = !!resolver(localPath); } catch { wantAutoReset = false; }
+      }
 
-    if (!wantAutoReset) {
-      return { ok: false, reason: 'dirty', dirtyFiles, branchInfo };
-    }
+      if (!wantAutoReset) {
+        return { ok: false, reason: 'dirty', dirtyFiles, branchInfo };
+      }
 
-    if (typeof log === 'function') {
-      log(`live-checkout auto-reset: discarding ${dirtyFiles.length} dirty path(s) on '${branchName}' via fetch + reset --hard origin/${branchName}`);
-    }
-    let resetOk = true;
-    try {
-      await git(['fetch', 'origin'], baseOpts);
-      await git(['reset', '--hard', `origin/${branchName}`], baseOpts);
-    } catch (e) {
-      resetOk = false;
       if (typeof log === 'function') {
-        log(`live-checkout auto-reset FAILED (fetch/reset): ${e && e.message ? e.message : e}`);
+        log(`live-checkout auto-reset: discarding ${dirtyFiles.length} dirty path(s) on '${branchName}' via fetch + reset --hard origin/${branchName}`);
       }
-    }
-
-    // Re-run the porcelain preflight once. If the tree is now clean we proceed;
-    // otherwise (reset failed, or something is still dirty) we fall back to the
-    // safe dirty refusal so we never dispatch onto an unexpected tree.
-    let stillDirty = dirtyFiles;
-    if (resetOk) {
+      let resetOk = true;
       try {
-        const recheckRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
-        const recheckStr = typeof recheckRaw === 'string' ? recheckRaw : '';
-        stillDirty = recheckStr
-          .split(/\r?\n/)
-          .map((line) => line.replace(/\s+$/, ''))
-          .filter((line) => line.length > 0 && !line.startsWith('## '));
+        await git(['fetch', 'origin'], baseOpts);
+        await git(['reset', '--hard', `origin/${branchName}`], baseOpts);
       } catch (e) {
         resetOk = false;
         if (typeof log === 'function') {
-          log(`live-checkout auto-reset re-check FAILED: ${e && e.message ? e.message : e}`);
+          log(`live-checkout auto-reset FAILED (fetch/reset): ${e && e.message ? e.message : e}`);
         }
       }
-    }
 
-    if (!resetOk || stillDirty.length > 0) {
-      return { ok: false, reason: 'dirty', dirtyFiles: stillDirty, branchInfo };
-    }
+      // Re-run the porcelain preflight once. If the tree is now clean we proceed;
+      // otherwise (reset failed, or something is still dirty) we fall back to the
+      // safe dirty refusal so we never dispatch onto an unexpected tree.
+      let stillDirty = dirtyFiles;
+      if (resetOk) {
+        try {
+          const recheckRaw = await git(['status', '--porcelain=v1', '-b'], baseOpts);
+          const recheckStr = typeof recheckRaw === 'string' ? recheckRaw : '';
+          stillDirty = recheckStr
+            .split(/\r?\n/)
+            .map((line) => line.replace(/\s+$/, ''))
+            .filter((line) => line.length > 0 && !line.startsWith('## '));
+        } catch (e) {
+          resetOk = false;
+          if (typeof log === 'function') {
+            log(`live-checkout auto-reset re-check FAILED: ${e && e.message ? e.message : e}`);
+          }
+        }
+      }
 
-    // Audit trail: record the discarded paths so the operator can recover from
-    // reflog / understand why their tree changed. Best-effort, never throws.
-    try {
-      const writeNote = (typeof _writeInboxNote === 'function') ? _writeInboxNote : _defaultWriteInboxNote;
-      const slug = `live-checkout-autoreset-${wiId || dispatchId || 'unknown'}`;
-      const body = [
-        `# Live-checkout auto-reset on '${branchName}'`,
-        '',
-        `⚠️ The live-checkout tree at \`${localPath}\` was dirty at dispatch time and`,
-        '`liveCheckoutAutoReset` is enabled, so it was force-reset to',
-        `\`origin/${branchName}\`. **The following uncommitted changes were DISCARDED**`,
-        '(recover from `git reflog` / `git fsck --lost-found` if needed):',
-        '',
-        '```',
-        ...dirtyFiles,
-        '```',
-      ].join('\n');
-      writeNote(slug, body);
-    } catch { /* best-effort audit note */ }
-    // Fall through — tree is now clean, continue with normal preparation.
+      if (!resetOk || stillDirty.length > 0) {
+        return { ok: false, reason: 'dirty', dirtyFiles: stillDirty, branchInfo };
+      }
+
+      // Audit trail: record the discarded paths so the operator can recover from
+      // reflog / understand why their tree changed. Best-effort, never throws.
+      try {
+        const writeNote = (typeof _writeInboxNote === 'function') ? _writeInboxNote : _defaultWriteInboxNote;
+        const slug = `live-checkout-autoreset-${wiId || dispatchId || 'unknown'}`;
+        const body = [
+          `# Live-checkout auto-reset on '${branchName}'`,
+          '',
+          `⚠️ The live-checkout tree at \`${localPath}\` was dirty at dispatch time and`,
+          '`liveCheckoutAutoReset` is enabled, so it was force-reset to',
+          `\`origin/${branchName}\`. **The following uncommitted changes were DISCARDED**`,
+          '(recover from `git reflog` / `git fsck --lost-found` if needed):',
+          '',
+          '```',
+          ...dirtyFiles,
+          '```',
+        ].join('\n');
+        writeNote(slug, body);
+      } catch { /* best-effort audit note */ }
+      // Fall through — tree is now clean, continue with normal preparation.
+    }
   }
 
   // ── Step 2: mid-operation / detached-HEAD preflight (P-b2e8d4a6). ──────
@@ -528,6 +538,7 @@ async function prepareLiveCheckout(opts = {}) {
  * @param {boolean} [opts.isTerminalFailure] true on error/timeout/crash
  * @param {string} [opts.resultLabel]      short status word for the alert body
  * @param {object} [opts.gitOpts]          extra execFile opts merged into cwd
+ * @param {boolean} [opts.skipDirtyCheck]  #522: skip the self-healing dirty probe (GVFS repos)
  * @param {function} [opts.log]            (level, msg) => void
  * @param {function} opts.writeInboxAlert  (slug, body) => any  (false = deduped)
  * @param {function} [opts._git]           test seam; defaults to shellSafeGit
@@ -544,6 +555,7 @@ async function restoreLiveCheckoutAtDispatchEnd(opts = {}) {
     isTerminalFailure,
     resultLabel,
     gitOpts,
+    skipDirtyCheck,  // #522: opt-out for GVFS repos — same flag as prepareLiveCheckout
     log,
     writeInboxAlert,
     _git, // private injection for testing — defaults to shared.shellSafeGit
@@ -633,7 +645,16 @@ async function restoreLiveCheckoutAtDispatchEnd(opts = {}) {
     // never reaches here (git status is empty → not dirty). Best-effort: a
     // failed commit falls through to the plain checkout, which refuses and
     // writes the existing manual-recovery alert — no worse than before.
-    if (branchName && branchName !== originalRef) {
+    //
+    // Skipped when `skipDirtyCheck:true` (#522 / GVFS repos): on GVFS/VFS-for-Git
+    // trees, `git status` reports ~120k un-hydrated virtual files as modified even
+    // when the operator's tree is effectively clean. Since prepareLiveCheckout
+    // also skips the dirty probe on GVFS repos, the precondition "tree was verified
+    // clean before the agent ran" doesn't hold — we cannot distinguish real
+    // agent-authored dirt from GVFS virtual noise. Skipping the self-heal here
+    // is safe: the plain `git checkout <originalRef>` below will succeed because
+    // GVFS's virtual dirty state does NOT block git checkout.
+    if (!skipDirtyCheck && branchName && branchName !== originalRef) {
       let dirty = false;
       try {
         const statusRaw = await git(['status', '--porcelain'], baseOpts);

package/engine/shared.js

@@ -7245,11 +7245,12 @@ function classifyPrRefForVerification(prRef, project = null) {
 // per the "structured-vs-loose split" — enrollment must be intentional.
 //
 // Returns:
-//   { skipped: true, reason }            — not a fix / no ref / no URL / upsert error
+//   { skipped: true, reason }            — not a pr-requiring type / no ref / no URL / upsert error
 //   { alreadyEnrolled: true, id }        — PR already in pull-requests.json
 //   { enrolled: true, id, prPath }       — newly enrolled
-function autoEnrollPrFromFixWorkItem(item, project, minionsDir) {
-  if (!item || item.type !== WORK_TYPE.FIX) return { skipped: true, reason: 'not-fix' };
+const _PR_REQUIRING_TYPES = new Set([WORK_TYPE.FIX, WORK_TYPE.REVIEW, WORK_TYPE.TEST]);
+function autoEnrollPrFromWorkItem(item, project, minionsDir) {
+  if (!item || !_PR_REQUIRING_TYPES.has(item.type)) return { skipped: true, reason: 'not-pr-requiring-type' };
   const prRef = extractStructuredWorkItemPrRef(item);
   if (!prRef) return { skipped: true, reason: 'no-structured-ref' };
   const url = deriveUrlForPrRef(prRef, project);
@@ -7280,10 +7281,12 @@ function autoEnrollPrFromFixWorkItem(item, project, minionsDir) {
       ? { enrolled: true, id: result.id, prPath }
       : { alreadyEnrolled: true, id: result.id };
   } catch (e) {
-    log('warn', `autoEnrollPrFromFixWorkItem ${item.id}: ${e.message}`);
+    log('warn', `autoEnrollPrFromWorkItem ${item.id}: ${e.message}`);
     return { skipped: true, reason: 'upsert-error', error: e.message };
   }
 }
+// Backward-compat alias — external callers that reference autoEnrollPrFromFixWorkItem keep working.
+const autoEnrollPrFromFixWorkItem = autoEnrollPrFromWorkItem;
 
 // ─── Cross-Platform Process Kill Helpers ─────────────────────────────────────
 
@@ -9015,6 +9018,7 @@ module.exports = {
   isContextOnlyPrRecord,
   upsertPullRequestRecord,
   isAutoManagedPrRecord, // W-mq5s5ttx000j7ab8-a — exported for engine + watch-plugin gate consolidation
+  autoEnrollPrFromWorkItem,
   autoEnrollPrFromFixWorkItem,
   deriveUrlForPrRef, // exported for testing
   classifyPrRefForVerification, // issue #246 — host routing for loose PR-ref verification

package/engine.js

@@ -2380,6 +2380,7 @@ async function spawnAgent(dispatchItem, config) {
         gitOpts: _gitOpts,
         dispatchId: id,
         wiId: _wiIdForAlert,
+        skipDirtyCheck: !!project.skipLiveCheckoutDirtyCheck,
         log: (msg, lvl) => log(lvl || 'info', msg),
       });
     } catch (liveErr) {
@@ -5283,6 +5284,7 @@ async function spawnAgent(dispatchItem, config) {
           isTerminalFailure: effectiveResult !== DISPATCH_RESULT.SUCCESS,
           resultLabel: errorReason || effectiveResult,
           gitOpts: _gitOpts,
+          skipDirtyCheck: !!project?.skipLiveCheckoutDirtyCheck,
           log,
           writeInboxAlert,
         });
@@ -8094,16 +8096,15 @@ function discoverFromWorkItems(config, project) {
       skipped.noAgent++; continue;
     }
 
-    // W-mq5wfh1v000e0da9 — defense-in-depth: auto-enroll the PR for fix WIs
+    // W-mq5wfh1v000e0da9 — defense-in-depth: auto-enroll the PR for fix/review/test WIs
     // carrying a structured PR pointer. Primary enrollment runs in the
     // dashboard `POST /api/work-items` handler, but WIs created via CLI / restored
     // from disk / older code paths might land here without the PR record.
-    // No-op if the PR is already tracked. Failures swallowed — the gate below
-    // still trips on missing PR records and surfaces `pr_not_found`.
+    // No-op if the PR is already tracked or if the type doesn't require a PR.
+    // Failures swallowed — the gate below still trips on missing PR records
+    // and surfaces `pr_not_found`.
     try {
-      if (item.type === WORK_TYPE.FIX) {
-        shared.autoEnrollPrFromFixWorkItem(item, project, MINIONS_DIR);
-      }
+      shared.autoEnrollPrFromWorkItem(item, project, MINIONS_DIR);
     } catch (e) { log('warn', `auto-enroll PR for ${item.id}: ${e.message}`); }
 
     const linkedPr = resolveWorkItemPrRecord(item, project);

package/package.json

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