@yemi33/minions 0.1.2304 → 0.1.2306

package/engine/ado.js

@@ -42,6 +42,23 @@ function isGitHubProject(project) {
   return String(project?.repoHost || '').toLowerCase() === 'github';
 }
 
+// #3758 — True when at least one configured project is NOT a GitHub project
+// (i.e., could plausibly need ADO). Tick-loop entry points
+// (pollPrStatus/pollPrHumanComments/reconcilePrs) use this to stay fully
+// inert on a GitHub-only install: without it, a config with adoPollEnabled
+// left at its default attempts az/azureauth token acquisition every poll for
+// no reason, producing a permanent, noisy — and, per the failure this
+// closes, potentially fatal — failure loop.
+//
+// Deliberately does NOT require adoOrg/adoProject to already be populated:
+// several legitimate ADO projects start with those fields blank and get them
+// repaired in-place (from a tracked PR URL, canonical PR id, or `git remote`)
+// by repairAdoProjectConfig() inside forEachActivePr/reconcilePrs itself —
+// gating on adoOrg/adoProject here would skip that repair before it ever ran.
+function hasAdoProjectConfigured(config) {
+  return shared.getProjects(config).some(p => !isGitHubProject(p));
+}
+
 function isAdoGuid(value) {
   return ADO_GUID_RE.test(String(value || '').trim());
 }
@@ -1165,6 +1182,13 @@ async function forEachActivePr(config, token, callback) {
             if (currentPrs[idx].reviewStatus === REVIEW_STATUS.APPROVED && after.reviewStatus !== REVIEW_STATUS.APPROVED) {
               after.reviewStatus = REVIEW_STATUS.APPROVED;
             }
+            // Never downgrade status from 'merged' — permanent terminal state. A
+            // stale/out-of-order poll response could otherwise overwrite a concurrent
+            // success/merge write-back (mirrors github.js:564-570 and the central
+            // ADO write-back guard at ado.js:1327-1330).
+            if (currentPrs[idx].status === PR_STATUS.MERGED && after.status !== PR_STATUS.MERGED) {
+              after.status = PR_STATUS.MERGED;
+            }
             shared.applyPrFieldDelta(currentPrs[idx], before, after);
           }
           // Don't push if not found — it was deleted by another writer, respect that
@@ -1328,6 +1352,10 @@ async function forEachActivePr(config, token, callback) {
 async function pollPrStatus(config) {
   _adoPollHadAuthFailure = false; // reset before polling — set again if errors recur
 
+  // #3758 — inert when no project actually uses ADO. Skip token acquisition
+  // entirely rather than spawning az/azureauth for a GitHub-only install.
+  if (!hasAdoProjectConfigured(config)) return;
+
   const token = await getAdoToken();
   if (!token) {
     const w = consumeNoAdoTokenWarning();
@@ -1882,6 +1910,9 @@ async function pollPrStatus(config) {
 // ─── Poll Human Comments on PRs ──────────────────────────────────────────────
 
 async function pollPrHumanComments(config) {
+  // #3758 — inert when no project actually uses ADO.
+  if (!hasAdoProjectConfigured(config)) return;
+
   const token = await getAdoToken();
   if (!token) return;
 
@@ -2100,6 +2131,9 @@ async function pollPrHumanComments(config) {
  * in pull-requests.json, and add them. Matches PRs to work items by branch name.
  */
 async function reconcilePrs(config) {
+  // #3758 — inert when no project actually uses ADO.
+  if (!hasAdoProjectConfigured(config)) return;
+
   const token = await getAdoToken();
   if (!token) {
     const w = consumeNoAdoTokenWarning();
@@ -2984,4 +3018,7 @@ module.exports = {
   isPrValidationBuild,
   shouldRequeueStaleBuild,
   PR_BUILD_REQUEUE_INTERVAL_MS,
+  // #3758 — exported for unit tests of GitHub-only-config inertness.
+  isGitHubProject,
+  hasAdoProjectConfigured,
 };

package/engine/consolidation.js

@@ -1136,6 +1136,52 @@ function consolidateWithRegex(items, files, config) {
 
 // ─── Knowledge Base Classification ───────────────────────────────────────────
 
+// Matches the reusable-knowledge section headers agents conventionally use in
+// their inbox findings notes ("## Patterns / Conventions", "## Bugs & Gotchas",
+// "## Dependencies", etc. — see notes.md consolidation history). Presence
+// signals the note carries generalizable knowledge worth a full-body KB copy;
+// absence means the note is most likely a narrow, one-off deliverable (a
+// single PR review, a task status update, a one-time plan) that should get a
+// condensed stub instead of a full-body duplicate (issue #604).
+// The keyword doesn't have to open the heading — "#### Bugs & Gotchas" (the
+// exact header this module itself generates for regex-fallback consolidation
+// entries, see catLabels above) puts "Bugs" before "Gotchas". Allow up to a
+// few leading heading words (bounded to avoid ReDoS) before the keyword.
+const REUSABLE_SIGNAL_RE = /^#{1,4}\s*(?:[\w&/-]+\s+){0,4}(patterns?(\s*(&|and|\/)\s*conventions?)?|conventions?|gotchas?|dependencies|best practices?)\b/im;
+
+function hasReusableSignal(content) {
+  return REUSABLE_SIGNAL_RE.test(content || '');
+}
+
+/**
+ * Build a condensed KB stub for narrowly-scoped, one-off notes instead of
+ * duplicating the full body (issue #604 — classifyToKnowledgeBase was copying
+ * every consolidated inbox note's ENTIRE body into knowledge/<category>/,
+ * doubling disk usage and paying a recurring context/token cost on every
+ * future dispatch that primes from knowledge/ before notes/inbox/).
+ *
+ * Deterministic and LLM-free: keeps the note's H1 title (if any) plus its
+ * first substantive paragraph as a short abstract, then links back to the
+ * archived note for anyone who needs the full detail. Existing full-body KB
+ * files already on disk are untouched — this only changes how NEW entries
+ * are written.
+ */
+function buildCondensedKbBody(content, titleLine, archiveRelPath) {
+  const body = String(content || '').trim();
+  const withoutTitle = titleLine ? body.replace(/^#\s+.+(\r?\n)+/, '') : body;
+  const firstBlock = (withoutTitle.split(/\r?\n\s*\r?\n/).find(b => b.trim().length > 0) || '').trim();
+  const MAX_LEN = 500;
+  let abstract = firstBlock;
+  if (abstract.length > MAX_LEN) {
+    abstract = abstract.slice(0, MAX_LEN).replace(/\s+\S*$/, '').trim() + '\u2026';
+  }
+  const parts = [];
+  if (titleLine) parts.push(titleLine.trim());
+  parts.push(abstract || '_(no summary available)_');
+  parts.push(`_Full note: \`${archiveRelPath}\`._`);
+  return parts.join('\n\n') + '\n';
+}
+
 async function classifyToKnowledgeBase(items, config) {
 
   if (!fs.existsSync(KNOWLEDGE_DIR)) fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
@@ -1174,9 +1220,18 @@ async function classifyToKnowledgeBase(items, config) {
     const kbFilename = `${dateStamp()}-${agent}-${titleSlug}.md`;
     const kbPath = shared.uniquePath(path.join(categoryDirs[category], kbFilename));
 
-    const frontmatter = `---\nsource: ${item.name}\nagent: ${agent}\ncategory: ${category}\ndate: ${dateStamp()}\n---\n\n`;
+    // Reserve full-body KB copies for content that's actually general/reusable
+    // (patterns, conventions, gotchas); narrowly-scoped one-off notes get a
+    // condensed stub + link back to the archived note instead (issue #604).
+    const reusable = category === 'conventions' || hasReusableSignal(content);
+    const archiveRelPath = `notes/archive/${dateStamp()}-${item.name}`;
+    const kbBody = reusable
+      ? content
+      : buildCondensedKbBody(content, titleMatch ? titleMatch[0] : null, archiveRelPath);
+
+    const frontmatter = `---\nsource: ${item.name}\nagent: ${agent}\ncategory: ${category}\ndate: ${dateStamp()}\nreusable: ${reusable}\n---\n\n`;
     try {
-      safeWrite(kbPath, frontmatter + content);
+      safeWrite(kbPath, frontmatter + kbBody);
       classified++;
     } catch (err) {
       log('warn', `Failed to classify ${item.name} to knowledge base: ${err.message}`);
@@ -1340,4 +1395,6 @@ module.exports = {
   archiveInboxFiles,
   _capNotesPreservingOverflow,
   NOTES_MAX_BYTES,
+  hasReusableSignal,
+  buildCondensedKbBody,
 };

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).
@@ -6400,7 +6547,9 @@ module.exports = {
   mergeArtifactNotes,
   promoteCompletionArtifacts,
   runPostCompletionHooks,
+  applyGoalInvalidation,
   syncPrdFromPrs,
+  advancePrdStatusOnAllItemsDone,
   persistVerifyPrsToPrd,
   resolveWorkItemPath,
   isItemCompleted,