@yemi33/minions 0.1.562 → 0.1.563

package/CHANGELOG.md

@@ -1,8 +1,9 @@
 # Changelog
 
-## 0.1.562 (2026-04-08)
+## 0.1.563 (2026-04-08)
 
 ### Fixes
+-  worktree lifecycle — fail on dep merge, fallback rm, cleanup on plan delete
 -  auto-reset CC session on resume failure, add error logging
 
 ## 0.1.561 (2026-04-08)

package/dashboard.js

@@ -621,7 +621,13 @@ Many common English words have specific meanings in the Minions context. **When
 // Hash the system prompt so we can detect changes and invalidate stale sessions
 const _ccPromptHash = require('crypto').createHash('md5').update(CC_STATIC_SYSTEM_PROMPT).digest('hex').slice(0, 8);
 
+let _preambleCache = null;
+let _preambleCacheTs = 0;
+const PREAMBLE_TTL = 10000; // 10s — same as status cache
+
 function buildCCStatePreamble() {
+  const now = Date.now();
+  if (_preambleCache && now - _preambleCacheTs < PREAMBLE_TTL) return _preambleCache;
   // Lightweight snapshot — just enough to orient. Use tools for details.
   const agents = getAgents().map(a => `- ${a.name} (${a.id}): ${a.status}${a.currentTask ? ' — ' + a.currentTask.slice(0, 60) : ''}`).join('\n');
   const projects = PROJECTS.map(p => `- ${p.name}: ${p.localPath}`).join('\n');
@@ -656,7 +662,7 @@ function buildCCStatePreamble() {
     }
   } catch {}
 
-  return `### Agents
+  const result = `### Agents
 ${agents}
 
 ### Active Dispatch
@@ -675,10 +681,13 @@ ${schedSummary}
 ### Pipelines
 ${pipelineSummary}
 
-### Dashboard API (all endpoints)
-${_getApiRoutesSummary()}
+### Dashboard API
+Run \`curl http://localhost:7331/api/routes\` for full endpoint listing.
 
 For details on any of the above, use your tools to read files under \`${MINIONS_DIR}\`.`;
+  _preambleCache = result;
+  _preambleCacheTs = now;
+  return result;
 }
 
 function parseCCActions(text) {
@@ -796,16 +805,18 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   const existing = resolveSession(store, sessionKey);
   let sessionId = existing ? existing.sessionId : null;
 
-  const parts = skipStatePreamble ? [] : [`## Current Minions State (${new Date().toISOString().slice(0, 16)})\n\n${buildCCStatePreamble()}`];
-  if (extraContext) parts.push(extraContext);
-  parts.push(message);
-  const prompt = parts.join('\n\n---\n\n');
+  function buildPrompt({ includePreamble = true } = {}) {
+    const parts = (!skipStatePreamble && includePreamble) ? [`## Current Minions State (${new Date().toISOString().slice(0, 16)})\n\n${buildCCStatePreamble()}`] : [];
+    if (extraContext) parts.push(extraContext);
+    parts.push(message);
+    return parts.join('\n\n---\n\n');
+  }
 
   let result;
 
-  // Attempt 1: resume existing session (skip for single-turn/no-tool calls — nothing to resume)
+  // Attempt 1: resume existing session — skip preamble (session already has context)
   if (sessionId && maxTurns > 1) {
-    result = await llm.callLLM(prompt, '', {
+    result = await llm.callLLM(buildPrompt({ includePreamble: false }), '', {
       timeout, label, model, maxTurns, allowedTools, sessionId,
     });
     llm.trackEngineUsage(label, result.usage);
@@ -838,8 +849,9 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
     }
   }
 
-  // Attempt 2: fresh session
-  result = await llm.callLLM(prompt, CC_STATIC_SYSTEM_PROMPT, {
+  // Attempt 2: fresh session (include preamble for full context)
+  const freshPrompt = buildPrompt();
+  result = await llm.callLLM(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
     timeout, label, model, maxTurns, allowedTools,
   });
   llm.trackEngineUsage(label, result.usage);
@@ -853,7 +865,7 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   if (maxTurns <= 1) return result;
   console.log(`[${label}] Fresh call also failed (code=${result.code}, empty=${!result.text}), retrying once more...`);
   await new Promise(r => setTimeout(r, 2000));
-  result = await llm.callLLM(prompt, CC_STATIC_SYSTEM_PROMPT, {
+  result = await llm.callLLM(freshPrompt, CC_STATIC_SYSTEM_PROMPT, {
     timeout, label, model, maxTurns, allowedTools,
   });
   llm.trackEngineUsage(label, result.usage);
@@ -2427,6 +2439,13 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
         } catch (e) { console.error('plan-to-prd cleanup:', e.message); }
       }
 
+      // Clean up worktrees associated with this plan
+      try {
+        const plan = body.file.endsWith('.json') ? (safeJsonObj(path.join(PRD_DIR, 'archive', body.file)) || safeJsonObj(path.join(PRD_DIR, body.file)) || {}) : {};
+        const { cleanupPlanWorktrees } = require('./engine/lifecycle');
+        cleanupPlanWorktrees(body.file, plan, PROJECTS, getConfig());
+      } catch (e) { console.error('plan worktree cleanup:', e.message); }
+
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, cleanedWorkItems: cleaned, cleanedDispatches: dispatchCleaned });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
@@ -2467,6 +2486,13 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
         } catch { /* optional */ }
       }
 
+      // Clean up worktrees associated with this plan
+      try {
+        const plan = body.file.endsWith('.json') ? (safeJsonObj(archivePath) || {}) : {};
+        const { cleanupPlanWorktrees } = require('./engine/lifecycle');
+        cleanupPlanWorktrees(body.file, plan, PROJECTS, getConfig());
+      } catch (e) { console.error('plan worktree cleanup:', e.message); }
+
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, archived: body.file, archivedSource });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }

package/engine/cleanup.js

@@ -250,12 +250,11 @@ function runCleanup(config, verbose = false) {
             }
           }
 
-          try {
-            exec(`git worktree remove "${entry.wtPath}" --force`, { cwd: root, stdio: 'pipe', timeout: 30000 });
+          if (shared.removeWorktree(entry.wtPath, root, worktreeRoot)) {
             cleaned.worktrees++;
             if (verbose) console.log(`  Removed worktree: ${entry.wtPath}`);
-          } catch (e) {
-            if (verbose) console.log(`  Failed to remove worktree ${entry.wtPath}: ${e.message}`);
+          } else {
+            if (verbose) console.log(`  Failed to remove worktree ${entry.wtPath}`);
           }
         }
       }

package/engine/lifecycle.js

@@ -313,34 +313,40 @@ function archivePlan(planFile, plan, projects, config) {
   } catch (err) { log('warn', `Plan archive scan: ${err.message}`); }
 
   // Clean up ALL worktrees created for this plan's work items (shared-branch + per-item)
+  cleanupPlanWorktrees(planFile, plan, projects, config);
+}
+
+/**
+ * Clean up worktrees associated with a plan's work items and PRs.
+ * Called from archivePlan() and also from plan delete/archive handlers.
+ */
+function cleanupPlanWorktrees(planFile, plan, projects, config) {
   try {
     const branchSlugs = new Set();
-    if (plan.feature_branch) branchSlugs.add(shared.sanitizeBranch(plan.feature_branch).toLowerCase());
+    if (plan?.feature_branch) branchSlugs.add(shared.sanitizeBranch(plan.feature_branch).toLowerCase());
 
-    // Collect work items for this plan
     const allWorkItems = queries.getWorkItems(config);
     const planItems = allWorkItems.filter(w => w.sourcePlan === planFile);
-    const doneItems = planItems.filter(w => DONE_STATUSES.has(w.status));
-
-    for (const w of doneItems) {
+    for (const w of planItems) {
       if (w.branch) branchSlugs.add(shared.sanitizeBranch(w.branch).toLowerCase());
       if (w.id) branchSlugs.add(w.id.toLowerCase());
     }
 
-    // Collect PR branches
     for (const p of projects) {
       try {
         const prs = safeJson(shared.projectPrPath(p)) || [];
         const prLinks = getPrLinks();
         for (const pr of prs) {
           const linkedId = prLinks[pr.id];
-          if (linkedId && doneItems.find(w => w.id === linkedId) && pr.branch) {
+          if (linkedId && planItems.find(w => w.id === linkedId) && pr.branch) {
             branchSlugs.add(shared.sanitizeBranch(pr.branch).toLowerCase());
           }
         }
       } catch { /* optional */ }
     }
 
+    if (branchSlugs.size === 0) return;
+
     let cleanedWt = 0;
     for (const p of projects) {
       const root = path.resolve(p.localPath);
@@ -352,15 +358,12 @@ function archivePlan(planFile, plan, projects, config) {
         const matches = [...branchSlugs].some(slug => dirLower.includes(slug));
         if (matches) {
           const wtPath = path.join(wtRoot, dir);
-          try {
-            execSilent(`git worktree remove "${wtPath}" --force`, { cwd: root, stdio: 'pipe', timeout: 15000 });
-            cleanedWt++;
-          } catch (err) { log('warn', `Failed to remove worktree ${dir}: ${err.message}`); }
+          if (shared.removeWorktree(wtPath, root, wtRoot)) cleanedWt++;
         }
       }
     }
-    if (cleanedWt > 0) log('info', `Archive: cleaned ${cleanedWt} worktree(s)`);
-  } catch (err) { log('warn', `Worktree cleanup: ${err.message}`); }
+    if (cleanedWt > 0) log('info', `Plan worktree cleanup: removed ${cleanedWt} worktree(s)`);
+  } catch (err) { log('warn', `Plan worktree cleanup: ${err.message}`); }
 }
 
 // ─── Plan → PRD Chaining ─────────────────────────────────────────────────────
@@ -1245,11 +1248,8 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         if (!otherActive) {
           for (const dir of dirs) {
             const wtPath = path.join(worktreeRoot, dir);
-            try {
-              shared.exec(`git worktree remove "${wtPath}" --force`, { cwd: rootDir, stdio: 'pipe', timeout: 15000, windowsHide: true });
+            if (shared.removeWorktree(wtPath, rootDir, worktreeRoot)) {
               log('info', `Post-completion: removed worktree ${dir}`);
-            } catch (err) {
-              log('warn', `Post-completion: failed to remove worktree ${dir}: ${err.message}`);
             }
           }
         }
@@ -1392,6 +1392,7 @@ function syncPrdFromPrs(config) {
 module.exports = {
   checkPlanCompletion,
   archivePlan,
+  cleanupPlanWorktrees,
   updateWorkItemStatus,
   syncPrdItemStatus,
   syncPrsFromOutput,

package/engine/shared.js

@@ -394,14 +394,17 @@ function resolveMainBranch(rootDir, configuredBranch) {
 
 // ── Environment ─────────────────────────────────────────────────────────────
 
+let _cleanEnvCache = null;
 function cleanChildEnv() {
+  if (_cleanEnvCache) return { ..._cleanEnvCache };
   const env = { ...process.env };
   delete env.CLAUDECODE;
   delete env.CLAUDE_CODE_ENTRYPOINT;
   for (const key of Object.keys(env)) {
     if (key.startsWith('CLAUDE_CODE') || key.startsWith('CLAUDECODE_')) delete env[key];
   }
-  return env;
+  _cleanEnvCache = env;
+  return { ..._cleanEnvCache };
 }
 
 // Environment for git commands — prevents credential manager from opening browser
@@ -799,6 +802,33 @@ function mutatePullRequests(filePath, mutator) {
   }, { defaultValue: [] });
 }
 
+/**
+ * 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.
+ */
+function removeWorktree(wtPath, gitRoot, worktreeRoot) {
+  const resolved = path.resolve(wtPath);
+  const resolvedRoot = path.resolve(worktreeRoot);
+  if (!resolved.startsWith(resolvedRoot)) {
+    log('warn', `removeWorktree: refusing to remove ${wtPath} — not under ${worktreeRoot}`);
+    return false;
+  }
+  try {
+    exec(`git worktree remove "${wtPath}" --force`, { cwd: gitRoot, stdio: 'pipe', timeout: 15000, windowsHide: true });
+    return true;
+  } catch (gitErr) {
+    try {
+      fs.rmSync(resolved, { recursive: true, force: true });
+      // Also prune the stale worktree entry from git metadata
+      try { exec('git worktree prune', { cwd: gitRoot, stdio: 'pipe', timeout: 10000, windowsHide: true }); } catch {}
+      return true;
+    } catch (rmErr) {
+      log('warn', `removeWorktree: both git and rm failed for ${wtPath}: ${rmErr.message}`);
+      return false;
+    }
+  }
+}
+
 module.exports = {
   MINIONS_DIR,
   PR_LINKS_PATH,
@@ -852,6 +882,7 @@ module.exports = {
   sleepMs,
   killGracefully,
   killImmediate,
+  removeWorktree,
   LOCK_STALE_MS,
   flushLogs,
   _logBuffer, // exported for testing

package/engine.js

@@ -412,10 +412,12 @@ async function spawnAgent(dispatchItem, config) {
       if (depIds.length > 0) {
         try {
           const depBranches = resolveDependencyBranches(depIds, meta?.item?.sourcePlan, project, config);
+          let depMergeFailed = false;
           for (const { branch: depBranch, prId } of depBranches) {
             // Skip refs already known to be missing this tick (avoids repeated 30s ETIMEDOUT)
             if (_failedRefCache.has(depBranch)) {
               log('warn', `Skipping dependency ${depBranch} — already failed to fetch this tick`);
+              depMergeFailed = true;
               continue;
             }
             try {
@@ -425,8 +427,13 @@ async function spawnAgent(dispatchItem, config) {
             } catch (mergeErr) {
               _failedRefCache.add(depBranch);
               log('warn', `Failed to merge dependency ${depBranch} into ${branchName}: ${mergeErr.message}`);
+              depMergeFailed = true;
             }
           }
+          if (depMergeFailed) {
+            completeDispatch(id, DISPATCH_RESULT.ERROR, `Dependency merge failed — will retry next tick`);
+            return;
+          }
         } catch (e) {
           log('warn', `Could not resolve dependency branches for ${branchName}: ${e.message}`);
         }

package/package.json

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