@yemi33/minions 0.1.2357 → 0.1.2359

package/engine/dispatch.js

@@ -310,25 +310,53 @@ function addToDispatch(item) {
 function _persistInvalidWorkItem(item, evaluation) {
   const meta = item?.meta;
   const itemId = meta?.item?.id;
-  if (!itemId) return;
+  if (!itemId) return { stuck: false };
   let wiPath;
   try { wiPath = lifecycle().resolveWorkItemPath(meta); } catch { wiPath = null; }
-  if (!wiPath) return;
+  if (!wiPath) return { stuck: false };
+  // W-mrcrh5hj0017d22f — repeat-rejection cap. Compare against the
+  // description snapshot from the LAST rejection so an operator edit to the
+  // WI resets the counter (it deserves a fresh evaluation), while an
+  // unchanged, permanently-unactionable description accumulates toward
+  // the cap instead of being silently re-evaluated forever.
+  const maxRejections = queries.getConfig()?.engine?.preDispatchEvalMaxRejections
+    ?? ENGINE_DEFAULTS.preDispatchEvalMaxRejections;
+  const currentDescription = String((meta.item && meta.item.description) || '');
+  let stuck = false;
   try {
     mutateWorkItems(wiPath, (items) => {
       if (!Array.isArray(items)) return items;
       const idx = items.findIndex(w => w && w.id === itemId);
       if (idx === -1) return items;
-      items[idx]._preDispatchEval = {
+      const wi = items[idx];
+      const prior = wi._preDispatchEval;
+      const sameDescription = prior && prior.description === currentDescription;
+      const rejectCount = (sameDescription ? (prior.rejectCount || 0) : 0) + 1;
+      wi._preDispatchEval = {
         valid: false,
         reason: evaluation.reason || '',
         evaluatedAt: ts(),
+        rejectCount,
+        description: currentDescription,
       };
+      if (rejectCount >= maxRejections) {
+        stuck = true;
+        wi.status = WI_STATUS.FAILED;
+        wi._failureClass = FAILURE_CLASS.PRE_DISPATCH_EVAL_STUCK;
+        wi.failReason = `pre-dispatch-eval rejected this work item ${rejectCount} times in a row ` +
+          `with an unchanged description — last reason: ${evaluation.reason || 'criteria not actionable'}`;
+        wi.failedAt = ts();
+        wi._pendingReason = 'pre_dispatch_eval_stuck';
+      }
       return items;
     }, { skipWriteIfUnchanged: true });
   } catch (e) {
     log('warn', `pre-dispatch-eval: failed to persist reason on ${itemId}: ${e.message}`);
   }
+  if (stuck) {
+    log('warn', `pre-dispatch-eval: ${itemId} rejected ${maxRejections}+ times with unchanged description — flipped to failed (PRE_DISPATCH_EVAL_STUCK) instead of re-evaluating forever`);
+  }
+  return { stuck };
 }
 
 function _routeToReviewQueue(item, evaluation) {
@@ -455,8 +483,12 @@ async function addToDispatchWithValidation(item, opts = {}) {
 
   if (!evaluation || evaluation.valid !== false) return addToDispatch(item);
 
-  _persistInvalidWorkItem(item, evaluation);
-  _routeToReviewQueue(item, evaluation);
+  const { stuck } = _persistInvalidWorkItem(item, evaluation);
+  // W-mrcrh5hj0017d22f: once the WI has been flipped to failed for
+  // repeat-rejection, don't also push it into the review queue — the
+  // failed status already stops future discovery ticks from re-evaluating
+  // it, and a review-queue entry would just be a stale duplicate signal.
+  if (!stuck) _routeToReviewQueue(item, evaluation);
   log('warn', `pre-dispatch-eval: blocked work item ${wi.id} — ${evaluation.reason || 'criteria not actionable'}`);
   return null;
 }

package/engine/pipeline.js

@@ -77,6 +77,23 @@ function getPipelineRuns() {
   return safeJsonObj(PIPELINE_RUNS_PATH);
 }
 
+// W-mrcrh5hj0017d22f: SQL is the canonical (and only) work-items store post
+// Phase 9.4 — the JSON files (central work-items.json + each
+// projects/<name>/work-items.json) are passive, best-effort mirrors that can
+// legitimately lag behind a just-completed write (mirror failures are
+// swallowed by design so they never block the SQL write; see
+// work-items-store.js's `_mirrorJsonFromSql` comments). Reading those JSON
+// files directly (via safeJson/safeJsonArr) can therefore observe a work
+// item whose `status` mirrored to DONE but whose `resultSummary` write
+// hasn't landed in the mirror yet — which silently degraded stage-output
+// template substitution ({{stages.<id>.output}}) to the stage's own work
+// item id instead of its real completion text. Route every work-item read
+// in this module through the SQL-backed store so pipeline state always sees
+// the authoritative record.
+function _allWorkItems() {
+  return require('./work-items-store').readAllWorkItems();
+}
+
 function getActiveRun(pipelineId) {
   const runs = getPipelineRuns();
   const pipelineRuns = runs[pipelineId] || [];
@@ -338,12 +355,7 @@ function evaluateCondition(condition, ctx) {
     case 'noFailedItems': {
       // True when all work items created by the pipeline are done (not failed)
       if (!run) return false;
-      const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJsonArr(wiPath);
-      const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
-        return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
-      }, []);
-      const all = [...workItems, ...allProjectWi];
+      const all = _allWorkItems();
       const pipelineWis = all.filter(w => w._pipelineRun === run.runId);
       if (pipelineWis.length === 0) return true; // no items = nothing failed
       return pipelineWis.every(w => w.status !== WI_STATUS.FAILED);
@@ -945,13 +957,8 @@ function isStageComplete(stage, stageState, run, config) {
 
   switch (stage.type) {
     case STAGE_TYPE.TASK: {
-      // Check root + all project work-items.json (WIs may be moved to project paths)
-      const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJsonArr(wiPath);
-      const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
-        return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
-      }, []);
-      const all = [...workItems, ...allProjectWi];
+      // Check central + all project work items (WIs may live in project scopes)
+      const all = _allWorkItems();
       const ids = artifacts.workItems || [];
       if (ids.length === 0) return false;
       return ids.every(id => {
@@ -970,12 +977,7 @@ function isStageComplete(stage, stageState, run, config) {
     }
     case STAGE_TYPE.PLAN: {
       // Plan stage completion: PRD conversion done + all materialized work items done
-      const wiPath = CENTRAL_WI_PATH;
-      const workItems = safeJsonArr(wiPath);
-      const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
-        return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
-      }, []);
-      const all = [...workItems, ...allProjectWi];
+      const all = _allWorkItems();
 
       // Check if plan-to-prd work item is done
       const prdWiIds = artifacts.workItems || [];
@@ -1138,13 +1140,20 @@ async function discoverPipelineWork(config) {
           // Collect output
           let output = '';
           if (stage.type === STAGE_TYPE.TASK) {
-            const wiPath = CENTRAL_WI_PATH;
-            const workItems = safeJsonArr(wiPath);
-            const projWi = shared.getProjects(config).reduce((acc, p) => acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []), []);
-            const allWi = [...workItems, ...projWi];
+            const allWi = _allWorkItems();
             output = (stageState.artifacts?.workItems || []).map(id => {
               const wi = allWi.find(w => w.id === id);
-              return wi?.resultSummary || wi?.title || id;
+              // W-mrcrh5hj0017d22f: never fall back to the stage's own work
+              // item id — a bare id substituted into {{stages.<id>.output}}
+              // produces a nonsensical downstream description (e.g.
+              // "Confirmed bugs:\nPL-mrcqpzit-verify-0-minions-opg") that
+              // pre-dispatch-eval correctly (but silently, forever) rejects.
+              // If the real resultSummary/title text isn't available yet
+              // (WI missing, or a lagged/failed mirror momentarily hides a
+              // just-completed resultSummary), fall back to an empty string
+              // — a blank substitution is harmless where an opaque id is
+              // actively misleading.
+              return wi?.resultSummary || wi?.title || '';
             }).join('\n');
           } else if (stage.type === STAGE_TYPE.MEETING) {
             const { getMeeting } = require('./meeting');

package/engine/shared.js

@@ -3497,6 +3497,17 @@ const ENGINE_DEFAULTS = {
   // requested/completed PRDs still flow through the normal validator path so a
   // stale PRD reopen can't smuggle in unvetted items.
   preDispatchEvalSkipPrdSourced: true,
+  // W-mrcrh5hj0017d22f — repeat-rejection cap. addToDispatchWithValidation
+  // re-runs the LLM validator on EVERY discovery tick for a WI that's still
+  // `pending` — routing to the review queue (_routeToReviewQueue) dedupes
+  // that queue but never changes the WI's own status, so an item whose
+  // description the validator will never accept (see stage-output
+  // substitution bug above) got re-evaluated forever, once per tick,
+  // invisible to the dashboard. Once the SAME (unchanged) description is
+  // rejected this many consecutive times, the WI is flipped to `failed`
+  // with FAILURE_CLASS.PRE_DISPATCH_EVAL_STUCK instead of being silently
+  // re-queued into review again.
+  preDispatchEvalMaxRejections: 5,
   completionNonceRequired: false, // P-d2a8f6c1 (agent trust boundary F8): when true, a missing `nonce` field in the completion JSON hard-fails the dispatch with failure_class:'completion-nonce-mismatch'. Default false for one release so older agents/runtime caches that haven't picked up the prompt change degrade with a warning instead of breaking. Mismatched nonces hard-fail regardless of this flag. See docs/completion-reports.md → "Trust boundary".
   autoApplyReviewVote: false, // W-mpea9fyb0010febf / P-f7splitgate: master gate for ALL engine platform vote mutations. When true, the engine (a) mirrors live platform vote state into local pull-requests.json reviewStatus, (b) re-applies its own ADO +10 approval when ADO resets votes on target-branch advance (pollPrStatus), (c) reconciles its own prior negative on a verdict flip to APPROVE (ADO resetReviewerNegativeVote / GitHub dismissPriorViewerChangesRequestedReviews), and (d) instructs ADO review agents to cast `az repos pr set-vote`. When false (default), the verdict is recorded in pull-requests.json reviewStatus from the agent's completion ONLY — informational — and Minions never cast, re-cast, or clear a platform vote/review (ADO agents post the verdict as a comment only, parity with GitHub self-approval block).
 
@@ -4958,6 +4969,7 @@ const FAILURE_CLASS = {
   OUTPUT_TRUNCATED: 'output-truncated',   // P-8e4c2a17: the agent streamed more stdout than the engine's hard capture cap (engine.js AGENT_OUTPUT_CAP_BYTES, 1MB) BEFORE the terminal `result` event arrived. The result (session id, completion block, final text) lives at the END of the stream, so it fell outside the captured window and parseOutput found nothing — the dispatch would otherwise fail as an opaque UNKNOWN and retry to death. Surfaced loudly with an actionable message; non-retryable (mechanical retry just reproduces the overflow — the agent must reduce output volume or the task must be split).
   VERIFY_MISSING_PR: 'verify-missing-pr', // W-mqsk1ip00006cbae: a verify WI exited done but no PR was attached (neither _prUrl/_pr on the item nor a matching pull-requests.json entry for the plan). Flipped to failed so the plan doesn't silently advance without an E2E PR. Retryable — agent may have phantom-crashed before pushing the branch.
   PROJECT_NOT_FOUND: 'project_not_found', // W-mqv2wsy30002e090: a work item's `project` field names a project that is not configured (resolveConfiguredProject / formatUnknownProjectError → `Project "<name>" not found. Known projects: …`). Stamped at discovery time so the dashboard PR-column renderer surfaces the red failReason snippet like other non-retryable failures instead of burying it in the Agent column. Non-retryable — operator must fix the WI's project field or configure the project.
+  PRE_DISPATCH_EVAL_STUCK: 'pre-dispatch-eval-stuck', // W-mrcrh5hj0017d22f: pre-dispatch-eval rejected the SAME (unchanged) description ENGINE_DEFAULTS.preDispatchEvalMaxRejections times in a row without the WI status ever leaving pending — previously this burned an LLM validation call every discovery tick forever with nothing surfaced to the dashboard (constant-bug-bash's file-fixes stage wedged 16+ consecutive rejections, one/minute, until a human manually cancelled it). Engine now flips the WI to failed with this class so the stalled item is visible and stops silently re-evaluating; non-retryable until the description changes.
   UNKNOWN: 'unknown',                     // Unclassified failure
 };
 

package/package.json

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