@yemi33/minions 0.1.2380 → 0.1.2382

package/engine/runtimes/claude.js

@@ -838,6 +838,12 @@ const capabilities = {
   budgetCap: true,
   // Supports `--bare` (suppress CLAUDE.md auto-discovery)
   bareMode: true,
+  // The Claude Code CLI reads repo-authored CLAUDE.md files itself at startup
+  // (unless `--bare`). TRUE here tells the engine's CLAUDE.md-propagation layer
+  // (engine/claude-md-context.js, injected in engine/playbook.js) to SKIP this
+  // runtime — re-injecting CLAUDE.md content into the prompt would double it.
+  // Copilot/Codex set this false because they have no native CLAUDE.md auto-load.
+  claudeMdNativeDiscovery: true,
   // Supports `--fallback-model <id>`
   fallbackModel: true,
   // Engine controls session persistence (writes session.json on completion)

package/engine/runtimes/codex.js

@@ -840,6 +840,20 @@ function getModelCacheKey({ env = process.env, timeoutMs = 10000 } = {}) {
   }
 }
 
+function getModelCacheKey({ env = process.env, timeoutMs = 10000 } = {}) {
+  const resolved = resolveBinary({ env });
+  if (!resolved) return null;
+  try {
+    return _execFileCapture(resolved.bin, [...(resolved.leadingArgs || []), '--version'], {
+      env,
+      timeoutMs,
+      native: resolved.native,
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 function createStreamConsumer(ctx) {
   let deltaText = '';
   let terminalText = '';
@@ -901,6 +915,10 @@ const capabilities = {
   budgetCap: false,
   bareMode: false,
   fallbackModel: false,
+  // Codex has no native CLAUDE.md auto-load — FALSE opts it into the engine's
+  // CLAUDE.md-propagation layer (engine/claude-md-context.js) so repo-authored
+  // CLAUDE.md guidance reaches the agent prompt.
+  claudeMdNativeDiscovery: false,
   sessionPersistenceControl: false,
   resumePromptCarryover: true,
   streamConsumer: true,

package/engine/runtimes/copilot.js

@@ -1273,6 +1273,13 @@ const capabilities = {
   budgetCap: false,
   // No --bare equivalent.
   bareMode: false,
+  // Copilot has NO native CLAUDE.md auto-load — it only reads its own AGENTS.md
+  // (native custom-instruction discovery owned by the CLI itself). FALSE
+  // here opts this runtime INTO the engine's CLAUDE.md-propagation layer
+  // (engine/claude-md-context.js) so repo-authored CLAUDE.md guidance is
+  // surfaced in the prompt. This is orthogonal to AGENTS.md discovery —
+  // CLAUDE.md carries no split-brain risk because Copilot never reads it itself.
+  claudeMdNativeDiscovery: false,
   // No --fallback-model
   fallbackModel: false,
   // Copilot manages session state internally in ~/.copilot/session-state/

package/engine/shared.js

@@ -1037,8 +1037,16 @@ function validateDispatchTmpDir(dirPath) {
 
 function removeDispatchTmpDir(dirPath) {
   if (!validateDispatchTmpDir(dirPath)) return false;
-  try { fs.rmSync(dirPath, { recursive: true, force: true }); return true; }
-  catch { return false; }
+  try {
+    _retryFsOp(
+      () => fs.rmSync(dirPath, { recursive: true, force: true }),
+      `removeDispatchTmpDir(${dirPath})`
+    );
+    return true;
+  } catch (e) {
+    log('warn', `removeDispatchTmpDir failed after retries: ${e.message}`, { path: dirPath, error: e.code });
+    return false;
+  }
 }
 
 // Read a file using O_NOFOLLOW where the platform supports it. On Windows
@@ -1439,48 +1447,37 @@ function withFileLock(lockPath, fn, {
         const isLockRaceErr = err.code === 'EEXIST' ||
           (process.platform === 'win32' && err.code === 'EPERM');
         if (!isLockRaceErr) throw err;
-        // P-b7d4e8f2 — Stale-lock check combines mtime age with PID liveness:
-        //   1. If mtime <= LOCK_STALE_MS  → never reap (recently active).
-        //   2. If JSON-parsable {pid, ts}:
-        //      - dead PID                 → reap.
-        //      - alive PID, mtime <= 5×   → don't reap (legitimate slow holder).
-        //      - alive PID, mtime > 5×    → reap (last-resort guard against
-        //                                    stuck holders that never released).
-        //   3. Legacy / empty / non-JSON lockfile → mtime-only path (reap).
+        // PID-owned locks are safe to reap as soon as their owner is dead.
+        // Alive owners retain the 5× stale window; legacy/partial lockfiles
+        // without a readable PID retain the mtime-only stale window.
         try {
           const stat = fs.statSync(lockPath);
           const mtimeAge = Date.now() - stat.mtimeMs;
-          if (mtimeAge > LOCK_STALE_MS) {
-            let holderPid = null;
-            try {
-              const raw = fs.readFileSync(lockPath, 'utf8');
-              const parsed = JSON.parse(raw);
-              if (parsed && Number.isFinite(parsed.pid) && parsed.pid > 0) {
-                holderPid = parsed.pid;
-              }
-            } catch { /* legacy/empty/corrupt lock → fall through to mtime-only */ }
-
-            let shouldReap;
-            if (holderPid !== null) {
-              shouldReap = !processUtils.isPidAlive(holderPid) || mtimeAge > LOCK_STALE_MS * 5;
-            } else {
-              // Legacy empty/non-JSON lockfile: trust mtime alone
-              shouldReap = true;
+          let holderPid = null;
+          try {
+            const raw = fs.readFileSync(lockPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && Number.isFinite(parsed.pid) && parsed.pid > 0) {
+              holderPid = parsed.pid;
             }
+          } catch { /* legacy/empty/corrupt lock → mtime-only fallback */ }
 
-            if (shouldReap) {
-              try {
-                fs.unlinkSync(lockPath);
-              } catch (unlinkErr) {
-                // ENOENT: another process deleted the lock between stat and unlink — safe to retry.
-                // EPERM on Windows: file is in 'pending delete' state from a concurrent
-                // reaper — the OS will finalize the delete shortly; retry will succeed.
-                const tolerable = unlinkErr.code === 'ENOENT' ||
-                  (process.platform === 'win32' && unlinkErr.code === 'EPERM');
-                if (!tolerable) throw unlinkErr;
-              }
-              continue; // lock just removed — retry immediately
+          const shouldReap = holderPid !== null
+            ? !processUtils.isPidAlive(holderPid) || mtimeAge > LOCK_STALE_MS * 5
+            : mtimeAge > LOCK_STALE_MS;
+
+          if (shouldReap) {
+            try {
+              fs.unlinkSync(lockPath);
+            } catch (unlinkErr) {
+              // ENOENT: another process deleted the lock between stat and unlink — safe to retry.
+              // EPERM on Windows: file is in 'pending delete' state from a concurrent
+              // reaper — the OS will finalize the delete shortly; retry will succeed.
+              const tolerable = unlinkErr.code === 'ENOENT' ||
+                (process.platform === 'win32' && unlinkErr.code === 'EPERM');
+              if (!tolerable) throw unlinkErr;
             }
+            continue; // lock just removed — retry immediately
           }
         } catch (staleErr) {
           // ENOENT from statSync: lock file disappeared between EEXIST and stat — retry will succeed.
@@ -2481,6 +2478,80 @@ function classifyInboxItem(name, content) {
 // config.json keep working without an on-disk rewrite. Tracked in
 // docs/deprecated.json (id: worktreemode-field-rename).
 const CHECKOUT_MODES = Object.freeze({ WORKTREE: 'worktree', LIVE: 'live' });
+const LEGACY_LIVE_VALIDATION_TYPE_ALIASES = Object.freeze({
+  'build-and-test': 'test',
+});
+
+function normalizeLiveValidationWorkType(value) {
+  if (typeof value !== 'string') return '';
+  const type = value.trim();
+  return LEGACY_LIVE_VALIDATION_TYPE_ALIASES[type] || type;
+}
+
+function inspectLiveValidation(value) {
+  if (value === undefined || value === null || value === '') {
+    return { configured: false, types: [], normalizedType: undefined, error: null };
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    return {
+      configured: true,
+      types: [],
+      normalizedType: undefined,
+      error: 'Invalid liveValidation: must be an object { type, autoDispatch }.',
+    };
+  }
+
+  const rawType = value.type;
+  const rawTypes = Array.isArray(rawType) ? rawType : [rawType];
+  if (
+    (typeof rawType !== 'string' && !Array.isArray(rawType))
+    || rawTypes.length === 0
+    || !rawTypes.every(type => typeof type === 'string' && type.trim())
+  ) {
+    const accepted = [...LIVE_VALIDATION_WORK_TYPES].sort().join(', ');
+    return {
+      configured: true,
+      types: [],
+      normalizedType: undefined,
+      error: `Invalid liveValidation: "type" is required and must be a non-empty string, or a non-empty array of live-capable work-item types. Accepted values: ${accepted}.`,
+    };
+  }
+
+  const normalizedTypes = [...new Set(rawTypes.map(normalizeLiveValidationWorkType))];
+  const types = normalizedTypes.filter(type => LIVE_VALIDATION_WORK_TYPES.has(type));
+  const invalidTypes = normalizedTypes.filter(type => !LIVE_VALIDATION_WORK_TYPES.has(type));
+  let error = null;
+  if (invalidTypes.length > 0) {
+    const accepted = [...LIVE_VALIDATION_WORK_TYPES].sort().join(', ');
+    error = `Invalid liveValidation type(s): ${invalidTypes.join(', ')}. Accepted values: ${accepted}.`;
+  }
+  if (!error && Object.prototype.hasOwnProperty.call(value, 'autoDispatch')) {
+    if (typeof value.autoDispatch !== 'boolean') {
+      error = 'Invalid liveValidation: "autoDispatch" must be a boolean.';
+    } else if (value.autoDispatch && !normalizedTypes.includes(WORK_TYPE.TEST)) {
+      error = 'Invalid liveValidation: autoDispatch requires "test" in liveValidation.type so the generated validation work item runs on the live checkout.';
+    }
+  }
+  return {
+    configured: true,
+    types,
+    normalizedType: Array.isArray(rawType) ? normalizedTypes : normalizedTypes[0],
+    error,
+  };
+}
+
+// Return the canonical, live-capable work-item types configured for a hybrid
+// project. Raw config is read defensively because config.json can predate the
+// validator; invalid entries are ignored rather than turning hybrid into full
+// live mode. `build-and-test` is retained as a read-compat alias for `test`.
+function resolveLiveValidationTypes(project) {
+  return inspectLiveValidation(project && project.liveValidation).types;
+}
+
+function isLiveValidationConfigInvalid(project) {
+  const inspection = inspectLiveValidation(project && project.liveValidation);
+  return inspection.configured && !!inspection.error;
+}
 
 // Resolve a project's effective checkout mode, honoring the legacy
 // `worktreeMode` field for back-compat. Reading order:
@@ -2492,37 +2563,37 @@ const CHECKOUT_MODES = Object.freeze({ WORKTREE: 'worktree', LIVE: 'live' });
 //
 // Optional second argument `workItemType` enables liveValidation routing:
 //   If checkoutMode === 'live' AND project.liveValidation is set:
-//     - workItemType matches liveValidation.type → 'live' (validation serialized)
-//     - otherwise → 'worktree' (coding escapes the live cap)
+//     - workItemType matches liveValidation.type → 'live'
+//     - otherwise → 'worktree'
 //   liveValidation without checkoutMode: 'live' is ignored with a warn log.
 function resolveCheckoutMode(project, workItemType) {
   if (!project || typeof project !== 'object') return CHECKOUT_MODES.WORKTREE;
   const canonical = project.checkoutMode;
+  const legacy = project.worktreeMode;
+  let effectiveMode = CHECKOUT_MODES.WORKTREE;
+  if (canonical === CHECKOUT_MODES.LIVE || canonical === CHECKOUT_MODES.WORKTREE) {
+    effectiveMode = canonical;
+  } else if (legacy === 'live') {
+    effectiveMode = CHECKOUT_MODES.LIVE;
+  }
   // liveValidation without checkoutMode: 'live' is a misconfiguration — warn and ignore.
-  if (project.liveValidation && canonical !== CHECKOUT_MODES.LIVE) {
+  if (project.liveValidation && effectiveMode !== CHECKOUT_MODES.LIVE) {
     log('warn', 'resolveCheckoutMode: liveValidation is set but checkoutMode is not "live" — liveValidation ignored',
       { projectName: project.name });
   }
-  if (canonical === CHECKOUT_MODES.LIVE) {
+  if (effectiveMode === CHECKOUT_MODES.LIVE) {
     // Apply liveValidation routing when the block is present and workItemType is provided.
     // liveValidation.type may be a single string (legacy / back-compat) or an
     // array of strings (W-mr2m1ute000a9c01, multi-select hybrid types) —
     // normalize to an array and do a membership check so either shape works.
     if (project.liveValidation && workItemType !== undefined) {
-      const lvTypes = Array.isArray(project.liveValidation.type)
-        ? project.liveValidation.type
-        : [project.liveValidation.type];
-      return lvTypes.includes(workItemType)
+      const lvTypes = resolveLiveValidationTypes(project);
+      return lvTypes.includes(normalizeLiveValidationWorkType(workItemType))
         ? CHECKOUT_MODES.LIVE
         : CHECKOUT_MODES.WORKTREE;
     }
     return CHECKOUT_MODES.LIVE;
   }
-  if (canonical === CHECKOUT_MODES.WORKTREE) return CHECKOUT_MODES.WORKTREE;
-  // Legacy field fallback (only consulted when checkoutMode is absent/unknown).
-  const legacy = project.worktreeMode;
-  if (legacy === 'live') return CHECKOUT_MODES.LIVE;
-  // legacy 'isolated' (and anything else) → the default worktree behavior.
   return CHECKOUT_MODES.WORKTREE;
 }
 
@@ -2538,9 +2609,10 @@ function isLiveCheckoutProject(project) {
 // anything else (undefined / null / string) is treated as unset so the next
 // tier (or the `false` default) decides. When ON and a live-checkout tree is
 // dirty, `engine/live-checkout.js#prepareLiveCheckout` runs
-// `git fetch origin` + `git reset --hard origin/<branch>` instead of refusing
-// with LIVE_CHECKOUT_DIRTY (the reset DISCARDS the operator's uncommitted work,
-// so it is opt-in). Sibling of `resolveCheckoutMode` — pure, no I/O.
+// `git reset --hard HEAD` + `git clean -fd` instead of refusing with
+// LIVE_CHECKOUT_DIRTY. This discards uncommitted tracked and untracked work but
+// preserves the current branch and committed history, so it is opt-in. Sibling
+// of `resolveCheckoutMode` — pure, no I/O.
 function resolveLiveCheckoutAutoReset(project, engine) {
   if (project && typeof project === 'object' && typeof project.liveCheckoutAutoReset === 'boolean') {
     return project.liveCheckoutAutoReset;
@@ -2605,16 +2677,14 @@ function validateCheckoutMode(value) {
 }
 
 // Validate + normalize a per-project `liveValidation` block (hybrid mode).
-// Hybrid = checkoutMode:'live' + liveValidation:{ type, autoDispatch }: coding
-// work items author in isolated worktrees (escaping the live cap) while only
-// work items whose type is IN liveValidation.type run in-place on the live
-// checkout. See resolveCheckoutMode (which routes per work-item type) and
-// docs/live-checkout-mode.md.
+// Hybrid = checkoutMode:'live' + liveValidation:{ type, autoDispatch }: only
+// work items whose type is IN liveValidation.type run in-place; all other types
+// use isolated worktrees. See resolveCheckoutMode and docs/live-checkout-mode.md.
 //
 // `type` may be a single work-item-type string (legacy / back-compat) OR a
 // non-empty array of non-empty-string work-item types
 // (W-mr2m1ute000a9c01 — multi-select hybrid types, e.g. both "implement" and
-// "fix" validate live while other types stay in worktrees). Every reader of
+// "fix" run live while other types stay in worktrees). Every reader of
 // liveValidation.type (resolveCheckoutMode, lifecycle.autoDispatchLiveValidationWi,
 // dashboard project mapper / pill / CC label) must handle BOTH shapes —
 // existing config.json entries with a plain string `type` continue to work
@@ -2623,10 +2693,8 @@ function validateCheckoutMode(value) {
 // Returns:
 //   - undefined → caller should clear the field (empty / null / '' input)
 //   - { type, autoDispatch? } normalized object on success, where `type` is
-//     whatever shape the caller passed in (string stays a string; array stays
-//     a deduped array) — we intentionally do NOT force single-string input
-//     into an array so already-persisted single-type configs round-trip
-//     byte-identical through a Settings save that doesn't touch this field.
+//     the caller's input shape (string stays a string; array stays an array),
+//     with values trimmed, normalized, and deduplicated.
 // Throws HTTP 400 (via _httpError) on malformed input, or when the effective
 // checkout mode is not 'live' (liveValidation is meaningless without it — it is
 // silently ignored at resolve time, so we refuse to persist a misconfiguration).
@@ -2636,45 +2704,15 @@ function validateCheckoutMode(value) {
 // applied so the gate sees the intended final mode.
 function validateLiveValidation(value, opts) {
   if (value === undefined || value === null || value === '') return undefined;
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    throw _httpError(400, 'Invalid liveValidation: must be an object { type, autoDispatch }.');
-  }
+  const inspection = inspectLiveValidation(value);
+  if (inspection.error) throw _httpError(400, inspection.error);
   const checkoutMode = opts && opts.checkoutMode;
   if (checkoutMode !== CHECKOUT_MODES.LIVE) {
     throw _httpError(400, 'liveValidation requires checkoutMode "live" (hybrid mode). Set checkoutMode to "live" first, or clear liveValidation.');
   }
-  const typeErrorMsg = 'Invalid liveValidation: "type" is required and must be a non-empty string, or a non-empty array of non-empty-string work-item types — the work-item type(s) that run on the live checkout (e.g. "build-and-test" or ["implement", "fix"]).';
-  const rawType = value.type;
-  let out;
-  if (typeof rawType === 'string') {
-    const trimmed = rawType.trim();
-    if (!trimmed) throw _httpError(400, typeErrorMsg);
-    out = { type: trimmed };
-  } else if (Array.isArray(rawType)) {
-    if (!rawType.every(t => typeof t === 'string' && t.trim().length > 0)) {
-      throw _httpError(400, typeErrorMsg);
-    }
-    // Dedupe (preserving first-seen order) and cap at the number of distinct
-    // work-item types the engine recognizes — a longer array can only be
-    // full of duplicates or invented types.
-    const deduped = [...new Set(rawType.map(t => t.trim()))];
-    if (deduped.length === 0) throw _httpError(400, typeErrorMsg);
-    if (deduped.length > VALID_WORK_TYPES.size) {
-      throw _httpError(400, `Invalid liveValidation: "type" array has ${deduped.length} entries, more than the ${VALID_WORK_TYPES.size} distinct work-item types the engine recognizes — remove duplicates or invalid types.`);
-    }
-    out = { type: deduped };
-  } else {
-    throw _httpError(400, typeErrorMsg);
-  }
-  // autoDispatch (optional): when true, lifecycle auto-creates a SINGLE
-  // validation WI after each coding WI completes with a PR
-  // (engine/lifecycle.js autoDispatchLiveValidationWi). Even when `type` is a
-  // multi-entry array (which drives checkout ROUTING — the types that run live),
-  // exactly one validation WI is filed, of the canonical `test` type when
-  // configured else the first configured live type. Coerce to a strict
-  // boolean; absent leaves it off so the operator opts in explicitly.
+  const out = { type: inspection.normalizedType };
   if (Object.prototype.hasOwnProperty.call(value, 'autoDispatch')) {
-    out.autoDispatch = !!value.autoDispatch;
+    out.autoDispatch = value.autoDispatch;
   }
   return out;
 }
@@ -3079,9 +3117,8 @@ const ENGINE_DEFAULTS = {
   // 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.
+  // rejected this many consecutive times, the WI stays pending but is marked
+  // exhausted so discovery pauses until an operator edits it.
   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, // Master gate for platform vote mutations; local verdicts remain informational when false.
@@ -3214,6 +3251,7 @@ const ENGINE_DEFAULTS = {
   maxMeetingPromptBytes: 16 * 1024, // cap meeting findings/debate context injected into prompts
   maxMeetingHumanNotesBytes: 2 * 1024, // cap human note bullet lists injected into meeting prompts
   maxPipelineMeetingContextBytes: 16 * 1024, // cap aggregated meeting/dependency context for pipeline plan generation
+  maxPipelineStageHandoffBytes: 32 * 1024, // cap current-run note content exposed through {{stages.<id>.handoff}}
   notesArchiveMaxFiles: 2000, // keep notes/archive bounded during periodic cleanup
   // ── Worktree pool (W-mp73ya3e000me6c5) ─────────────────────────────────────
   // Per-project warm pool: completed worktrees are parked detached at
@@ -3283,7 +3321,7 @@ const ENGINE_DEFAULTS = {
       'node', 'bun', 'npm', 'npx', 'pnpm', 'yarn',
       'python', 'python3', 'pip', 'pip3',
       'docker', 'podman',
-      'adb', 'emulator',
+      'adb', 'emulator', 'maestro',
       'gradle', 'gradlew', 'mvn',
       'pwsh', 'powershell', 'bash', 'sh',
       'curl', 'wget',
@@ -3588,6 +3626,28 @@ function resolveAgentBareMode(agent, engine) {
   return false;
 }
 
+// W-mrdon0pe000l045a — resolve whether repo-authored CLAUDE.md instructions
+// should be propagated into the prompt for runtimes that don't auto-discover
+// CLAUDE.md natively (Copilot/Codex). Precedence mirrors
+// `resolveLiveCheckoutAutoReset`:
+//   1. per-project boolean `project.propagateClaudeMdForNonClaudeRuntimes`
+//   2. fleet-wide boolean `engine.propagateClaudeMdForNonClaudeRuntimes`
+//   3. hardcoded default TRUE (additive, on by default)
+// Only an explicit boolean counts as "set" at either level — undefined/null/
+// string are treated as unset so the next tier (or the TRUE default) decides.
+// This gate is orthogonal to each runtime's native AGENTS.md / repo-instruction
+// discovery by design (see ENGINE_DEFAULTS.propagateClaudeMdForNonClaudeRuntimes).
+// Pure, no I/O.
+function resolvePropagateClaudeMdForNonClaudeRuntimes(project, engine) {
+  if (project && typeof project === 'object' && typeof project.propagateClaudeMdForNonClaudeRuntimes === 'boolean') {
+    return project.propagateClaudeMdForNonClaudeRuntimes;
+  }
+  if (engine && typeof engine === 'object' && typeof engine.propagateClaudeMdForNonClaudeRuntimes === 'boolean') {
+    return engine.propagateClaudeMdForNonClaudeRuntimes;
+  }
+  return true;
+}
+
 // ─── Legacy ccModel → defaultModel Migration ─────────────────────────────────
 //
 // Pre-P-3b8e5f1d, `engine.ccModel` was the single fleet-wide model knob (it
@@ -3902,6 +3962,15 @@ const WORK_TYPE = {
   BUILD_FIX_COMPLEX: 'build-fix-complex',
 };
 
+const FIX_LIKE_WORK_TYPES = new Set([
+  WORK_TYPE.FIX,
+  WORK_TYPE.BUILD_FIX_COMPLEX,
+]);
+
+function isFixLikeWorkType(type) {
+  return FIX_LIKE_WORK_TYPES.has(type);
+}
+
 // Work types whose dispatch path requires a per-project git worktree. The
 // engine's spawnAgent uses the project's `localPath` as the worktree root —
 // without an owning project the rootDir falls back to MINIONS_DIR's parent,
@@ -3940,6 +4009,21 @@ const WORKTREE_REQUIRING_TYPES = new Set([
   WORK_TYPE.DOCS,
 ]);
 
+// Hybrid routing is meaningful only for work types that would otherwise need
+// an isolated project worktree. Read-only root tasks already run from the
+// project/root path and therefore gain nothing from a live-validation entry.
+const LIVE_VALIDATION_WORK_TYPES = new Set(WORKTREE_REQUIRING_TYPES);
+
+function resolveLiveValidationAutoDispatchType(project) {
+  if (!project?.liveValidation || project.liveValidation.autoDispatch !== true) return null;
+  if (resolveCheckoutMode(project) !== CHECKOUT_MODES.LIVE) return null;
+  const inspection = inspectLiveValidation(project.liveValidation);
+  if (inspection.error) return null;
+  return inspection.types.includes(WORK_TYPE.TEST)
+    ? WORK_TYPE.TEST
+    : null;
+}
+
 // W-mpxqkkn300121d21 — Valid `type` strings the materializer will honor when a
 // PRD missing_feature carries one. Excludes orchestration-only types that the
 // plan→PRD→materializer pipeline never produces (PLAN, PLAN_TO_PRD, MEETING)
@@ -4435,7 +4519,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', // Verify completed without an attached or tracked PR.
   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.
+  PRE_DISPATCH_EVAL_STUCK: 'pre-dispatch-eval-stuck', // Legacy persisted classification normalized by migration 025. New exhausted evaluations remain pending with _preDispatchEval.exhausted so they are not counted as agent execution failures.
   UNKNOWN: 'unknown',                     // Unclassified failure
 };
 
@@ -7295,7 +7379,12 @@ function classifyPrRefForVerification(prRef, project = null) {
 //   { skipped: true, reason }            — not a pr-requiring type / no ref / no URL / upsert error
 //   { alreadyEnrolled: true, id }        — PR already tracked
 //   { enrolled: true, id, scope }        — newly enrolled
-const _PR_REQUIRING_TYPES = new Set([WORK_TYPE.FIX, WORK_TYPE.REVIEW, WORK_TYPE.TEST]);
+const _PR_REQUIRING_TYPES = new Set([
+  WORK_TYPE.FIX,
+  WORK_TYPE.BUILD_FIX_COMPLEX,
+  WORK_TYPE.REVIEW,
+  WORK_TYPE.TEST,
+]);
 function autoEnrollPrFromWorkItem(item, project, minionsDir) {
   if (!item || !_PR_REQUIRING_TYPES.has(item.type)) return { skipped: true, reason: 'not-pr-requiring-type' };
   const prRef = extractStructuredWorkItemPrRef(item);
@@ -8421,12 +8510,12 @@ module.exports = {
   ENGINE_DEFAULTS,
   resolvePollFlag, // P-c4d8e1a3 — granular per-poller flag resolution
   resolveAgentCli, resolveCcCli, resolveCcUseWorkerPool, resolveAgentUseWorkerPool, resolveAgentAcpPoolSize, resolveAgentModel, resolveCcModel,
-  resolveAgentMaxBudget, resolveAgentBareMode,
+  resolveAgentMaxBudget, resolveAgentBareMode, resolvePropagateClaudeMdForNonClaudeRuntimes,
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
   backfillProjectWorkSourceDefaults,
-  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, isPrdArchived, isDefunctPrd, WORK_TYPE, WORKTREE_REQUIRING_TYPES, VALID_WORK_TYPES, resolveWorkItemTypeFromPrdItem, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, RETRY_DELAY_MS, ADO_TOKEN_REFRESH_MAX_RETRIES, DISPATCH_RESULT, mutateMetrics, mutateWatches, mutateScheduleRuns, mutatePipelineRuns, mutateManagedProcesses, mutateWorktreePool, mutateQaRuns, mutateQaSessions, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject, extractPlanTargetProjects,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, isPrdArchived, isDefunctPrd, WORK_TYPE, isFixLikeWorkType, WORKTREE_REQUIRING_TYPES, LIVE_VALIDATION_WORK_TYPES, VALID_WORK_TYPES, resolveWorkItemTypeFromPrdItem, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, RETRY_DELAY_MS, ADO_TOKEN_REFRESH_MAX_RETRIES, DISPATCH_RESULT, mutateMetrics, mutateWatches, mutateScheduleRuns, mutatePipelineRuns, mutateManagedProcesses, mutateWorktreePool, mutateQaRuns, mutateQaSessions, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject, extractPlanTargetProjects,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS, WATCH_ACTION_TYPE,
   WATCH_STALLED_DEFAULT_TICKS, WATCH_STUCK_STAGE_DEFAULT_TICKS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
@@ -8546,6 +8635,10 @@ module.exports = {
   CHECKOUT_MODES,
   validateCheckoutMode,
   validateLiveValidation,
+  normalizeLiveValidationWorkType,
+  resolveLiveValidationTypes,
+  isLiveValidationConfigInvalid,
+  resolveLiveValidationAutoDispatchType,
   resolveCheckoutMode,
   isLiveCheckoutProject,
   resolveLiveCheckoutAutoReset,