@yemi33/minions 0.1.2216 → 0.1.2217

package/engine/cli.js

@@ -1255,7 +1255,10 @@ const commands = {
     }
     const control = getControl();
     if (control.pid && control.pid !== process.pid) {
-      try { process.kill(control.pid); } catch { /* process may be dead */ }
+      // killGracefully so the engine's SIGTERM graceful-shutdown handler runs
+      // and recurses into the child tree (bare process.kill defaults to a
+      // non-recursing SIGTERM that is Windows-broken — CLAUDE.md Footgun #4).
+      shared.killGracefully({ pid: control.pid });
     }
     mutateControl(() => ({ state: 'stopped', stopped_at: e.ts() }));
     e.log('info', 'Engine stopped');
@@ -1793,7 +1796,10 @@ const commands = {
       let pidNum = NaN;
       try { pidNum = shared.validatePid(raw); } catch { /* invalid — skip */ }
       if (pidNum > 0) {
-        try { process.kill(pidNum); console.log(`Killed process ${pidNum} (${fileName})`); }
+        // killImmediate force-kills the whole process tree (bare process.kill
+        // defaults to a non-recursing SIGTERM that is Windows-broken and
+        // leaks child processes — CLAUDE.md Footgun #4).
+        try { shared.killImmediate({ pid: pidNum }); console.log(`Killed process ${pidNum} (${fileName})`); }
         catch { console.log(`Process ${pidNum} already dead`); }
       } else {
         console.log(`Skipping ${fileName}: invalid or empty PID`);

package/engine/consolidation.js

@@ -541,7 +541,7 @@ function reconcileAndAppendToAgentMemory(item, knownAgents, config) {
         try { safeWrite(memPath + '.bak', beforeLock); }
         catch (err) { log('warn', `agent-memory reconcile: backup write failed for ${agent}: ${err.message}`); }
 
-        const next = pruneAgentMemoryToBudget(updated + entry, agent);
+        const next = pruneAgentMemoryToBudget(updated + entry, agent, _pruneOptsFromConfig(config));
         safeWrite(memPath, next);
         reconciled = true;
         const skippedCount = skipped.length;

package/engine/lifecycle.js

@@ -469,7 +469,7 @@ function archivePlan(planFile, plan, projects, config) {
       const mdFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md'));
       for (const md of mdFiles) {
         const mdContent = shared.safeRead(path.join(PLANS_DIR, md)) || '';
-        if (mdContent.includes(projectName) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
+        if ((projectName && mdContent.includes(projectName)) || mdContent.includes(plan.plan_summary?.slice(0, 40) || '___nomatch___')) {
           try {
             const mdDest = shared.moveFileNoClobber(path.join(PLANS_DIR, md), planArchiveDir, md);
             log('info', `Archived source plan: plans/archive/${path.basename(mdDest)}`);

package/engine/pipeline.js

@@ -126,6 +126,24 @@ function updateRunStage(pipelineId, runId, stageId, updates) {
   });
 }
 
+// Like updateRunStage, but creates the stage entry when the run never seeded it.
+// startRun only seeds top-level `pipeline.stages` ids; nested parallel sub-stages
+// live under `stage.stages`, so the run's `stages` map has no slot for them until
+// the parallel executor persists one. updateRunStage no-ops on a missing entry, so
+// the parallel path needs this upsert to make sub-stage state survive a disk
+// round-trip (without it the cross-tick PARALLEL completion check reads each sub
+// id as undefined forever and the parent wedges in RUNNING — P-9c1a4e7b).
+function upsertRunStage(pipelineId, runId, stageId, state) {
+  mutatePipelineRuns((data) => {
+    const runs = data[pipelineId] || [];
+    const run = runs.find(r => r.runId === runId);
+    if (!run) return data;
+    if (!run.stages || typeof run.stages !== 'object') run.stages = {};
+    run.stages[stageId] = { ...(run.stages[stageId] || {}), ...state };
+    return data;
+  });
+}
+
 function completeRun(pipelineId, runId, status) {
   // Stages whose status is in this set are considered "terminal" and must not
   // be touched by the run-close sweep. Anything else (RUNNING, PENDING,
@@ -829,12 +847,17 @@ function executeConditionStage(stage, stageState, run, pipeline, config) {
 
 async function executeParallelStage(stage, stageState, run, pipeline, config) {
   const subStages = stage.stages || [];
-  const subResults = {};
   for (const sub of subStages) {
     if (!run.stages[sub.id] || run.stages[sub.id].status === PIPELINE_STATUS.PENDING) {
       const result = await executeStage(sub, run, pipeline, config);
-      subResults[sub.id] = result;
-      run.stages[sub.id] = { ...run.stages[sub.id] || {}, ...result, startedAt: ts() };
+      const subState = { ...(run.stages[sub.id] || {}), ...result, startedAt: ts() };
+      run.stages[sub.id] = subState;
+      // Persist sub-stage state to disk. getActiveRun re-reads the run fresh from
+      // disk every tick, so a sub-stage mutated only on the in-memory run object is
+      // invisible to the next tick's PARALLEL completion check — the parent then
+      // wedges in RUNNING forever. updateRunStage only mutates an existing entry and
+      // sub-stage ids are never seeded by startRun, so upsert to seed + persist.
+      upsertRunStage(pipeline.id, run.runId, sub.id, subState);
     }
   }
   // Parent is running until all subs complete
@@ -966,9 +989,29 @@ function isStageComplete(stage, stageState, run, config) {
       return stageState.status === PIPELINE_STATUS.COMPLETED;
     case STAGE_TYPE.PARALLEL: {
       const subIds = artifacts.subStages || [];
+      if (subIds.length === 0) return true;
+      const subDefs = stage.stages || [];
       return subIds.every(id => {
-        const sub = run.stages[id];
-        return sub && (sub.status === PIPELINE_STATUS.COMPLETED || sub.status === PIPELINE_STATUS.FAILED);
+        const subState = run.stages[id];
+        if (!subState) return false; // sub-stage state not yet persisted — not complete
+        if (subState.status === PIPELINE_STATUS.COMPLETED || subState.status === PIPELINE_STATUS.FAILED) return true;
+        // Async sub-stages (task/meeting/plan/…) persist as RUNNING; their underlying
+        // work (work items, meetings, …) finishes on a later tick. The driver never
+        // re-executes a RUNNING parallel parent, so this completion check is the only
+        // place that advances them: evaluate each sub through its own completion logic
+        // and promote its persisted status so the run closes cleanly (no false
+        // non-terminal anomaly) and the dashboard reflects reality (P-9c1a4e7b).
+        const subDef = subDefs.find(s => s.id === id);
+        if (!subDef) return false;
+        if (isStageComplete(subDef, subState, run, config)) {
+          subState.status = PIPELINE_STATUS.COMPLETED;
+          subState.completedAt = subState.completedAt || ts();
+          updateRunStage(run.pipelineId, run.runId, id, {
+            status: PIPELINE_STATUS.COMPLETED, completedAt: subState.completedAt,
+          });
+          return true;
+        }
+        return false;
       });
     }
     default:

package/package.json

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