@yemi33/minions 0.1.2289 → 0.1.2290

package/engine/live-checkout.js

@@ -172,6 +172,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 +213,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 +229,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 +539,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 +556,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 +646,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.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,
         });

package/package.json

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