@yemi33/minions 0.1.1876 → 0.1.1878

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1878 (2026-05-12)
+
+### Fixes
+- Copilot resolver picks POSIX shim on Windows (#2370) (#2372)
+
+## 0.1.1877 (2026-05-11)
+
+### Fixes
+- PRD header showing Completed when items are still missing (#2364)
+
 ## 0.1.1876 (2026-05-11)
 
 ### Features

package/dashboard/js/render-prd.js

@@ -35,7 +35,9 @@ function renderPrd(prd, prog) {
     // Single PRD — show status + actions in header
     const implementItems = allWi.filter(w => prdItems.some(pi => pi.id === w.id));
     const allDone = implementItems.length > 0 && implementItems.every(w => w.status === 'done');
-    const hasActive = implementItems.some(w => w.status === 'pending' || w.status === 'dispatched');
+    // Unmaterialized PRD items (status === 'missing') count as active — they still need work.
+    const hasMissing = prdItems.some(i => i.status === 'missing');
+    const hasActive = hasMissing || implementItems.some(w => w.status === 'pending' || w.status === 'dispatched');
     const prdFile = existing[0]?.file || '';
     const prdStatus = existing[0]?.status || '';
     const effectiveStatus = allDone && !hasActive ? 'completed' : hasActive ? 'dispatched' : prdStatus || 'active';
@@ -65,7 +67,9 @@ function renderPrd(prd, prog) {
       const items = prdItems.filter(i => i.source === p.file);
       const wiForPrd = allWi.filter(w => items.some(pi => pi.id === w.id));
       const allDone = wiForPrd.length > 0 && wiForPrd.every(w => w.status === 'done');
-      const hasActive = wiForPrd.some(w => w.status === 'pending' || w.status === 'dispatched');
+      // Unmaterialized PRD items (status === 'missing') count as active — they still need work.
+      const hasMissing = items.some(i => i.status === 'missing');
+      const hasActive = hasMissing || wiForPrd.some(w => w.status === 'pending' || w.status === 'dispatched');
       const s = allDone && !hasActive ? 'completed' : hasActive ? 'dispatched' : p.status || 'active';
       counts[s] = (counts[s] || 0) + 1;
     }

package/engine/queries.js

@@ -1313,6 +1313,7 @@ function getPrdInfo(config) {
   if (_prdResultCache && hash === _prdResultInputHash) return _prdResultCache;
 
   let allPrdItems = [];
+  const existingPrds = [];
   let latestStat = null;
 
   // Check if directory listings need refresh
@@ -1353,6 +1354,13 @@ function getPrdInfo(config) {
               if (recorded && sourceMtime > recorded) planStale = true;
             } catch { /* optional */ }
           }
+          existingPrds.push({
+            file: pf,
+            status: plan.status || 'active',
+            planStale: planStale || plan.planStale || false,
+            completedAt: plan.completedAt || '',
+            _archived: archived,
+          });
           for (const f of plan.missing_features) {
             allPrdItems.push({
               ...f, _source: pf, _planStatus: plan.status || 'active',
@@ -1497,7 +1505,7 @@ function getPrdInfo(config) {
 
   const status = {
     exists: true, age: latestStat ? timeSince(latestStat.mtimeMs) : 'unknown',
-    existing: 0, missing: items.filter(i => i.status === 'missing').length, questions: 0, summary: '',
+    existing: existingPrds, missing: items.filter(i => i.status === 'missing').length, questions: 0, summary: '',
     missingList: items.filter(i => i.status === 'missing').map(f => ({ id: f.id, name: f.name || f.title, priority: f.priority, complexity: f.estimated_complexity || f.size })),
   };
 

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.1876",
+  "version": "0.1.1878",
   "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"