@yemi33/minions 0.1.2380 → 0.1.2382

package/engine/dispatch.js

@@ -53,6 +53,8 @@ const NON_MUTATING_DISPATCH_TYPES = new Set([
 // PR source branch always differs and causes phantom auto-cancellation (#369).
 const PR_BRANCH_TARGETED_TYPES = new Set([
   WORK_TYPE.FIX,
+  WORK_TYPE.BUILD_FIX_COMPLEX,
+  WORK_TYPE.TEST,
   WORK_TYPE.VERIFY,
   WORK_TYPE.DECOMPOSE,
 ]);
@@ -148,7 +150,7 @@ function getPrDispatchDedupeKey(entry) {
   if (!entry?.type) return null;
   const targetKey = getPrDispatchTargetKey(entry);
   if (!targetKey) return null;
-  const type = entry.type === WORK_TYPE.FIX ? WORK_TYPE.FIX : entry.type;
+  const type = shared.isFixLikeWorkType(entry.type) ? WORK_TYPE.FIX : entry.type;
   return `${targetKey}:${type}`;
 }
 
@@ -197,7 +199,7 @@ function findActivePrOrBranchLock(dispatch, item) {
   // PR-target dedup is FIX-only: a FIX shouldn't stack on top of another FIX
   // for the same PR, but a REVIEW + FIX pair targeting the same PR is the
   // normal review-then-fix flow and must not be dedup'd here.
-  if (item?.type === WORK_TYPE.FIX) {
+  if (shared.isFixLikeWorkType(item?.type)) {
     const prTargetKey = getPrDispatchTargetKey(item);
     if (prTargetKey) {
       const existing = active.find(d => getPrDispatchTargetKey(d) === prTargetKey);
@@ -305,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
@@ -317,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;
@@ -327,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) {
@@ -436,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
@@ -475,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;
 }
@@ -703,7 +757,7 @@ async function pruneStalePrDispatchesAsync(config = queries.getConfig()) {
   for (const entry of pending) {
     const reason = reasonsById.get(entry.id);
     if (!reason) continue;
-    if (entry.type !== WORK_TYPE.FIX || !_MERGED_OR_ABANDONED_REASON_RE.test(reason)) continue;
+    if (!shared.isFixLikeWorkType(entry.type) || !_MERGED_OR_ABANDONED_REASON_RE.test(reason)) continue;
     try {
       const wi = _resolveWorkItemForPrunedEntry(entry);
       const scopePaths = shared.extractScopeFilePathsFromWorkItem(wi);

package/engine/lifecycle.js

@@ -1559,7 +1559,7 @@ function isPrAttachmentRequired(type, item, meta = {}) {
   // PR — the agent updates meta.pr in place. The meta.pr short-circuit beats
   // the explicit-flag fallthrough so a legacy requiresPr:true fix doesn't
   // trigger the contract when there's already a PR attached.
-  if ((type === WORK_TYPE.FIX || type === WORK_TYPE.TEST) && meta?.pr) return false;
+  if ((shared.isFixLikeWorkType(type) || type === WORK_TYPE.TEST) && meta?.pr) return false;
 
   // Standalone test work is usually pure build/run/verify. It should only be
   // PR-required when the caller explicitly marks it as file-changing work.
@@ -1568,7 +1568,7 @@ function isPrAttachmentRequired(type, item, meta = {}) {
   return explicit
     || type === WORK_TYPE.IMPLEMENT
     || type === WORK_TYPE.IMPLEMENT_LARGE
-    || type === WORK_TYPE.FIX;
+    || shared.isFixLikeWorkType(type);
 }
 
 function readOptionalJsonStrict(filePath, label, validate) {
@@ -4578,8 +4578,8 @@ function parseCompletionBoolean(value) {
 // detected, or null otherwise. The status must be a successful terminal state
 // — a failed/partial/in-progress completion that also claims `noop` is a
 // contradiction and falls through to the normal contract.
-function parseCompletionNoop(completion) {
-  if (!completion || typeof completion !== 'object') return null;
+function completionDeclaresNoop(completion) {
+  if (!completion || typeof completion !== 'object') return false;
   const explicit = parseCompletionBoolean(completion.noop);
   let resultIsNoop = false;
   if (typeof completion.result === 'string') {
@@ -4587,7 +4587,11 @@ function parseCompletionNoop(completion) {
   } else if (completion.result && typeof completion.result === 'object') {
     resultIsNoop = String(completion.result.type || '').trim().toLowerCase() === 'noop';
   }
-  if (explicit !== true && !resultIsNoop) return null;
+  return explicit === true || resultIsNoop;
+}
+
+function parseCompletionNoop(completion) {
+  if (!completionDeclaresNoop(completion)) return null;
   const status = normalizeCompletionStatus(completion.status);
   if (status && status !== 'success' && status !== 'done' && status !== 'complete') return null;
   const reason = String(
@@ -4600,6 +4604,53 @@ function parseCompletionNoop(completion) {
   return reason || 'no-op completion';
 }
 
+function classifyBenignZeroTargetOutcome(dispatchItem, completion, resultSummary) {
+  const item = dispatchItem?.meta?.item;
+  if (!item?._scheduleId || item.createdBy !== 'scheduler') return null;
+  const type = dispatchItem?.type || item.type;
+  if (![WORK_TYPE.SETUP, WORK_TYPE.EXPLORE, WORK_TYPE.REVIEW].includes(type)) return null;
+  if (!completionDeclaresNoop(completion)) return null;
+  if (parseCompletionBoolean(completion?.needs_rerun ?? completion?.needsRerun) === true) return null;
+  if (parseCompletionBoolean(completion?.retryable) === true) return null;
+  if (completion?.securityFlags?.injectionAttempt === true) return null;
+  const failureClass = String(completion?.failure_class || '').trim().toLowerCase();
+  const nonceUnavailable = failureClass === 'completion-nonce-unavailable'
+    || failureClass === 'nonce-unavailable';
+  if (hasActionableFailureClass(failureClass) && !nonceUnavailable) return null;
+  const status = normalizeCompletionStatus(completion?.status);
+  const successfulStatus = status === 'success' || status === 'done' || status === 'complete';
+  const nonceTransportFailure = nonceUnavailable && (status.startsWith('fail') || status === 'error');
+  if (!successfulStatus && !nonceTransportFailure) return null;
+
+  const evidence = [...new Set([
+    completion?.summary,
+    completion?.noopReason,
+    completion?.noop_reason,
+    resultSummary,
+  ].filter(Boolean).map(value => String(value).trim()))].join(' ').trim();
+  if (!evidence) return null;
+
+  const mutationOccurred = [
+    /\b(?:a|one|[1-9]\d*)\s+(?:new\s+)?(?:work items?|reviews?|pull requests?|prs?|issues?)\s+(?:(?:was|were)\s+)?(?:created|enrolled|dispatched|posted|deleted|removed)\b/i,
+    /\b(?:created|enrolled|dispatched|posted|deleted|removed)\s+[1-9]\d*\b/i,
+  ].some(pattern => pattern.test(evidence));
+  if (mutationOccurred) return null;
+
+  const zeroTargets = [
+    /\bno\s+[^.!?\n]{0,120}\b(?:needed|required|eligible|qualif(?:y|ied)|found|remain(?:ed|ing)?|to\s+(?:review|remove|dispatch|enroll|process|merge|fix))\b/i,
+    /\bno\s+(?:open\s+issues?|eligible|qualifying|matching|context-only|merged|abandoned)\b/i,
+    /\b(?:0|zero)\s+(?:eligible|qualifying|matching|context-only|open)\b/i,
+  ].some(pattern => pattern.test(evidence));
+  if (!zeroTargets) return null;
+
+  const noMutation = [
+    /\bno\s+(?:api\s+)?(?:post|mutations?|writes?|actions?|changes?|modifications?|updates?|delete requests?|work items?|review work items?)\s+(?:(?:was|were)\s+)?(?:made|performed|taken|sent|created)?\b/i,
+    /\b(?:0|zero)\s+(?:were\s+)?(?:created|enrolled|dispatched|posted|deleted|removed)\b/i,
+    /\b(?:created|enrolled|dispatched|posted|deleted|removed)\s+(?:0|zero)\b/i,
+  ].some(pattern => pattern.test(evidence));
+  return noMutation ? evidence : null;
+}
+
 function normalizeReviewVerdict(verdict) {
   const value = String(verdict || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
   if (value === 'approve' || value === 'approved') return REVIEW_STATUS.APPROVED;
@@ -5482,11 +5533,15 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // P-d2a8f6c1: a nonce mismatch always counts as an agent-reported failure
   // (regardless of what the discarded report claimed). This forces both the
   // effectiveSuccess gate below and the dispatch result in engine.js to ERROR.
-  const agentReportedFailure = !!nonceMismatch
-    || completionStatus.startsWith('fail')
+  const benignNoop = nonceMismatch
+    ? null
+    : classifyBenignZeroTargetOutcome(dispatchItem, structuredCompletion, completionGateSummary);
+  const agentReportedFailure = !!nonceMismatch || (!benignNoop && (
+    completionStatus.startsWith('fail')
     || completionStatus === 'error'
     || hasActionableFailureClass(structuredCompletion?.failure_class)
-    || agentNeedsRerun;
+    || agentNeedsRerun
+  ));
   // Untrusted completions cannot be honored as "retryable" by the agent — its
   // retryable claim was discarded with the rest of the report. Force false.
   const agentRetryable = nonceMismatch ? false : parseCompletionBoolean(structuredCompletion?.retryable);
@@ -5494,12 +5549,12 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Auto-recover: if a failed implement/fix/test agent created PRs, it likely succeeded before the failure surfaced.
   // P-d2a8f6c1: skip auto-recovery for nonce-mismatched dispatches — a forged
   // report shouldn't be able to ride PRs into a "done" status.
-  const prCreatingType = type === WORK_TYPE.IMPLEMENT || type === WORK_TYPE.IMPLEMENT_LARGE || type === WORK_TYPE.FIX || type === WORK_TYPE.TEST;
+  const prCreatingType = type === WORK_TYPE.IMPLEMENT || type === WORK_TYPE.IMPLEMENT_LARGE || shared.isFixLikeWorkType(type) || type === WORK_TYPE.TEST;
   const autoRecovered = !nonceMismatch && !agentReportedFailure && !isSuccess && prsCreatedCount > 0 && prCreatingType && !!meta?.item?.id;
   if (autoRecovered) {
     log('info', `Auto-recovery: agent failed but created ${prsCreatedCount} PR(s) — upgrading ${meta.item.id} to done`);
   }
-  const effectiveSuccess = !nonceMismatch && ((isSuccess && !agentReportedFailure) || autoRecovered);
+  const effectiveSuccess = !nonceMismatch && (benignNoop || (isSuccess && !agentReportedFailure) || autoRecovered);
   if (!nonceMismatch) {
     const episodeOutcome = effectiveSuccess
       ? (autoRecovered || completionStatus.startsWith('partial') ? 'partial' : 'success')
@@ -5571,7 +5626,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Without this, the second run produces no VERDICT, _retryCount increments,
   // and after 3 such bailouts the WI flips to status=failed even though the
   // original review was posted on the first run.
-  if (effectiveSuccess && type === WORK_TYPE.REVIEW && meta?.item?.id) {
+  if (effectiveSuccess && type === WORK_TYPE.REVIEW && meta?.item?.id && !benignNoop) {
     const verdict = reviewVerdictFromCompletion(structuredCompletion) || parseReviewVerdict(resultSummary);
     if (!verdict && isReviewBailout(resultSummary)) {
       log('info', `Review ${meta.item.id} bailed out (review already posted) — treating as DONE without retry`);
@@ -5721,7 +5776,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   let completionContractFailure = null;
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
-    const nonTerminalCompletion = detectNonTerminalResultSummary(completionGateSummary, structuredCompletion, reportCompletion, { detectPhantom });
+    const nonTerminalCompletion = benignNoop
+      ? null
+      : detectNonTerminalResultSummary(completionGateSummary, structuredCompletion, reportCompletion, { detectPhantom });
     if (nonTerminalCompletion) {
       const isPhantomDetection = nonTerminalCompletion.phrase === 'phantom-completion';
       // P-e0b4f7a5 — before deferring a phantom retry, attempt to recover
@@ -5753,7 +5810,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // shipped, dispatch premise wrong, self-authored review, etc.). Skip the PR
   // attachment contract — a missing PR is intentional, not a silent failure.
   const noopRationale = (effectiveSuccess && meta?.item?.id && !skipDoneStatus)
-    ? parseCompletionNoop(structuredCompletion)
+    ? (parseCompletionNoop(structuredCompletion) || benignNoop)
     : null;
   if (noopRationale) {
     log('info', `No-op completion for ${meta.item.id}: ${noopRationale.slice(0, 200)}`);
@@ -5792,14 +5849,16 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       try { stampPrdItemWorkItemId(meta.item.id, meta.item.sourcePlan); } catch (err) { log('warn', `stampPrdItemWorkItemId: ${err.message}`); }
     }
     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}`); }
     }
   }
+  if (effectiveSuccess && !skipDoneStatus) {
+    // Coding WIs and direct PR-sourced fix dispatches share this follow-up path.
+    try { autoDispatchLiveValidationWi(meta, config, dispatchItem); } catch (err) { log('warn', `autoDispatchLiveValidationWi: ${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.
   if (!effectiveSuccess && meta?.item?.id && type === WORK_TYPE.DECOMPOSE) {
@@ -5994,7 +6053,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   let prFixBranchChange = null;
   let prFixBuildStillFailing = null;
-  if (type === WORK_TYPE.FIX && effectiveSuccess && meta?.pr?.id) {
+  if (shared.isFixLikeWorkType(type) && effectiveSuccess && meta?.pr?.id) {
     try {
       prFixBranchChange = await detectPrFixBranchChange(meta, config);
     } catch (err) {
@@ -6131,12 +6190,12 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const hardContractFail = completionContractFailure?.severity === 'hard'
     || completionContractFailure?.nonTerminal === true;
   const finalResult = hardContractFail ? DISPATCH_RESULT.ERROR : (effectiveSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR);
-  if (type === WORK_TYPE.REVIEW && finalResult === DISPATCH_RESULT.SUCCESS && !skipDoneStatus) {
+  if (type === WORK_TYPE.REVIEW && finalResult === DISPATCH_RESULT.SUCCESS && !skipDoneStatus && !benignNoop) {
     await updatePrAfterReview(agentId, meta?.pr, meta?.project, config, resultSummary, structuredCompletion, dispatchItem);
   } else if (type === WORK_TYPE.REVIEW) {
     log('warn', `Skipping PR review metadata update for ${meta?.pr?.id || meta?.pr?.url || '(unknown PR)'} because review dispatch ${dispatchItem.id} did not complete cleanly`);
   }
-  if (type === WORK_TYPE.FIX && effectiveSuccess) {
+  if (shared.isFixLikeWorkType(type) && effectiveSuccess) {
     updatePrAfterFix(meta?.pr, meta?.project, meta?.source, {
       branchChanged: fixCompletionChangedBranch(structuredCompletion),
       automationCauseKey: meta?.automationCauseKey,
@@ -6173,7 +6232,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         }
       } catch (err) { log('warn', `PRD sync after fix: ${err.message}`); }
     }
-  } else if (type === WORK_TYPE.FIX && meta?.pr?.id) {
+  } else if (shared.isFixLikeWorkType(type) && meta?.pr?.id) {
     // W-mph6br6a0006a2b9 (F9): the fix dispatch did not complete cleanly
     // (agent crash, non-zero exit, hard contract failure, or nonce mismatch),
     // so updatePrAfterFix above was skipped. Without a write here the PR's
@@ -6230,7 +6289,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const metricsResult = isAutoRetry ? 'retry' : finalResult;
   updateMetrics(agentId, dispatchItem, metricsResult, taskUsage, prsCreatedCount, model);
 
-  return { resultSummary, taskUsage, autoRecovered, structuredCompletion, completionContractFailure, agentReportedFailure, agentRetryable, nonceMismatch };
+  return { resultSummary, taskUsage, autoRecovered, structuredCompletion, completionContractFailure, agentReportedFailure, agentRetryable, nonceMismatch, benignNoop };
 }
 
 // ─── PR → PRD Status Sync ─────────────────────────────────────────────────────
@@ -6800,37 +6859,9 @@ function collapseAllDuplicatePrRecords(config) {
 // a coding WI (not one of the validation types itself). Skips if the coding WI
 // has no PR.
 //
-// W-mrdq22j700056c6c — gated to real code-authoring completions only. Only
-// item.type in {implement, implement:large, fix} ever spawns a follow-up
-// validation WI. Every other work-item type (review, test, verify, setup,
-// explore, ask, docs, decompose, ...) is excluded even when it resolves a PR
-// ref and autoDispatch is on, because those completions don't author a code
-// diff worth re-validating — e.g. a `review` dispatch that merely comments on
-// someone else's PR previously spawned a spurious "Validate: Review opg PR
-// #792 ..." follow-up. See the ELIGIBLE_TYPES check below.
-//
-// Files exactly ONE validation WI per coding-WI completion (W-mrhybval0001).
-// `liveValidation.type` still governs CHECKOUT ROUTING — the set of work-item
-// types that run in-place on the live checkout (see resolveCheckoutMode's
-// membership check) — but auto-validation no longer fans that array out into
-// one validation WI per type. That earlier behavior (W-mr2m1ute000a9c01)
-// conflated "which types run live" with "how many validation tasks to file";
-// a multi-select routing config would silently spawn N validation WIs after
-// every coding completion. Validation is a single downstream step, so we
-// collapse to one WI.
-//
-// liveValidation.type may be a single string (legacy / back-compat) or an
-// array of strings (multi-select hybrid types). We choose ONE validation type
-// for the single WI. It MUST be a member of lvTypes, otherwise resolveCheckoutMode
-// would route the validation WI to a worktree instead of the live checkout
-// (defeating hybrid validation). Preference order: the canonical `test` type
-// when configured, else the first configured live type. The completing item's
-// own type is excluded so a validation-type WI can't recursively validate
-// itself (anti-loop).
-//
-// Only these item.type values ever trigger this hook (see ELIGIBLE_TYPES
-// below) — real code-authoring completions, not review/test/verify/setup/
-// explore/ask/docs/decompose completions.
+// Only real code-authoring completions trigger the hook. The follow-up is
+// always a canonical `test` WI with the PR-focused `build-and-test` playbook;
+// liveValidation.type controls routing, not the semantic type of the task.
 //
 // Deduplicates per codingWiId: any non-terminal WI with
 // meta.liveValidationFor === codingWiId blocks a second dispatch, so only one
@@ -6852,22 +6883,30 @@ function collapseAllDuplicatePrRecords(config) {
 // verify, setup, explore, ask, docs, decompose, ...) is excluded even when it
 // resolves a PR ref, because those completions don't author a code diff
 // worth re-validating.
-const ELIGIBLE_LIVE_VALIDATION_TYPES = new Set([WORK_TYPE.IMPLEMENT, WORK_TYPE.IMPLEMENT_LARGE, WORK_TYPE.FIX]);
+const ELIGIBLE_LIVE_VALIDATION_TYPES = new Set([
+  WORK_TYPE.IMPLEMENT,
+  WORK_TYPE.IMPLEMENT_LARGE,
+  WORK_TYPE.FIX,
+  WORK_TYPE.BUILD_FIX_COMPLEX,
+]);
 
-function autoDispatchLiveValidationWi(meta, config) {
-  const item = meta?.item;
-  if (!item?.id || !item?.type) return;
+function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
+  const item = meta?.item || null;
+  const sourceType = item?.type || dispatchItem?.type || null;
+  const sourceKey = item?.id || dispatchItem?.id || null;
+  if (!sourceKey || !sourceType) return;
+  if (!item && !meta?.pr) return;
 
   // Never re-trigger off the completion of a WI that was itself auto-created
   // as a live-validation follow-up — that's what causes the infinite
   // "Validate: Validate: ..." cascade (W-mr9u39az000db5c2 / issue #708).
-  if (item.meta && item.meta.liveValidationFor) return;
+  if (item?.meta && item.meta.liveValidationFor) return;
 
-  // W-mrdq22j700056c6c — only implement/implement:large/fix completions ever
+  // Only implement/implement:large/fix/build-fix-complex completions ever
   // author a real code diff worth validating. Review, test, verify, setup,
   // explore, ask, docs, decompose, etc. completions must never spawn a
   // "Validate: ..." follow-up, even when they resolve a PR reference.
-  if (!ELIGIBLE_LIVE_VALIDATION_TYPES.has(item.type)) return;
+  if (!ELIGIBLE_LIVE_VALIDATION_TYPES.has(sourceType)) return;
 
   // Issue #716 — QA Session infrastructure WIs (SETUP/DRAFT/EXECUTE, tagged
   // via meta.sessionId and always dispatched with skipPr:true) never own a
@@ -6877,7 +6916,7 @@ function autoDispatchLiveValidationWi(meta, config) {
   // for all three phases) spawns spurious "Validate: QA Session ..." WIs the
   // moment any PR reference resolves against it (see the skipPr guard below
   // resolveWorkItemPrRecord in engine.js for the matching pre-dispatch fix).
-  if (item.skipPr || (item.meta && item.meta.sessionId)) return;
+  if (item?.skipPr || (item?.meta && item.meta.sessionId)) return;
 
   const projectName = meta?.project?.name;
   if (!projectName) return;
@@ -6887,23 +6926,8 @@ function autoDispatchLiveValidationWi(meta, config) {
   const project = projects.find(p => p && p.name === projectName);
   if (!project) return;
 
-  const lv = project.liveValidation;
-  if (!lv || lv.autoDispatch !== true || !lv.type) return;
-
-  const lvTypes = Array.isArray(lv.type) ? lv.type : [lv.type];
-
-  // Candidate validation types = configured live types minus the completing
-  // item's own type (avoid an infinite validate-the-validation loop).
-  const candidates = lvTypes.filter(t => t && t !== item.type);
-  if (candidates.length === 0) return;
-
-  // Collapse to a SINGLE validation type: prefer the canonical `test` type when
-  // it is a configured live type, else the first configured live type. Either
-  // way the chosen type is a member of lvTypes, so the validation WI routes to
-  // the live checkout (not a worktree).
-  const validationType = candidates.includes(WORK_TYPE.TEST)
-    ? WORK_TYPE.TEST
-    : candidates[0];
+  const validationType = shared.resolveLiveValidationAutoDispatchType(project);
+  if (!validationType) return;
 
   // Resolve PR reference: prefer the canonical stamped _pr field (set by
   // stampWiPrRef which runs earlier in runPostCompletionHooks), then fall
@@ -6915,11 +6939,22 @@ function autoDispatchLiveValidationWi(meta, config) {
   // (W-mq18ec6h000p7b87) and would otherwise let a non-fix WI (e.g.
   // 'implement'/'docs') that merely *mentions* an unrelated PR number in
   // prose trigger a live-validation dispatch against the wrong PR.
-  const prRef = item._pr || item._prUrl || shared.extractStructuredWorkItemPrRef(item) || null;
+  const prRef = item
+    ? (item._pr || item._prUrl || shared.extractStructuredWorkItemPrRef(item) || null)
+    : (meta?.pr || null);
   if (!prRef) return;
 
-  const codingWiId = item.id;
-  const wiScope = resolveWorkItemScope(meta);
+  const prUrl = item?._prUrl || (typeof prRef === 'object'
+    ? (prRef.url || prRef.webUrl || prRef.remoteUrl || null)
+    : (/^https?:\/\//i.test(String(prRef)) ? String(prRef) : null));
+  const prId = typeof prRef === 'object'
+    ? (prRef.id || prRef.pr_id || prRef.prId || prRef.pullRequestId || shared.getPrNumber(prRef))
+    : String(prRef);
+  const prTarget = prUrl || (prId != null ? String(prId) : null);
+  if (!prTarget) return;
+
+  const codingWiId = sourceKey;
+  const wiScope = item ? resolveWorkItemScope(meta) : projectName;
   if (!wiScope) return;
 
   try {
@@ -6942,7 +6977,7 @@ function autoDispatchLiveValidationWi(meta, config) {
         return items;
       }
 
-      const proposedTitle = 'Validate: ' + (item.title || codingWiId);
+      const proposedTitle = 'Validate: ' + (item?.title || meta?.pr?.title || codingWiId);
       // Defense-in-depth (belt-and-suspenders alongside the meta.liveValidationFor
       // guard above): never create a doubly-nested "Validate: Validate: ..."
       // title even if some future caller manages to invoke this function
@@ -6957,11 +6992,20 @@ function autoDispatchLiveValidationWi(meta, config) {
         title: proposedTitle,
         type: validationType,
         status: WI_STATUS.PENDING,
-        depends_on: [codingWiId],
-        references: [prRef],
-        meta: { liveValidationFor: codingWiId, liveValidationType: validationType },
+        depends_on: item?.id ? [codingWiId] : [],
+        targetPr: prTarget,
+        pr_id: prId != null ? String(prId) : prTarget,
+        references: prUrl
+          ? [{ url: prUrl, label: 'Source PR' }]
+          : [prTarget],
+        meta: {
+          liveValidationFor: codingWiId,
+          liveValidationType: validationType,
+          playbook: 'build-and-test',
+          ...(dispatchItem?.id ? { sourceDispatchId: dispatchItem.id } : {}),
+        },
         project: projectName,
-        priority: item.priority || 'medium',
+        priority: item?.priority || 'medium',
         created: ts(),
         createdBy: 'lifecycle:live-validation-auto-dispatch',
       };
@@ -6999,6 +7043,7 @@ module.exports = {
   parseReviewVerdict,
   isReviewBailout,
   parseCompletionNoop,
+  classifyBenignZeroTargetOutcome, // exported for testing
   detectNonTerminalResultSummary,
   deferNonTerminalCompletion,
   deferPhantomCompletion,