@yemi33/minions 0.1.2285 → 0.1.2286

package/dashboard.js

@@ -8022,77 +8022,103 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
+  // Shared by pause + reject (and any future PRD-stop handler): stop a PRD's
+  // materialized work. Kills any active dispatch for the PRD's items, transitions
+  // every non-completed WI sourced from the PRD to `targetStatus`, AND cancels the
+  // still-running plan-to-prd regeneration WI for the PRD's source plan so it can't
+  // silently rebuild the PRD we just paused/rejected. Returns the count of WIs
+  // transitioned. Lockless reads → cleanDispatchEntries (atomic kill + remove) →
+  // mutateWorkItems, mirroring the original pause flow. (RC3 — reject had no
+  // cleanup; pause never stopped regeneration.)
+  function stopPlanMaterializedWork(prdFile, prdSourcePlan, opts) {
+    const targetStatus = opts.targetStatus;
+    const wiPaths = [path.join(MINIONS_DIR, 'work-items.json')];
+    for (const proj of PROJECTS) wiPaths.push(shared.projectWorkItemsPath(proj));
+
+    // Step 1: find dispatched item ids (read-only, no lock).
+    const dispatchedItemIds = new Set();
+    for (const wiPath of wiPaths) {
+      try {
+        for (const w of safeJsonArr(wiPath)) {
+          if (w.sourcePlan !== prdFile) continue;
+          if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
+          if (w.status === WI_STATUS.DISPATCHED && w.id) dispatchedItemIds.add(w.id);
+        }
+      } catch { /* file may not exist */ }
+    }
+
+    // Step 2: kill active dispatches via the canonical primitive (resolves PIDs from
+    // the pid sidecar, kills outside the dispatch lock, removes via mutateDispatch).
+    if (dispatchedItemIds.size > 0) {
+      cleanDispatchEntries((d) => {
+        const itemId = d.meta?.item?.id;
+        if (itemId && dispatchedItemIds.has(itemId)) return true;
+        if (d.meta?.dispatchKey && [...dispatchedItemIds].some(id => d.meta.dispatchKey.includes(id))) return true;
+        return false;
+      });
+    }
+
+    // Step 3: transition WIs per path (each lock held briefly, no nesting).
+    let affected = 0;
+    for (const wiPath of wiPaths) {
+      try {
+        mutateWorkItems(wiPath, items => {
+          for (const w of items) {
+            if (w.sourcePlan !== prdFile) continue;
+            if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
+            if (w.status !== targetStatus) affected++;
+            w.status = targetStatus;
+            if (opts.stampField) w[opts.stampField] = opts.stampValue;
+            delete w._resumedAt;
+            delete w.dispatched_at;
+            delete w.dispatched_to;
+            delete w.failReason;
+            delete w.failedAt;
+          }
+        });
+      } catch (e) { console.error('stopPlanMaterializedWork work items:', e.message); }
+    }
+
+    // Step 4: cancel the still-running plan-to-prd regeneration WI for this source
+    // plan — otherwise a pending/dispatched plan-to-prd run rebuilds the PRD we just
+    // stopped. (delete handles the DONE plan-to-prd WI separately to revert to draft.)
+    if (prdSourcePlan) {
+      try {
+        const centralPath = path.join(MINIONS_DIR, 'work-items.json');
+        mutateWorkItems(centralPath, items => {
+          for (const w of items) {
+            if (w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === prdSourcePlan &&
+                !DONE_STATUSES.has(w.status) && w.status !== WI_STATUS.CANCELLED) {
+              w.status = WI_STATUS.CANCELLED;
+              w._cancelledBy = opts.stampValue || 'prd-stopped';
+            }
+          }
+        });
+      } catch (e) { console.error('stopPlanMaterializedWork plan-to-prd:', e.message); }
+    }
+    return affected;
+  }
+
   async function handlePlansPause(req, res) {
     try {
       const body = await readBody(req);
       if (!body.file) return jsonReply(res, 400, { error: 'file required' });
       if (!body.file.endsWith('.json')) return jsonReply(res, 400, { error: 'expected a PRD JSON filename (got `' + body.file + '`). Pass prd/<plan>.json, not the source plans/<plan>.md.' });
       const planPath = resolvePlanPath(body.file);
-      mutateJsonFileLocked(planPath, (plan) => {
+      let prdSourcePlan = null;
+      const updated = mutateJsonFileLocked(planPath, (plan) => {
         if (!plan || Array.isArray(plan) || typeof plan !== 'object') plan = {};
         plan.status = 'paused';
         plan.pausedAt = new Date().toISOString();
         return plan;
       }, { defaultValue: {} });
+      prdSourcePlan = updated?.source_plan || null;
 
-      // Propagate pause to materialized work items across all projects:
-      // kill any active agent process and reset non-completed items to paused.
-      // Pattern: lockless reads → cleanDispatchEntries (atomic kill + remove) → mutateWorkItems.
-      const wiPaths = [path.join(MINIONS_DIR, 'work-items.json')];
-      for (const proj of PROJECTS) {
-        wiPaths.push(shared.projectWorkItemsPath(proj));
-      }
-      const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
-
-      // Step 1: Read work items (read-only, no lock) to find plan items that are dispatched.
-      const dispatchedItemIds = new Set();
-      for (const wiPath of wiPaths) {
-        try {
-          const items = safeJsonArr(wiPath);
-          for (const w of items) {
-            if (w.sourcePlan !== body.file) continue;
-            if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
-            if (w.status === WI_STATUS.DISPATCHED && w.id) dispatchedItemIds.add(w.id);
-          }
-        } catch { /* file may not exist */ }
-      }
-
-      // Step 2: Route PID resolution + kill + dispatch removal through the canonical primitive.
-      // cleanDispatchEntries resolves PIDs from engine/tmp/dispatch-<id>-*/pid-<id>.pid
-      // (see shared.findDispatchPidFile), kills outside the dispatch lock, and removes the
-      // entries via mutateDispatch (SQL + JSON mirror in one atomic write).
-      // The defunct per-agent status sidecar reads/writes that used to live here are gone
-      // (engine/queries.js documents that file no longer exists).
-      if (dispatchedItemIds.size > 0) {
-        const matchFn = (d) => {
-          const itemId = d.meta?.item?.id;
-          if (itemId && dispatchedItemIds.has(itemId)) return true;
-          if (d.meta?.dispatchKey && [...dispatchedItemIds].some(id => d.meta.dispatchKey.includes(id))) return true;
-          return false;
-        };
-        cleanDispatchEntries(matchFn);
-      }
-
-      // Step 3: Mutate work-items.json per path — pause items (each lock held briefly, no nesting).
-      let reset = 0;
-      for (const wiPath of wiPaths) {
-        try {
-          mutateWorkItems(wiPath, items => {
-            for (const w of items) {
-              if (w.sourcePlan !== body.file) continue;
-              if (w.completedAt || DONE_STATUSES.has(w.status)) continue;
-              if (w.status !== WI_STATUS.PAUSED) reset++;
-              w.status = WI_STATUS.PAUSED;
-              w._pausedBy = 'prd-pause';
-              delete w._resumedAt;
-              delete w.dispatched_at;
-              delete w.dispatched_to;
-              delete w.failReason;
-              delete w.failedAt;
-            }
-          });
-        } catch (e) { console.error('reset work items:', e.message); }
-      }
+      // Propagate pause to materialized work items across all projects + cancel the
+      // plan-to-prd regeneration WI so a paused PRD can't be silently rebuilt.
+      const reset = stopPlanMaterializedWork(body.file, prdSourcePlan, {
+        targetStatus: WI_STATUS.PAUSED, stampField: '_pausedBy', stampValue: 'prd-pause',
+      });
 
       invalidateStatusCache();
       invalidatePlansCache();
@@ -8149,8 +8175,17 @@ const server = http.createServer(async (req, res) => {
         return data;
       }, { defaultValue: {} });
 
+      // RC3: reject used to flip only the PRD status — its materialized work items
+      // kept dispatching and any active agent kept running, and a pending plan-to-prd
+      // run could rebuild the PRD. Reject is terminal, so cancel the materialized WIs,
+      // kill active dispatches, and cancel the plan-to-prd regeneration WI.
+      const cancelled = stopPlanMaterializedWork(body.file, plan?.source_plan || null, {
+        targetStatus: WI_STATUS.CANCELLED, stampField: '_cancelledBy', stampValue: 'prd-rejected',
+      });
+
+      invalidateStatusCache();
       invalidatePlansCache();
-      return jsonReply(res, 200, { ok: true, status: 'rejected' });
+      return jsonReply(res, 200, { ok: true, status: 'rejected', cancelledWorkItems: cancelled });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 

package/package.json

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