@yemi33/minions 0.1.2381 → 0.1.2383

package/engine/dispatch.js

@@ -307,10 +307,10 @@ function addToDispatch(item) {
 function _persistInvalidWorkItem(item, evaluation) {
   const meta = item?.meta;
   const itemId = meta?.item?.id;
-  if (!itemId) return { stuck: false };
+  if (!itemId) return { exhausted: false };
   let wiScope;
   try { wiScope = lifecycle().resolveWorkItemScope(meta); } catch { wiScope = null; }
-  if (!wiScope) return { stuck: false };
+  if (!wiScope) return { exhausted: 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
@@ -319,7 +319,7 @@ function _persistInvalidWorkItem(item, evaluation) {
   const maxRejections = queries.getConfig()?.engine?.preDispatchEvalMaxRejections
     ?? ENGINE_DEFAULTS.preDispatchEvalMaxRejections;
   const currentDescription = String((meta.item && meta.item.description) || '');
-  let stuck = false;
+  let exhausted = false;
   try {
     mutateWorkItems(wiScope, (items) => {
       if (!Array.isArray(items)) return items;
@@ -329,31 +329,79 @@ function _persistInvalidWorkItem(item, evaluation) {
       const prior = wi._preDispatchEval;
       const sameDescription = prior && prior.description === currentDescription;
       const rejectCount = (sameDescription ? (prior.rejectCount || 0) : 0) + 1;
+      const history = Array.isArray(prior?.history) ? prior.history.slice(-19) : [];
+      const evaluatedAt = ts();
+      history.push({
+        reason: evaluation.reason || '',
+        evaluatedAt,
+        description: currentDescription,
+      });
       wi._preDispatchEval = {
         valid: false,
         reason: evaluation.reason || '',
-        evaluatedAt: ts(),
+        evaluatedAt,
         rejectCount,
         description: currentDescription,
+        history,
       };
       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';
+        exhausted = true;
+        wi.status = WI_STATUS.PENDING;
+        wi._preDispatchEval.exhausted = true;
+        wi._preDispatchEval.exhaustedAt = evaluatedAt;
+        wi._pendingReason = 'pre_dispatch_eval_rejected';
+        delete wi._failureClass;
+        delete wi.failReason;
+        delete wi.failedAt;
       }
       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`);
+  if (exhausted) {
+    log('warn', `pre-dispatch-eval: ${itemId} rejected ${maxRejections}+ times with unchanged description — paused pending operator edit`);
+  }
+  return { exhausted };
+}
+
+function _clearPreDispatchRejection(item, evaluation) {
+  const meta = item?.meta;
+  const itemId = meta?.item?.id;
+  if (!itemId) return;
+  let wiScope;
+  try { wiScope = lifecycle().resolveWorkItemScope(meta); } catch { wiScope = null; }
+  if (!wiScope) return;
+  try {
+    mutateWorkItems(wiScope, (items) => {
+      if (!Array.isArray(items)) return items;
+      const wi = items.find(w => w && w.id === itemId);
+      if (!wi || !wi._preDispatchEval) return items;
+      wi._preDispatchEval = {
+        ...wi._preDispatchEval,
+        valid: true,
+        reason: evaluation?.reason || '',
+        evaluatedAt: ts(),
+        rejectCount: 0,
+        description: String(meta.item?.description || ''),
+      };
+      delete wi._preDispatchEval.exhausted;
+      delete wi._preDispatchEval.exhaustedAt;
+      if (wi._pendingReason === 'pre_dispatch_eval_rejected') delete wi._pendingReason;
+      return items;
+    }, { skipWriteIfUnchanged: true });
+  } catch (e) {
+    log('warn', `pre-dispatch-eval: failed to clear rejection on ${itemId}: ${e.message}`);
+  }
+  try {
+    mutateDispatch((dispatch) => {
+      dispatch.review = (Array.isArray(dispatch.review) ? dispatch.review : [])
+        .filter(entry => entry?.meta?.item?.id !== itemId);
+      return dispatch;
+    });
+  } catch (e) {
+    log('warn', `pre-dispatch-eval: failed to clear review entry for ${itemId}: ${e.message}`);
   }
-  return { stuck };
 }
 
 function _routeToReviewQueue(item, evaluation) {
@@ -438,6 +486,11 @@ async function addToDispatchWithValidation(item, opts = {}) {
   if (!hasCriteria && !hasUsableDescription) {
     return addToDispatch(item);
   }
+  const priorEvaluation = wi?._preDispatchEval;
+  if (priorEvaluation?.exhausted === true
+      && priorEvaluation.description === String(wi?.description || '')) {
+    return null;
+  }
 
   // W-mq9acoo800177bcb — PRD-sourced bypass. plan-to-prd already LLM-vets
   // every item it lands in a PRD, so re-validating each materialized item
@@ -477,14 +530,13 @@ async function addToDispatchWithValidation(item, opts = {}) {
     return addToDispatch(item);
   }
 
-  if (!evaluation || evaluation.valid !== false) return addToDispatch(item);
+  if (!evaluation || evaluation.valid !== false) {
+    _clearPreDispatchRejection(item, evaluation);
+    return addToDispatch(item);
+  }
 
-  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);
+  const { exhausted } = _persistInvalidWorkItem(item, evaluation);
+  if (!exhausted) _routeToReviewQueue(item, evaluation);
   log('warn', `pre-dispatch-eval: blocked work item ${wi.id} — ${evaluation.reason || 'criteria not actionable'}`);
   return null;
 }
@@ -926,7 +978,12 @@ function markCompletedSourceWorkItem(item) {
 // ─── Complete Dispatch ───────────────────────────────────────────────────────
 
 function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', resultSummary = '', opts = {}) {
-  const { processWorkItemFailure = true, processWorkItemSuccess = false, failureClass } = opts;
+  const {
+    processWorkItemFailure = true,
+    processWorkItemSuccess = false,
+    countAgentRetryFailure = true,
+    failureClass,
+  } = opts;
   const agentRetryable = normalizeRetryableDecision(opts.agentRetryable ?? opts.retryable);
   let item = null;
   let completedSourceWorkItem = false;
@@ -1133,7 +1190,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
                   // agent hits the threshold. Skip when no agent is resolvable
                   // (anonymous failures shouldn't corrupt the map shape).
                   const failedAgent = item.agent || wi.dispatched_to;
-                  if (failedAgent) shared.bumpAgentRetryCount(wi, failedAgent);
+                  if (failedAgent && countAgentRetryFailure) shared.bumpAgentRetryCount(wi, failedAgent);
                   delete wi.failReason;
                   delete wi.failedAt;
                   delete wi.dispatched_at;

package/engine/execution-model.js

@@ -0,0 +1,68 @@
+/**
+ * Runtime-model evidence shared by dispatch, PR-comment, and review persistence.
+ *
+ * Priority is deliberate: runtime completion output is authoritative, an
+ * earlier stream/session capture is next, and the requested model is only a
+ * fallback when Minions explicitly sent one to the runtime. No catalog-based
+ * default inference belongs here.
+ */
+
+const UNKNOWN_MODEL = 'unknown';
+const MODEL_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
+
+function normalizeExecutionModel(value) {
+  if (typeof value !== 'string') return null;
+  const model = value.trim();
+  return MODEL_ID_RE.test(model) ? model : null;
+}
+
+function resolveExecutionModel({
+  reportedModel,
+  capturedModel,
+  requestedModel,
+} = {}) {
+  for (const [source, value] of [
+    ['reported', reportedModel],
+    ['captured', capturedModel],
+    ['requested', requestedModel],
+  ]) {
+    const model = normalizeExecutionModel(value);
+    if (model) return { model, source };
+  }
+  return { model: UNKNOWN_MODEL, source: 'unknown' };
+}
+
+function _dispatchWorkItemId(item) {
+  return item?.meta?.item?.id
+    || item?.meta?.workItemId
+    || item?.workItemId
+    || null;
+}
+
+function resolveCommentExecutionModel({
+  dispatch,
+  agentId,
+  workItemId,
+} = {}) {
+  const active = Array.isArray(dispatch?.active) ? dispatch.active : [];
+  const candidates = active.filter((item) => {
+    if (String(item?.agent || '').toLowerCase() !== String(agentId || '').toLowerCase()) return false;
+    if (!workItemId) return true;
+    return item.id === workItemId || _dispatchWorkItemId(item) === workItemId;
+  });
+  candidates.sort((a, b) => String(b.started_at || '').localeCompare(String(a.started_at || '')));
+  const item = candidates[0] || null;
+  if (!item) return { model: null, source: 'none' };
+  return resolveExecutionModel({
+    capturedModel: item?.executionModel,
+    requestedModel: item?.requestedModel,
+  });
+}
+
+module.exports = {
+  UNKNOWN_MODEL,
+  MODEL_ID_RE,
+  normalizeExecutionModel,
+  resolveExecutionModel,
+  resolveCommentExecutionModel,
+};

package/engine/gh-comment.js

@@ -4,7 +4,7 @@
  * minions-authored PR comments by structure rather than by body shape.
  *
  * Marker format (single line, ASCII):
- *   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> -->
+ *   <!-- minions:agent=<agentId> kind=<kind> wi=<workItemId> model=<modelId> -->
  *
  * Followed by `\n\n` and then the caller-provided body. `wi=` is omitted when
  * no workItemId is supplied. The marker is intentionally minimal so it round-
@@ -14,6 +14,7 @@
  *   - agentId    /^[a-z][a-z0-9-]{0,30}$/  (lowercase, hyphenated, ≤31 chars)
  *   - kind       /^[a-z][a-z0-9-]{0,30}$/  (same shape — categorical tag)
  *   - workItemId /^[A-Z]-[a-z0-9]+$/       (e.g. W-mp3bp0ha000997ab, P-d5a8c9b6)
+ *   - model      concrete runtime model, when active-dispatch evidence exists
  *   - no field may contain `--` (would close the HTML comment early)
  *   - no field may contain `=` `<` `>` `\n` `"` `'` `` ` ``  ` `  (whitespace)
  *
@@ -153,13 +154,14 @@ function postPrComment({
   agentId,
   kind,
   workItemId,
+  model,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {
@@ -182,13 +184,14 @@ function postPrReviewComment({
   agentId,
   kind,
   workItemId,
+  model,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {

package/engine/github.js

@@ -282,10 +282,10 @@ async function _resolveViewerLogin(slug) {
 // `_isMinionsAuthoredComment` cannot tell minions posts apart from human
 // posts (the `viewerDidAuthor` gate stays false for everything), so the
 // comment classifier reclassifies every minions comment as human and
-// queues a spurious fix dispatch on every poll cycle. The downstream
-// `check-self-authored-review-comment` skill no-ops the dispatch, so this
-// is a slot/token tax rather than state corruption — but the frequency
-// data is worth tracking so future audits can prioritize a deeper fix
+// queues a spurious fix dispatch on every poll cycle. Review-fix completion
+// now rejects shared-identity-only no-ops, so failing closed here prevents
+// both duplicate traffic and false completion retries. The frequency
+// data is still worth tracking so future audits can prioritize a deeper fix
 // (e.g. a credentialed re-probe of the gh CLI). Global counter under
 // `_engine.viewerLoginResolutionFailures`; surfaced through the existing
 // engine metrics aggregation (`getMetrics()` in `engine/queries.js`).
@@ -1241,9 +1241,8 @@ async function pollPrHumanComments(config) {
     // `c.viewerDidAuthor === true`, and `_backfillViewerDidAuthor` is a
     // no-op when viewerLogin is null. Running the classifier without a
     // login mass-misclassifies every minions comment as human and queues
-    // a redundant fix dispatch on every poll cycle (the downstream
-    // `check-self-authored-review-comment` skill no-ops them, so this is
-    // a slot/token tax — see audit OQ-Y, HIGH not CRITICAL). Skip the
+    // a redundant fix dispatch on every poll cycle. Shared identity is not
+    // valid review-fix no-op evidence, so skip the
     // entire round instead. One log + one counter increment per affected
     // PR per cycle (no per-comment fanout).
     if (!viewerLogin) {