@yemi33/minions 0.1.740 → 0.1.742

package/CHANGELOG.md

@@ -1,10 +1,14 @@
 # Changelog
 
-## 0.1.740 (2026-04-09)
+## 0.1.742 (2026-04-09)
 
 ### Features
 - add prNumber field to pull-requests.json records (#711)
 
+### Fixes
+-  escalate failed plan items instead of blocking indefinitely (closes #722) (#733)
+-  handle NUL pseudo-file in Windows worktree cleanup (#731)
+
 ## 0.1.739 (2026-04-09)
 
 ### Fixes

package/engine/lifecycle.js

@@ -8,7 +8,7 @@ const path = require('path');
 const os = require('os');
 const shared = require('./shared');
 const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, projectPrPath, getPrLinks, addPrLink,
-  log, ts, dateStamp, WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
+  log, ts, dateStamp, WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
   ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS, FAILURE_CLASS } = shared;
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
@@ -34,7 +34,7 @@ function checkPlanCompletion(meta, config) {
   const planItems = allWorkItems.filter(w => w.sourcePlan === planFile && w.itemType !== 'pr' && w.itemType !== 'verify');
   if (planItems.length === 0) return;
 
-  // Hard completion gate: every PRD feature ID must have a corresponding work item in done status.
+  // Hard completion gate: every PRD feature ID must have a corresponding work item in a terminal state.
   const planFeatureIds = new Set((plan.missing_features || []).map(f => f.id).filter(Boolean));
   const workItemById = {};
   for (const w of planItems) { if (w.id) workItemById[w.id] = w; }
@@ -51,20 +51,36 @@ function checkPlanCompletion(meta, config) {
     return;
   }
 
-  // Check 2: every feature's work item must be done (or PRD item marked done externally)
-  const notDone = [...planFeatureIds].filter(id => {
+  // Check 2: every feature must be in a terminal state (done, failed, or cancelled).
+  // Failed/cancelled items are unrecoverable — waiting on them blocks the plan indefinitely.
+  const notTerminal = [...planFeatureIds].filter(id => {
     const w = workItemById[id];
-    if (w && DONE_STATUSES.has(w.status)) return false;
+    if (w && PLAN_TERMINAL_STATUSES.has(w.status)) return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && DONE_STATUSES.has(prdItem.status));
+    return !(prdItem && PLAN_TERMINAL_STATUSES.has(prdItem.status));
   });
-  if (notDone.length > 0) {
-    log('info', `Plan ${planFile}: waiting for done on ${notDone.length}/${planFeatureIds.size} item(s): ${notDone.join(', ')}`);
+  if (notTerminal.length > 0) {
+    log('info', `Plan ${planFile}: waiting for ${notTerminal.length}/${planFeatureIds.size} item(s) to reach terminal state: ${notTerminal.join(', ')}`);
     return;
   }
 
   const doneItems = planItems.filter(w => DONE_STATUSES.has(w.status));
-  const failedItems = planItems.filter(w => w.status === WI_STATUS.FAILED);
+  const failedItems = planItems.filter(w => w.status === WI_STATUS.FAILED || w.status === WI_STATUS.CANCELLED);
+
+  // Escalate failed/cancelled items to human — write inbox alert (deduped by slug)
+  if (failedItems.length > 0) {
+    const alertSlug = `plan-failure-escalation-${planFile.replace('.json', '')}`;
+    const failDetails = failedItems.map(w =>
+      `- \`${w.id}\`: ${w.title || 'Unknown'} — ${w.failReason || w.status}`
+    ).join('\n');
+    shared.writeToInbox('engine', alertSlug,
+      `# Plan Items Failed: ${plan.plan_summary || planFile}\n\n` +
+      `**${failedItems.length}** of ${planFeatureIds.size} item(s) failed or were cancelled:\n\n${failDetails}\n\n` +
+      `The plan is completing with partial results (${doneItems.length} done, ${failedItems.length} failed).\n` +
+      `Review failed items and re-dispatch manually if needed.\n`
+    );
+    log('warn', `Plan ${planFile}: ${failedItems.length} item(s) failed/cancelled — escalating to human: ${failedItems.map(w => w.id).join(', ')}`);
+  }
 
   // 1. Mark plan as completed
   plan.status = PLAN_STATUS.COMPLETED;

package/engine/shared.js

@@ -562,6 +562,9 @@ const WI_STATUS = {
 // Read-side: accept legacy aliases for backward compat with old data/clients.
 // Write-side: only WI_STATUS.DONE is written (cleanup.js migrates old values on each run).
 const DONE_STATUSES = new Set([WI_STATUS.DONE, 'in-pr', 'implemented', 'complete']);
+// Terminal statuses for plan completion — item won't progress further (done, failed, cancelled).
+// Used by checkPlanCompletion to unblock the gate when items are in an unrecoverable state.
+const PLAN_TERMINAL_STATUSES = new Set([...DONE_STATUSES, WI_STATUS.FAILED, WI_STATUS.CANCELLED]);
 const WORK_TYPE = {
   IMPLEMENT: 'implement', IMPLEMENT_LARGE: 'implement:large', FIX: 'fix', REVIEW: 'review',
   VERIFY: 'verify', PLAN: 'plan', PLAN_TO_PRD: 'plan-to-prd', DECOMPOSE: 'decompose',
@@ -857,8 +860,49 @@ function mutatePullRequests(filePath, mutator) {
  * Remove a git worktree, falling back to fs.rmSync if git fails (e.g., locked on Windows).
  * Only removes directories under worktreeRoot to prevent accidental deletion.
  * Tracks persistent failures to avoid retrying locked paths every cleanup cycle.
+ *
+ * On Windows, reserved device-name files (NUL, CON, PRN, AUX, etc.) can appear in
+ * worktree directories when shell redirections run under Git Bash/WSL. These block
+ * git worktree remove, fs.rmSync, and PowerShell Remove-Item. Two mitigations:
+ * 1. _purgeReservedFiles() deletes them via the \\?\ extended path prefix before removal
+ * 2. cmd /c rd /s /q as final fallback handles any remaining reserved names
  */
 const _removeWorktreeFailures = new Map(); // path → { count, lastAttempt }
+
+// Windows reserved device names that cannot be deleted via normal paths
+const _WIN_RESERVED_NAMES = new Set([
+  'CON', 'PRN', 'AUX', 'NUL',
+  'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+  'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
+]);
+
+/**
+ * Recursively purge Windows reserved-name pseudo-files (NUL, CON, PRN, AUX, etc.)
+ * using the \\?\ extended path prefix that bypasses reserved-name interpretation.
+ * Called before normal deletion attempts on Windows to unblock git/fs operations.
+ */
+function _purgeReservedFiles(dirPath) {
+  let entries;
+  try { entries = fs.readdirSync(dirPath, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    try {
+      if (entry.isDirectory()) {
+        _purgeReservedFiles(fullPath);
+      } else {
+        // Match NUL, NUL.txt, con, con.log, etc.
+        const baseName = entry.name.toUpperCase().split('.')[0];
+        if (_WIN_RESERVED_NAMES.has(baseName)) {
+          // \\?\ prefix bypasses Win32 reserved-name interpretation
+          fs.unlinkSync('\\\\?\\' + fullPath);
+        }
+      }
+    } catch {
+      // Best-effort: file may already be gone or inaccessible
+    }
+  }
+}
+
 function removeWorktree(wtPath, gitRoot, worktreeRoot) {
   const resolved = path.resolve(wtPath);
   const resolvedRoot = path.resolve(worktreeRoot) + path.sep;
@@ -870,6 +914,11 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot) {
   const prior = _removeWorktreeFailures.get(resolved);
   if (prior && prior.count >= 3 && Date.now() - prior.lastAttempt < 3600000) return false;
 
+  // Windows: purge reserved-name pseudo-files (NUL, CON, etc.) that block normal deletion
+  if (process.platform === 'win32') {
+    _purgeReservedFiles(resolved);
+  }
+
   try {
     exec(`git worktree remove "${wtPath}" --force`, { cwd: gitRoot, stdio: 'pipe', timeout: 15000, windowsHide: true });
     _removeWorktreeFailures.delete(resolved);
@@ -881,14 +930,17 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot) {
       _removeWorktreeFailures.delete(resolved);
       return true;
     } catch (rmErr) {
-      // Windows EPERM: a process may hold file handles — try rd /s /q as fallback
-      if (process.platform === 'win32' && rmErr.code === 'EPERM') {
+      // Windows: try cmd /c rd /s /q for any error — handles reserved device names,
+      // locked files, and partially-deleted directories (not just EPERM)
+      if (process.platform === 'win32') {
         try {
-          exec(`rd /s /q "${resolved}"`, { stdio: 'pipe', timeout: 15000, windowsHide: true });
+          exec(`cmd /c rd /s /q "${resolved}"`, { stdio: 'pipe', timeout: 15000, windowsHide: true });
           try { exec('git worktree prune', { cwd: gitRoot, stdio: 'pipe', timeout: 10000, windowsHide: true }); } catch {}
           _removeWorktreeFailures.delete(resolved);
           return true;
-        } catch {}
+        } catch (rdErr) {
+          log('warn', `removeWorktree: rd /s /q fallback failed for ${wtPath}: ${rdErr.message}`);
+        }
       }
       const fail = _removeWorktreeFailures.get(resolved) || { count: 0, lastAttempt: 0 };
       fail.count++;
@@ -940,7 +992,7 @@ module.exports = {
   KB_CATEGORIES,
   classifyInboxItem,
   ENGINE_DEFAULTS,
-  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, ESCALATION_POLICY, COMPLETION_FIELDS,
   DEFAULT_AGENT_METRICS,
@@ -963,6 +1015,8 @@ module.exports = {
   killGracefully,
   killImmediate,
   removeWorktree,
+  _purgeReservedFiles, // exported for testing
+  _WIN_RESERVED_NAMES, // exported for testing
   LOCK_STALE_MS,
   flushLogs,
   slugify,

package/package.json

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