@yemi33/minions 0.1.2305 → 0.1.2307

package/engine/lifecycle.js

@@ -4981,6 +4981,77 @@ function pickReReviewAgentHints(config, opts = {}) {
   return out;
 }
 
+/**
+ * P-mqyp0009y025z6a7 — Goal invalidation.
+ *
+ * When a completing WI's report carries a non-empty `invalidates: [wi-id, …]`
+ * array, cancel each listed WI that is currently pending or queued.
+ *
+ * Rules:
+ *   - Only cancels WIs in status 'pending' or 'queued'.
+ *   - WIs in any other status (dispatched, done, failed, cancelled, …) are
+ *     skipped with a warning log — they are not cancelled.
+ *   - Missing WI IDs produce a warning but do not throw.
+ *   - Uses mutateWorkItems (SQL-canonical) so the dashboard reflects the change.
+ */
+function applyGoalInvalidation(sourceWiId, invalidates, config) {
+  if (!Array.isArray(invalidates) || invalidates.length === 0) return;
+
+  const wiPaths = getWorkItemPaths(config);
+  const cancellableStatuses = new Set([WI_STATUS.PENDING, WI_STATUS.QUEUED]);
+  const cancellationReason = `invalidated-by:${sourceWiId}`;
+
+  for (const targetId of invalidates) {
+    if (!targetId || typeof targetId !== 'string') continue;
+
+    // Find which file contains the WI.
+    let foundPath = null;
+    let foundStatus = null;
+    for (const wiPath of wiPaths) {
+      try {
+        const items = readOptionalJsonStrict(wiPath, 'work-items', Array.isArray) || [];
+        const item = items.find(i => i && i.id === targetId);
+        if (item) {
+          foundPath = wiPath;
+          foundStatus = item.status;
+          break;
+        }
+      } catch { /* best-effort scan */ }
+    }
+
+    if (!foundPath) {
+      log('warn', `Goal invalidation: WI ${targetId} listed in invalidates[] by ${sourceWiId} not found — skipping`);
+      continue;
+    }
+
+    if (!cancellableStatuses.has(foundStatus)) {
+      log('warn', `Goal invalidation: WI ${targetId} is in status '${foundStatus}' — only pending/queued WIs are cancelled; skipping`);
+      continue;
+    }
+
+    // Cancel the WI via mutateWorkItems so the SQL store + state event are updated.
+    try {
+      mutateWorkItems(foundPath, (items) => {
+        if (!Array.isArray(items)) return items;
+        const wi = items.find(i => i && i.id === targetId);
+        if (!wi) return items;
+        // Re-check status inside the lock to avoid TOCTOU races.
+        if (!cancellableStatuses.has(wi.status)) {
+          log('warn', `Goal invalidation: WI ${targetId} changed to '${wi.status}' before cancel lock acquired — skipping`);
+          return items;
+        }
+        wi.status = WI_STATUS.CANCELLED;
+        wi.cancellationReason = cancellationReason;
+        wi.cancelledAt = ts();
+        log('info', `Goal invalidation: cancelled WI ${targetId} (${cancellationReason})`);
+        return items;
+      });
+    } catch (err) {
+      log('warn', `Goal invalidation: failed to cancel WI ${targetId}: ${err.message}`);
+    }
+  }
+}
+
 async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config, opts) {
 
   const detectPhantom = !!(opts && opts.detectPhantom);
@@ -5459,6 +5530,11 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     promoteCompletionArtifacts(meta, agentId, dispatchItem.id, structuredCompletion, { resultSummary });
     // M003 — auto-dispatch a live-validation WI when a coding WI completes.
     try { autoDispatchLiveValidationWi(meta, config); } catch (err) { log('warn', `autoDispatchLiveValidationWi: ${err.message}`); }
+    // P-mqyp0009y025z6a7 — goal invalidation: cancel any pending/queued WIs
+    // listed in the completion report's optional `invalidates[]` field.
+    if (structuredCompletion && Array.isArray(structuredCompletion.invalidates) && structuredCompletion.invalidates.length > 0) {
+      try { applyGoalInvalidation(meta.item.id, structuredCompletion.invalidates, config); } catch (err) { log('warn', `applyGoalInvalidation: ${err.message}`); }
+    }
   }
   // Failure retry is handled by completeDispatch in dispatch.js — not duplicated here.
   // Only clear _decomposing flag on failure so decompose items don't get permanently stuck.
@@ -5927,12 +6003,83 @@ function syncPrdFromPrs(config) {
         if (sourcePlan) stampPrdItemPrUrl(itemId, sourcePlan, pr.url);
       }
     }
+    // Advance PRD top-level status when all items are done and all linked PRs merged
+    advancePrdStatusOnAllItemsDone(config);
   } catch (err) {
     // Non-fatal — log and continue
     try { log('warn', `syncPrdFromPrs error: ${err?.message || err}`); } catch { /* engine not available */ }
   }
 }
 
+// ─── PRD Top-Level Status Auto-Completion (P-d7e8f9a1) ───────────────────────
+// Runs at the end of syncPrdFromPrs (same PR-poll cadence). Advances PRD
+// status to 'completed' when every missing_features item satisfies both:
+//   1. A work item with that id exists in done status (DONE_STATUSES)
+//   2. The linked PR (WI._pr) is merged — or the item has no linked PR
+//      (non-code items that never raised a PR)
+// Paused, rejected, awaiting-approval, completed, and archived PRDs are
+// skipped via _PRD_FROZEN_STATUSES. The locked write is idempotent.
+function advancePrdStatusOnAllItemsDone(config) {
+  if (!fs.existsSync(PRD_DIR)) return;
+  let prdFiles;
+  try { prdFiles = fs.readdirSync(PRD_DIR).filter(f => f.endsWith('.json')); } catch { return; }
+  if (!prdFiles.length) return;
+
+  const allWorkItems = queries.getWorkItems(config);
+  if (!allWorkItems.length) return;
+
+  // Index done WIs by id for O(1) lookup
+  const doneWiById = new Map();
+  for (const wi of allWorkItems) {
+    if (wi.id && DONE_STATUSES.has(wi.status)) doneWiById.set(wi.id, wi);
+  }
+  if (!doneWiById.size) return;
+
+  // Collect all PRs by id across all projects for merged-status lookup
+  const prById = new Map();
+  for (const project of shared.getProjects(config)) {
+    for (const pr of safeJsonArr(shared.projectPrPath(project))) {
+      if (pr?.id) prById.set(pr.id, pr);
+    }
+  }
+
+  for (const file of prdFiles) {
+    try {
+      const fpath = path.join(PRD_DIR, file);
+      const plan = safeJsonNoRestore(fpath);
+      if (!plan?.missing_features?.length) continue;
+      // Skip frozen PRDs — paused/rejected/awaiting-approval/completed/archived
+      if (_PRD_FROZEN_STATUSES.has(plan.status)) continue;
+
+      const allDone = plan.missing_features.every(feature => {
+        const wi = doneWiById.get(feature.id);
+        if (!wi) return false; // no done WI for this feature
+        // If the WI has a linked PR, it must be merged
+        if (wi._pr) {
+          const pr = prById.get(wi._pr);
+          if (!pr) return true; // PR no longer in tracker (swept after merge) — allow
+          return pr.status === PR_STATUS.MERGED;
+        }
+        // No linked PR — non-code item or PR not tracked; done WI is sufficient
+        return true;
+      });
+
+      if (!allDone) continue;
+
+      mutateJsonFileLocked(fpath, (data) => {
+        // Re-check under lock — another writer may have frozen this PRD
+        if (_PRD_FROZEN_STATUSES.has(data.status)) return data;
+        data.status = PLAN_STATUS.COMPLETED;
+        if (!data.completedAt) data.completedAt = ts();
+        return data;
+      }, { skipWriteIfUnchanged: true });
+      log('info', `PRD auto-advance: ${file} → completed (all items done, all linked PRs merged)`);
+    } catch (err) {
+      log('warn', `advancePrdStatusOnAllItemsDone error for ${file}: ${err?.message || err}`);
+    }
+  }
+}
+
 // ─── Persist verify/E2E aggregate PRs onto the PRD JSON (W-mqps9jlb) ──────────
 // The PRD view's "E2E Aggregate PRs" section (dashboard/js/render-prd.js#
 // renderE2eSection) sources its PRs from the LIVE tracker (pull-requests.json).
@@ -6161,18 +6308,34 @@ function diagnoseEmptyOutput(failureClass, code, elapsedMs) {
   return `[empty-output: process exited in ${elapsedMs}ms \u2014 possible causes: machine sleep, network unavailability, auth failure]`;
 }
 
-// W-mqba5ulq000nd255 — Reconciliation sweep: delete PR records flagged with
-// `_invalidProjectScope: { reason: "pr_scope_mismatch" }` IFF a sibling
-// record for the same canonical pr.id exists in another project whose scope
-// matches the PR URL (i.e. the correctly-scoped project owns the canonical
-// record). Sibling-less mismatches are preserved as tracking. Runs once per
-// tick from engine.js after the ADO/GitHub reconcile polls finish.
+// W-mqba5ulq000nd255 / W-mr2cqq12000b04f8 — Reconciliation sweep with two
+// defenses against mis-scoped `_invalidProjectScope: { reason: "pr_scope_mismatch" }`
+// records:
+//
+//  1. PRUNE — a sibling record for the same canonical pr.id already exists in
+//     the correctly-scoped project (e.g. a fresh dispatch there re-synced it).
+//     The mis-scoped duplicate is deleted; the sibling is the surviving record.
 //
-// Returns { pruned, scanned } so the engine tick can log a summary line.
+//  2. RELOCATE — no sibling exists yet, but a project IS configured whose
+//     scope matches the PR's real repo (e.g. work dispatched under project
+//     "minions-opg" opened a PR against `yemi33/minions`, and a "minions"
+//     project mapping to that repo is configured). Without this, the record
+//     would sit mis-scoped forever — the correct project's tracker (read by
+//     repo-scoped schedules such as daily-merge-approved-minions-prs) would
+//     never see it. The record is moved: upserted into the correct project's
+//     file (which clears `_invalidProjectScope` since it's now correctly
+//     scoped) and removed from the mis-scoped project's file.
+//
+// When no configured project matches the PR's real scope at all, the record
+// is left in place with its `_invalidProjectScope` stamp so operators can
+// still find it (still surfaced via GET /api/pull-requests aggregation).
+// Runs once per tick from engine.js after the ADO/GitHub reconcile polls finish.
+//
+// Returns { pruned, relocated, scanned } so the engine tick can log a summary line.
 function pruneScopeMismatchDuplicatePrs(config) {
   config = config || getConfig();
   const projects = shared.getProjects(config) || [];
-  if (projects.length === 0) return { pruned: 0, scanned: 0 };
+  if (projects.length === 0) return { pruned: 0, relocated: 0, scanned: 0 };
 
   // Map project name -> canonical scope so we can find which project IS the
   // correctly-scoped owner for a given mismatch record.
@@ -6197,13 +6360,17 @@ function pruneScopeMismatchDuplicatePrs(config) {
   }
 
   // Build per-project delete sets keyed by id, so we batch one mutation per
-  // affected project file.
-  const deletesByProject = new Map(); // projectName -> Set(prId)
+  // affected project file. Track prune-deletes and relocate-deletes in
+  // separate id sets (per project) so `pruned` vs `relocated` counts stay
+  // accurate even though both end up removing rows from the same file.
+  const pruneDeletesByProject = new Map(); // projectName -> Set(prId)
+  const relocateDeletesByProject = new Map(); // projectName -> Set(prId)
+  // Records to insert into their correctly-scoped project's file.
+  const relocationsByTargetProject = new Map(); // projectName -> [{ rec, owningScope }]
   let scanned = 0;
   let pruned = 0;
 
   for (const records of byId.values()) {
-    if (records.length < 2) continue;
     for (const rec of records) {
       scanned++;
       if (!rec._invalidProjectScope || rec._invalidProjectScope.reason !== 'pr_scope_mismatch') continue;
@@ -6211,32 +6378,79 @@ function pruneScopeMismatchDuplicatePrs(config) {
       if (!correctScope) continue;
       const correctProject = projectByScope.get(correctScope);
       if (!correctProject) continue; // no configured project owns the URL — keep as tracking
-      // Sibling check: is there a record under the correct scope for the same id?
-      const sibling = records.find(r => r !== rec && r._scope === correctProject.name);
-      if (!sibling) continue;
-      // Safe to prune.
       const owningScope = rec._scope;
       if (!owningScope || owningScope === 'central') continue;
-      if (!deletesByProject.has(owningScope)) deletesByProject.set(owningScope, new Set());
-      deletesByProject.get(owningScope).add(rec.id);
+      if (owningScope === correctProject.name) continue; // already correctly scoped
+      // Sibling check: is there a record under the correct scope for the same id?
+      const sibling = records.find(r => r !== rec && r._scope === correctProject.name);
+      if (sibling) {
+        // Safe to prune — the sibling already owns the canonical record.
+        if (!pruneDeletesByProject.has(owningScope)) pruneDeletesByProject.set(owningScope, new Set());
+        pruneDeletesByProject.get(owningScope).add(rec.id);
+      } else {
+        // No sibling anywhere: relocate the record into the correctly-scoped
+        // project instead of leaving it stuck mis-scoped indefinitely.
+        if (!relocationsByTargetProject.has(correctProject.name)) relocationsByTargetProject.set(correctProject.name, []);
+        relocationsByTargetProject.get(correctProject.name).push({ rec, owningScope });
+      }
     }
   }
 
-  if (deletesByProject.size === 0) return { pruned: 0, scanned };
+  // Relocate first (insert into target), only marking the source record for
+  // deletion once the insert into the correct project succeeds — this avoids
+  // losing a record if the insert throws mid-way.
+  let relocated = 0;
+  for (const [targetProjectName, entries] of relocationsByTargetProject) {
+    const targetProject = projects.find(p => p.name === targetProjectName);
+    if (!targetProject) continue;
+    const targetPrPath = projectPrPath(targetProject);
+    for (const { rec, owningScope } of entries) {
+      const entry = { ...rec };
+      delete entry._scope;
+      delete entry._invalidProjectScope;
+      delete entry.project; // let upsertPullRequestRecord backfill from targetProject
+      try {
+        const result = shared.upsertPullRequestRecord(targetPrPath, entry, {
+          project: targetProject,
+          itemIds: Array.isArray(rec.prdItems) ? rec.prdItems : null,
+        });
+        if (result.created || result.linked) {
+          relocated++;
+          if (!relocateDeletesByProject.has(owningScope)) relocateDeletesByProject.set(owningScope, new Set());
+          relocateDeletesByProject.get(owningScope).add(rec.id);
+          log('info', `[pull-requests] relocated mis-scoped PR ${rec.id} from project=${owningScope} to correctly-scoped project=${targetProjectName}`);
+        }
+      } catch (err) {
+        log('warn', `pruneScopeMismatchDuplicatePrs: failed to relocate ${rec.id} to ${targetProjectName}: ${err?.message || err}`);
+      }
+    }
+  }
+
+  // Merge prune + relocate delete sets per project so each file is mutated once.
+  const deletesByProject = new Map();
+  for (const [projectName, ids] of pruneDeletesByProject) {
+    deletesByProject.set(projectName, new Set(ids));
+  }
+  for (const [projectName, ids] of relocateDeletesByProject) {
+    if (!deletesByProject.has(projectName)) deletesByProject.set(projectName, new Set());
+    for (const id of ids) deletesByProject.get(projectName).add(id);
+  }
+
+  if (deletesByProject.size === 0) return { pruned: 0, relocated, scanned };
 
   for (const [projectName, idsToDelete] of deletesByProject) {
     const project = projects.find(p => p.name === projectName);
     if (!project) continue;
     const prPath = projectPrPath(project);
+    const pruneIds = pruneDeletesByProject.get(projectName) || new Set();
     try {
       shared.mutatePullRequests(prPath, (prs) => {
-        const before = prs.length;
+        const deletedIds = prs.filter(p => idsToDelete.has(p?.id)).map(p => p.id);
         const next = prs.filter(p => !idsToDelete.has(p?.id));
-        const deleted = before - next.length;
-        if (deleted > 0) {
-          pruned += deleted;
-          for (const id of idsToDelete) {
-            log('info', `[pull-requests] pruned scope-mismatch duplicate ${id} from project=${projectName} (sibling exists in correctly-scoped project)`);
+        for (const id of deletedIds) {
+          if (pruneIds.has(id)) {
+            pruned++;
+            log('info', `[pull-requests] removed mis-scoped duplicate ${id} from project=${projectName}`);
           }
         }
         return next;
@@ -6246,7 +6460,7 @@ function pruneScopeMismatchDuplicatePrs(config) {
     }
   }
 
-  return { pruned, scanned };
+  return { pruned, relocated, scanned };
 }
 
 // Repair helper: collapse prNumber duplicates across all project-scoped and
@@ -6400,7 +6614,9 @@ module.exports = {
   mergeArtifactNotes,
   promoteCompletionArtifacts,
   runPostCompletionHooks,
+  applyGoalInvalidation,
   syncPrdFromPrs,
+  advancePrdStatusOnAllItemsDone,
   persistVerifyPrsToPrd,
   resolveWorkItemPath,
   isItemCompleted,