@yemi33/minions 0.1.1877 → 0.1.1879

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.1879 (2026-05-12)
+
+### Fixes
+- reconcile stale failed plan follow-ups (#2366) (#2371)
+- Copilot resolver picks POSIX shim on Windows (#2370) (#2372)
+
 ## 0.1.1877 (2026-05-11)
 
 ### Fixes

package/dashboard/js/render-plans.js

@@ -61,12 +61,60 @@ async function refreshPlans() {
   } catch (e) { console.error('plans refresh:', e.message); }
 }
 
+/**
+ * Returns true when a failed plan follow-up work item's intended outcome has
+ * been satisfied by a later/alternate path — so the stale failure should not
+ * drive the plan's top-level "has failures" badge.
+ *
+ * Reconciliation rules (issue #2366):
+ * - Failed `itemType: 'pr'` (Create PR for plan): satisfied when a PR linked
+ *   to the same plan exists in any non-terminated state (active/merged/linked).
+ *   The original failure is preserved on the WI for audit; it just doesn't
+ *   count toward the rollup once a PR actually got created.
+ * - Failed `itemType: 'verify'`: satisfied when a newer verify WI for the
+ *   same plan + project exists and is done OR in-flight (pending/dispatched).
+ *
+ * Returns false when the outcome cannot be confirmed satisfied — failure
+ * remains live and drives the badge.
+ */
+function isFollowUpOutcomeSatisfied(wi, allWorkItems, allPrs) {
+  if (!wi || wi.status !== 'failed') return false;
+  if (wi.itemType === 'pr') {
+    // PR for this plan was created on any non-terminated path.
+    // "abandoned" / "closed" are terminal failures; everything else counts as
+    // the desired outcome being reached.
+    return (allPrs || []).some(pr =>
+      pr && pr.sourcePlan === wi.sourcePlan &&
+      pr.status !== 'abandoned' && pr.status !== 'closed'
+    );
+  }
+  if (wi.itemType === 'verify') {
+    // A newer verify WI for the same plan + project that is in flight or done.
+    const wiCreated = wi.created || '';
+    return (allWorkItems || []).some(other =>
+      other && other !== wi && other.itemType === 'verify' &&
+      other.sourcePlan === wi.sourcePlan &&
+      (other.project || '') === (wi.project || '') &&
+      (other.status === 'done' || other.status === 'pending' || other.status === 'dispatched') &&
+      (other.created || '') > wiCreated
+    );
+  }
+  return false;
+}
+
 /**
  * Derive effective plan/PRD status from work items (single source of truth).
  * PRD JSON status is treated as user intent (approved, paused, rejected),
  * but completion/progress is always derived from actual work item state.
+ *
+ * opts.allPrs — optional PR records used to reconcile stale failed follow-up
+ * tasks (issue #2366). Falls back to window._lastStatus.pullRequests in the
+ * browser. Pass `[]` to disable reconciliation.
  */
-function derivePlanStatus(prdFile, mdFile, prdJsonStatus, workItems) {
+function derivePlanStatus(prdFile, mdFile, prdJsonStatus, workItems, opts) {
+  const allPrs = (opts && opts.allPrs)
+    || (typeof window !== 'undefined' && window._lastStatus && window._lastStatus.pullRequests)
+    || [];
   const wi = workItems.filter(w =>
     w.sourcePlan === prdFile || w.sourcePlan === mdFile ||
     (w.type === 'plan-to-prd' && (w.planFile === prdFile || w.planFile === mdFile))
@@ -74,8 +122,18 @@ function derivePlanStatus(prdFile, mdFile, prdJsonStatus, workItems) {
   const implementWi = wi.filter(w => w.type !== 'plan-to-prd' && w.type !== 'verify');
   const hasPendingPrd = wi.some(w => w.type === 'plan-to-prd' && (w.status === 'pending' || w.status === 'dispatched'));
   const hasActiveWork = implementWi.some(w => w.status === 'pending' || w.status === 'dispatched');
-  const allDone = implementWi.length > 0 && implementWi.every(w => w.status === 'done' || w.status === 'decomposed');
-  const hasFailed = implementWi.some(w => w.status === 'failed');
+  // A WI is "effectively done" when it succeeded normally OR when it is a
+  // reconciled follow-up failure (intended outcome satisfied elsewhere — #2366).
+  // The original failure record is preserved on the WI for audit; it just
+  // stops blocking plan completion and stops driving the red badge.
+  const isReconciledFailure = (w) =>
+    w.status === 'failed' &&
+    (w.itemType === 'pr' || w.itemType === 'verify') &&
+    isFollowUpOutcomeSatisfied(w, workItems, allPrs);
+  const isEffectivelyDone = (w) =>
+    w.status === 'done' || w.status === 'decomposed' || isReconciledFailure(w);
+  const allDone = implementWi.length > 0 && implementWi.every(isEffectivelyDone);
+  const hasFailed = implementWi.some(w => w.status === 'failed' && !isReconciledFailure(w));
 
   // User-set statuses take priority when no work has started
   if (prdJsonStatus === 'rejected') return 'rejected';
@@ -897,4 +955,4 @@ async function planUnarchive(file, btn) {
   } catch (e) { showToast('cmd-toast', 'Error: ' + e.message, false); refresh(); }
 }
 
-window.MinionsPlans = { openCreatePlanModal, refreshPlans, derivePlanStatus, renderPlans, openArchivedPlansModal, planExecute, planReexecuteModal, planReexecuteSubmit, planSubmitRevise, planShowRevise, planHideRevise, planView, planApprove, planArchive, planUnarchive, planDelete, planPause, planReject, planDiscuss, planOpenInDocChat, planRegeneratePRD, openVerifyGuide, triggerVerify };
+window.MinionsPlans = { openCreatePlanModal, refreshPlans, derivePlanStatus, isFollowUpOutcomeSatisfied, renderPlans, openArchivedPlansModal, planExecute, planReexecuteModal, planReexecuteSubmit, planSubmitRevise, planShowRevise, planHideRevise, planView, planApprove, planArchive, planUnarchive, planDelete, planPause, planReject, planDiscuss, planOpenInDocChat, planRegeneratePRD, openVerifyGuide, triggerVerify };

package/engine/runtimes/copilot.js

@@ -55,6 +55,14 @@ const isWin = process.platform === 'win32';
 const CAPS_FILE = path.join(_CACHE_DIR, 'copilot-caps.json');
 const MODELS_CACHE = path.join(_CACHE_DIR, 'copilot-models.json');
 
+// Bump when cache shape or resolution semantics change so we can ignore stale
+// entries from earlier resolver versions. v1 (pre-issue-2370): picked
+// `where copilot` line 1, which silently selected the POSIX bash shim on
+// Windows npm installs and chained into a node.exe-loads-bash-script crash.
+// v2: parses the full `where` output, prefers .exe, and resolves npm shims
+// to the sibling node_modules/@github/copilot/index.js JS entry.
+const CAPS_SCHEMA_VERSION = 2;
+
 function _safeJson(p) {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
 }
@@ -68,16 +76,149 @@ function _execSyncCapture(cmd, env, timeoutMs = 10000) {
 }
 
 /**
- * Probe PATH for a standalone `copilot` binary. Returns the absolute path or
+ * Pure helper: choose the best `copilot` binary from a `where` / `which`
+ * output buffer. Returns `{ bin, native }` or null.
+ *
+ * Background (issue #2370): on Windows `where copilot` enumerates every file
+ * along PATH in PATHEXT order, e.g. for an `npm i -g @github/copilot` install:
+ *   C:\Users\<u>\AppData\Roaming\npm\copilot         (POSIX `#!/bin/sh` shim)
+ *   C:\Users\<u>\AppData\Roaming\npm\copilot.cmd     (Windows cmd shim)
+ *   C:\Users\<u>\AppData\Roaming\npm\copilot.ps1     (PowerShell shim)
+ * The legacy resolver took `.split('\n')[0]` (the extensionless shim) and
+ * marked it `native: false`, which made engine/llm.js spawn `node.exe <shim>`.
+ * Node parsed the bash script as JS and exit-1'd in <1s, silently breaking
+ * every Copilot dispatch.
+ *
+ * Resolution priority on Windows:
+ *   1. `.exe`                                  → native:true, run directly
+ *   2. JS entry sibling of a `.cmd`/`.bat`/shim (npm install pattern) → native:false
+ *   3. `.js`                                   → native:false, loaded by Node
+ * Anything else (`.cmd`/`.bat` without a JS sibling, raw POSIX shim) is
+ * skipped — spawning it via the existing llm.js code path would fail.
+ *
+ * On non-Windows the standard `which` always returns one usable file, so we
+ * pick the first that exists. `existsSync` is parameterized so unit tests
+ * can simulate sibling-file presence without touching the real filesystem.
+ */
+function _pickStandaloneCopilotFromOutput(rawOutput, { existsSync = fs.existsSync, isWin: _isWin = isWin } = {}) {
+  if (rawOutput == null) return null;
+  const lines = String(rawOutput).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+  if (lines.length === 0) return null;
+  const existing = lines.filter(l => {
+    try { return existsSync(l); } catch { return false; }
+  });
+  if (existing.length === 0) return null;
+
+  if (!_isWin) {
+    // POSIX `which` returns one line; first existing entry wins. Mark native
+    // when there's no extension or an executable extension — but since
+    // engine/llm.js only checks `.exe` for native on Windows and otherwise
+    // routes through process.execPath on non-native, we keep native:true on
+    // POSIX (matches legacy behavior — spawn(<bin>) works directly).
+    return { bin: existing[0], native: true };
+  }
+
+  const byExt = (ext) => existing.find(l => l.toLowerCase().endsWith(ext));
+  const exe = byExt('.exe');
+  if (exe) return { bin: exe, native: true };
+
+  // npm shim path: copilot.cmd / copilot.bat / extensionless shim → look for
+  // a Node-loadable JS entry next to it. npm places the package at
+  // <shim_dir>\node_modules\@github\copilot\index.js for `@github/copilot`.
+  // The .cmd shim itself just invokes `node "%~dp0\node_modules\@github\copilot\index.js"`,
+  // so resolving directly to the JS entry sidesteps both the .cmd-via-node
+  // crash AND the POSIX-shim-via-node crash.
+  const shim = byExt('.cmd') || byExt('.bat') || existing.find(l => !path.extname(l));
+  if (shim) {
+    const jsEntry = _resolveNpmCopilotJsEntry(shim, existsSync);
+    if (jsEntry) return { bin: jsEntry, native: false };
+  }
+
+  // Fall back to a bare `.js` listing (rare — npm rarely emits a `.js`
+  // alongside the shims, but a hand-rolled install may).
+  const js = byExt('.js');
+  if (js) return { bin: js, native: false };
+
+  // Nothing safely spawnable. Let resolveBinary fall through to the gh
+  // extension probe rather than caching a known-broken path.
+  return null;
+}
+
+/**
+ * Given a Windows shim path like `C:\...\npm\copilot.cmd` (or the
+ * extensionless POSIX shim sibling), look for the actual JS entry the shim
+ * dispatches to. Returns the absolute path or null when none exists.
+ *
+ * Layout produced by `npm i -g @github/copilot` on Windows:
+ *   <prefix>\copilot              (POSIX shim)
+ *   <prefix>\copilot.cmd          (Windows shim)
+ *   <prefix>\copilot.ps1
+ *   <prefix>\node_modules\@github\copilot\index.js   ← what the shim invokes
+ *
+ * We probe a small list of conventional JS entry locations rather than
+ * parsing the shim itself — shim contents are npm-version-specific and not
+ * a stable contract.
+ */
+function _resolveNpmCopilotJsEntry(shimPath, existsSync = fs.existsSync) {
+  if (!shimPath) return null;
+  // Separator-agnostic dirname. path.dirname() on POSIX hosts (e.g. Linux CI
+  // runners) does not recognize backslashes, so feeding a Windows shim path
+  // like `C:\Users\u\AppData\Roaming\npm\copilot.cmd` returns '.' and breaks
+  // every npm-layout probe. Split on whichever separator appears last.
+  const lastSep = Math.max(shimPath.lastIndexOf('\\'), shimPath.lastIndexOf('/'));
+  const dir = lastSep >= 0 ? shimPath.slice(0, lastSep) : '.';
+  const candidates = [
+    path.join(dir, 'node_modules', '@github', 'copilot', 'index.js'),
+    path.join(dir, 'node_modules', '@github', 'copilot', 'dist', 'index.js'),
+    path.join(dir, 'node_modules', '@github', 'copilot', 'bin', 'index.js'),
+    path.join(dir, 'node_modules', '@github', 'copilot-cli', 'index.js'),
+  ];
+  for (const c of candidates) {
+    try { if (existsSync(c)) return c; } catch { /* best effort */ }
+  }
+  return null;
+}
+
+/**
+ * Probe PATH for a standalone `copilot` binary. Returns `{ bin, native }` or
  * null. Resilient to non-zero exits (where/which return 1 when nothing found).
+ *
+ * Native flag:
+ *   - true  → spawn directly (`.exe`, POSIX `which` hit)
+ *   - false → spawn via process.execPath (Node), bin must be JS-loadable
  */
 function _findStandaloneCopilot(env) {
   try {
     const cmd = isWin ? 'where copilot 2>NUL' : 'which copilot 2>/dev/null';
-    const which = _execSyncCapture(cmd, env).trim().split('\n')[0].trim();
-    if (which && fs.existsSync(which)) return which;
-  } catch { /* PATH probe is optional */ }
-  return null;
+    const raw = _execSyncCapture(cmd, env);
+    return _pickStandaloneCopilotFromOutput(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate a cached resolveBinary entry against the current schema. Returns
+ * true when the cache is safe to reuse, false when it must be re-resolved.
+ *
+ * Hard invalidation rules:
+ *   - missing/non-matching schema version (pre-#2370 caches)
+ *   - on Windows, copilotIsNative=false but bin lacks a Node-loadable
+ *     extension (extensionless POSIX shim, .cmd, .bat — any of which would
+ *     re-trigger the issue #2370 crash on next spawn)
+ */
+function _isCachedBinUsable(cached) {
+  if (!cached || typeof cached !== 'object') return false;
+  if (typeof cached.copilotBin !== 'string' || !cached.copilotBin) return false;
+  if (cached.version !== CAPS_SCHEMA_VERSION) return false;
+  try { if (!fs.existsSync(cached.copilotBin)) return false; } catch { return false; }
+  if (isWin && cached.copilotIsNative === false) {
+    const ext = path.extname(cached.copilotBin).toLowerCase();
+    // Only Node-loadable extensions are safe with native:false on Windows.
+    // Anything else (extensionless shim, .cmd, .bat) would crash on spawn.
+    if (ext !== '.js' && ext !== '.mjs' && ext !== '.cjs') return false;
+  }
+  return true;
 }
 
 /**
@@ -114,32 +255,40 @@ function _findGhCopilotExtension(env) {
  * standalone CLI" warnings without re-probing.
  */
 function resolveBinary({ env = process.env } = {}) {
-  // 1. Cache hit — fastest path
+  // 1. Cache hit — fastest path. Validate before trusting: stale pre-#2370
+  // entries that point at a POSIX bash shim with native:false would re-crash
+  // every spawn until manually wiped, so we re-resolve when the schema or
+  // shape doesn't match what _findStandaloneCopilot now produces.
   const cached = _safeJson(CAPS_FILE);
-  if (cached?.copilotBin && fs.existsSync(cached.copilotBin)) {
+  if (_isCachedBinUsable(cached)) {
     const leadingArgs = Array.isArray(cached.leadingArgs) ? cached.leadingArgs : [];
     return { bin: cached.copilotBin, native: !!cached.copilotIsNative, leadingArgs };
   }
 
-  // 2. Standalone `copilot` first (preferred)
+  // 2. Standalone `copilot` first (preferred). Now returns { bin, native }
+  // so the resolver no longer has to guess at native-ness from extension alone
+  // — _pickStandaloneCopilotFromOutput owns that decision.
   const standalone = _findStandaloneCopilot(env);
   if (standalone) {
-    const native = !isWin || path.extname(standalone).toLowerCase() === '.exe';
     _safeWriteJson(CAPS_FILE, {
-      copilotBin: standalone,
-      copilotIsNative: native,
+      version: CAPS_SCHEMA_VERSION,
+      copilotBin: standalone.bin,
+      copilotIsNative: standalone.native,
       leadingArgs: [],
       source: 'standalone',
       resolvedAt: new Date().toISOString(),
     });
-    return { bin: standalone, native, leadingArgs: [] };
+    return { bin: standalone.bin, native: standalone.native, leadingArgs: [] };
   }
 
-  // 3. `gh copilot` extension fallback (best-effort)
+  // 3. `gh copilot` extension fallback (best-effort). gh is itself a native
+  // binary (gh.exe / `gh` POSIX), so the .exe / POSIX-passthrough heuristic
+  // is fine here — no shim layer to worry about.
   const gh = _findGhCopilotExtension(env);
   if (gh) {
     const native = !isWin || path.extname(gh).toLowerCase() === '.exe';
     _safeWriteJson(CAPS_FILE, {
+      version: CAPS_SCHEMA_VERSION,
       copilotBin: gh,
       copilotIsNative: native,
       leadingArgs: ['copilot'],
@@ -1028,5 +1177,9 @@ module.exports = {
   _copilotAssistantMessageHasTools,
   _readCatalogIds,
   _hyphenToDotVersion,
+  _pickStandaloneCopilotFromOutput,
+  _resolveNpmCopilotJsEntry,
+  _isCachedBinUsable,
+  CAPS_SCHEMA_VERSION,
   KNOWN_EVENT_TYPES,
 };

package/package.json

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