@yemi33/minions 0.1.2305 → 0.1.2307

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/cli.js

@@ -250,7 +250,7 @@ const CLI_COMMAND_DOCS = Object.freeze({
   'mcp-sync': { args: '',                      summary: 'Print harness propagation diagnostic (same source as `minions doctor --harness`; read-only, no writes)' },
   doctor:     { args: '[--harness]',           summary: 'Check prerequisites and runtime health (--harness: print harness propagation diagnostic)' },
   config:     { args: 'set-cli <R> [--model M]', summary: 'Persist defaultCli/defaultModel without starting' },
-  pr:         { args: 'comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] [--resolved] [--harness-file <f>|--harness-json <j>] [--body-file <f>|--body <text>]', summary: 'Post a marker-prepended PR comment via gh (ADO: --resolved posts pre-closed)' },
+  pr:         { args: 'comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] [--resolved] [--harness-file <f>|--harness-json <j>] [--skill-skipped-file <f>|--skill-skipped-json <j>] [--body-file <f>|--body <text>]', summary: 'Post a marker-prepended PR comment via gh (ADO: --resolved posts pre-closed)' },
   bridge:     { args: 'status|health|enable|disable',         summary: 'Constellation bridge: toggle and inspect the read-only cross-repo feed' },
 });
 
@@ -475,6 +475,49 @@ function resolveHarnessUsedForComment(flags) {
   return shared.groundHarnessUsed(parsed, propagated);
 }
 
+// resolveSkillSkippedForComment(flags) — W-mr287sc0000uc214. Turn the
+// `minions pr comment` skip flags into a canonical `{name, reason}` record for
+// the posters' `skillSkipped` param (engine/gh-comment.js / engine/ado-comment.js),
+// which fold it via buildMinionsCommentBody -> buildSkippedSkillSection into a
+// VISIBLE callout in the same comment as the verdict.
+//
+// Source precedence mirrors the harness resolver: `--skill-skipped-file <path>`
+// (JSON on disk) wins over the inline `--skill-skipped-json <json>`; neither
+// supplied -> returns undefined so the comment body is byte-identical to today
+// (no callout). Read/parse failures are HARD errors (process.exit(2)). Accepts
+// the raw `{name, reason}` shape or a `meta.skill` / `meta.review` wrapper; a
+// record with no non-empty `name` yields undefined (nothing to surface).
+function resolveSkillSkippedForComment(flags) {
+  const fileArg = flags['skill-skipped-file'];
+  const jsonArg = flags['skill-skipped-json'];
+
+  let raw;
+  if (fileArg !== undefined) {
+    try {
+      raw = fs.readFileSync(fileArg, 'utf8');
+    } catch (e) {
+      console.error(`error: could not read --skill-skipped-file ${fileArg}: ${e.message}`);
+      process.exit(2);
+    }
+  } else if (jsonArg !== undefined) {
+    raw = String(jsonArg);
+  } else {
+    return undefined;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    const src = fileArg !== undefined ? `--skill-skipped-file ${fileArg}` : '--skill-skipped-json';
+    console.error(`error: invalid JSON in ${src}: ${e.message}`);
+    process.exit(2);
+  }
+
+  const { _extractSkillSkipped } = require('./comment-format');
+  return _extractSkillSkipped(parsed) || undefined;
+}
+
 const commands = {
   start(...startArgs) {
     // Apply --cli / --model fleet flags before any engine wiring touches
@@ -2044,6 +2087,10 @@ const commands = {
       console.log('  --harness-file <path>   JSON file with the { skills, mcpServers, commands, docs } record (wins over --harness-json)');
       console.log('  --harness-json <json>   same record inline as a JSON string');
       console.log('  --dispatch-id <id>      grounding manifest override (else basename of $MINIONS_COMPLETION_REPORT)');
+      console.log('');
+      console.log('Skipped in-scope project skill (folded in as a VISIBLE "⚠️ Skipped project skill" callout):');
+      console.log('  --skill-skipped-file <path>   JSON file with the { name, reason } skip record (wins over --skill-skipped-json)');
+      console.log('  --skill-skipped-json <json>   same record inline as a JSON string (also accepts a meta.skill/meta.review wrapper)');
       console.log('  --resolved              (ADO only) post the thread pre-resolved/closed — for non-actionable FYI/praise notes');
       console.log('');
       console.log('Posts a PR comment with the hidden minions marker, the collapsible');
@@ -2117,6 +2164,12 @@ const commands = {
     // -> undefined -> body byte-identical to today.
     const harnessUsed = resolveHarnessUsedForComment(flags);
 
+    // W-mr287sc0000uc214 — thread the skipped-in-scope-project-skill self-report
+    // into both posters so it's surfaced as a VISIBLE callout in the same comment
+    // as the verdict (not buried in the completion-report JSON). Absent flags
+    // -> undefined -> body byte-identical to today.
+    const skillSkipped = resolveSkillSkippedForComment(flags);
+
     // ── Azure DevOps: <prNumber> --host ado --ado-org --ado-project --repo-id ──
     if (isAdo) {
       const [prNumberRaw] = positional;
@@ -2136,7 +2189,7 @@ const commands = {
       const orgBase = flags['org-base'] || `https://dev.azure.com/${adoOrg}`;
       const adoComment = require('./ado-comment');
       adoComment.postAdoPrComment({
-        orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId, harnessUsed,
+        orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId, harnessUsed, skillSkipped,
         resolved: flags.resolved === true,
       }).then((result) => {
         if (result && result.threadId) {
@@ -2175,7 +2228,7 @@ const commands = {
 
     try {
       const result = ghComment.postPrComment({
-        repo, prNumber, body, agentId, kind, workItemId, harnessUsed,
+        repo, prNumber, body, agentId, kind, workItemId, harnessUsed, skillSkipped,
       });
       if (result.output) console.log(result.output);
     } catch (e) {
@@ -2316,6 +2369,8 @@ module.exports = {
   _dispatchSessionBranch: dispatchSessionBranch,
   // P-7a3c9e21 — harness-flag resolver exported for CLI-threading tests.
   _resolveHarnessUsedForComment: resolveHarnessUsedForComment,
+  // W-mr287sc0000uc214 — skipped-project-skill flag resolver exported for tests.
+  _resolveSkillSkippedForComment: resolveSkillSkippedForComment,
   // W-mpcyvff6000pf828 (#2653) — heartbeat writer + factory exported for tests
   _writeHeartbeatNow: writeHeartbeatNow,
   _createHeartbeatInterval: createHeartbeatInterval,

package/engine/comment-format.js

@@ -36,6 +36,13 @@ const HARNESS_KINDS = [
 const HARNESS_SUMMARY_ICON = '\u{1F9F0}'; // 🧰
 const HARNESS_WARN_ICON = '⚠️'; // ⚠️
 
+// W-mr287sc0000uc214 — the visible "skipped project skill" callout. The label is
+// a stable literal so buildMinionsCommentBody can dedupe (never stack two
+// callouts) and tests can assert on it. Clamps mirror the harness field caps.
+const SKILL_SKIPPED_LABEL = '**Skipped project skill:**';
+const SKILL_SKIPPED_MAX_NAME_LEN = 200;
+const SKILL_SKIPPED_MAX_REASON_LEN = 1000;
+
 // Canonical Minions site URL. shared-rules.md ("Brand link (MANDATORY)") requires
 // the human-readable "Minions" mention in a PR/ADO comment to render as a markdown
 // hyperlink to this destination. Keep this in sync with the literal in
@@ -119,6 +126,64 @@ function buildHarnessUsedSection(harnessUsed) {
     + `${lines.join('\n')}${legend}\n\n</details>`;
 }
 
+/**
+ * Extract a canonical `{ name, reason }` skip record from a self-reported skip
+ * value. Accepts the raw `{ name, reason }` shape directly, or a `meta` wrapper
+ * that carries it — `meta.skill` (`{ skipped: { name, reason } }`) or
+ * `meta.review` (`{ skillSkipped: { name, reason } }`) — so callers can pass the
+ * completion-report block verbatim. Returns null when no non-empty `name` is
+ * present so callers treat "no skip" as a single falsy case.
+ * @param {*} input
+ * @returns {{name:string, reason:string}|null}
+ */
+function _extractSkillSkipped(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  let node = input;
+  if (input.skipped && typeof input.skipped === 'object' && !Array.isArray(input.skipped)) {
+    node = input.skipped; // meta.skill shape
+  } else if (input.skillSkipped && typeof input.skillSkipped === 'object' && !Array.isArray(input.skillSkipped)) {
+    node = input.skillSkipped; // meta.review shape
+  }
+  const name = typeof node.name === 'string' ? node.name.trim() : '';
+  if (!name) return null;
+  const reason = typeof node.reason === 'string' ? node.reason.trim() : '';
+  return { name, reason };
+}
+
+/**
+ * Render the "skipped project skill" self-report as a VISIBLE Markdown
+ * blockquote callout (W-mr287sc0000uc214), e.g.:
+ *   > ⚠️ **Skipped project skill:** `FMF-review-context` — small 2-file diff…
+ *
+ * A review/fix agent may self-report that it intentionally skipped an available,
+ * in-scope project (review) skill via `meta.review.skillSkipped` /
+ * `meta.skill.skipped` (shape `{name, reason}`). That skip used to live ONLY in
+ * the completion-report JSON — invisible to a human reading the PR before merge.
+ * This is a sibling of buildHarnessUsedSection (same neutral chokepoint, same
+ * `_clean` hygiene) but a VISIBLE blockquote rather than a collapsed <details>:
+ * the whole point is that a human reviewing the PR sees the skip rationale in the
+ * same comment as the APPROVE / REQUEST_CHANGES verdict, before merge.
+ *
+ * Deliberately platform-NEUTRAL Markdown so the GitHub and ADO posters fold in a
+ * byte-identical callout — there is no second renderer to drift. Accepts either
+ * the raw `{name, reason}` record or a `meta.skill` / `meta.review` wrapper.
+ *
+ * Returns '' when the record is absent/malformed (no skip name), so callers can
+ * append it unconditionally without emitting a stray callout — reports without
+ * meta.review.skillSkipped / meta.skill.skipped render identically to today.
+ *
+ * @param {object|null} skillSkipped `{name, reason}` or a meta.skill/meta.review wrapper
+ * @returns {string} '' when empty, else a one-line `> ⚠️ …` blockquote
+ */
+function buildSkippedSkillSection(skillSkipped) {
+  const parsed = _extractSkillSkipped(skillSkipped);
+  if (!parsed) return '';
+  const name = _clean(parsed.name).slice(0, SKILL_SKIPPED_MAX_NAME_LEN);
+  const reasonClean = parsed.reason ? _clean(parsed.reason).slice(0, SKILL_SKIPPED_MAX_REASON_LEN) : '';
+  const tail = reasonClean ? ` — ${reasonClean}` : ''; // em dash
+  return `> ${HARNESS_WARN_ICON} ${SKILL_SKIPPED_LABEL} \`${name}\`${tail}`;
+}
+
 // ── Minions marker + neutral comment-body builder ───────────────────────────
 //
 // The hidden HTML-comment marker and the body composition (marker + harness
@@ -188,15 +253,26 @@ function _buildMarker({ agentId, kind, workItemId }) {
  * Idempotency: if `body` already starts with a minions marker it is returned
  * with the harness/brand transforms applied but no second marker prepended.
  *
- * @param {{agentId:string, kind:string, workItemId?:string, body?:string, harnessUsed?:object}} args
+ * @param {{agentId:string, kind:string, workItemId?:string, body?:string, harnessUsed?:object, skillSkipped?:object}} args
  * @returns {string} the final comment body
  */
-function buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed }) {
+function buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed, skillSkipped }) {
   // Validate the inputs even when the body is pre-marked, so callers can't
   // silently bypass validation by pre-marking their body.
   _validateMarkerInputs({ agentId, kind, workItemId });
   let safeBody = body == null ? '' : String(body);
 
+  // Fold in the VISIBLE "skipped project skill" callout (W-mr287sc0000uc214)
+  // BEFORE the collapsed harness section so a human sees the skip rationale in
+  // the same comment as the verdict — not buried in a <details> or reachable
+  // only via a separate API call. Dedup on the stable label so a re-marked body
+  // already carrying the callout doesn't stack a second one. Absent/malformed
+  // skip → '' → no-op (byte-identical to today).
+  const skipSection = buildSkippedSkillSection(skillSkipped);
+  if (skipSection && !safeBody.includes(SKILL_SKIPPED_LABEL)) {
+    safeBody = safeBody ? `${safeBody}\n\n${skipSection}` : skipSection;
+  }
+
   // Fold the grounded harness-usage digest in as a collapsible <details>
   // section. Append at the END so it survives the marker-idempotency path;
   // dedup on the summary line so a re-marked body that already carries the
@@ -232,6 +308,7 @@ function parseMinionsMarker(body) {
 
 module.exports = {
   buildHarnessUsedSection,
+  buildSkippedSkillSection,
   linkifyBrandTrailer,
   MINIONS_BRAND_URL,
   // Neutral marker + body builder (consumed by gh-comment.js and ado-comment.js).
@@ -247,4 +324,7 @@ module.exports = {
   _validateMarkerInputs,
   // Exported for tests / advanced callers that want to mirror the kind mapping.
   HARNESS_KINDS,
+  // W-mr287sc0000uc214 — skipped-project-skill callout helpers.
+  _extractSkillSkipped,
+  SKILL_SKIPPED_LABEL,
 };

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/discover-project-skills.js

@@ -437,6 +437,8 @@ function renderProjectSkillsBlock(entries) {
   }
   lines.push('');
   lines.push("Record the skill outcome in your completion report's `meta.skill` block (`invoked` or `skipped` — see `docs/completion-reports.md`) so the engine can later measure skill-vs-first-principles signal.");
+  lines.push('');
+  lines.push("**Before you record a `skipped` outcome for an in-scope skill, this is a hard constraint, not a suggestion:** re-read that skill's own SKILL.md review criteria / checklist (the content injected above) and confirm your skip reason does not contradict any explicit \"Flag if…\" / \"Verify that…\" / \"Requirements\" item it documents. If the diff trips ANY explicit checklist item the skill covers, skipping is NOT permitted — apply the skill (or at minimum that specific checklist item). A skip reason that waves away a gate the skill explicitly documents (e.g. \"no CHANGELOG needed here\" when the skill's CHANGELOG Requirements section says otherwise) is invalid. When you do skip, the SAME `{name, reason}` you record in `meta.skill.skipped` must be the reason surfaced in the PR comment — no drift between the two.");
   return lines.join('\n');
 }
 
@@ -469,6 +471,8 @@ function renderReviewSkillsBlock(entries) {
   }
   lines.push('');
   lines.push("Record the skill outcome in your completion report's `meta.review` block (`skillInvoked` or `skillSkipped` — see `docs/completion-reports.md`) so the engine can later measure skill-vs-first-principles signal.");
+  lines.push('');
+  lines.push("**Before you record a `skillSkipped` outcome for an in-scope review skill, this is a hard constraint, not a suggestion:** re-read that skill's own SKILL.md review criteria / checklist (the content injected above) and confirm your skip reason does not contradict any explicit \"Flag if…\" / \"Verify that…\" / \"Requirements\" item it documents. If the diff under review trips ANY explicit checklist item the skill covers, skipping is NOT permitted — apply the skill (or at minimum that specific checklist item) and let it inform your verdict. A skip reason that waves away a gate the skill explicitly documents (e.g. \"no CHANGELOG needed for this diff\" when the skill's CHANGELOG Requirements section says otherwise) is invalid. When you do skip, the SAME `{name, reason}` you record in `meta.review.skillSkipped` must be the reason surfaced in the PR comment — no drift between the two.");
   return lines.join('\n');
 }
 

package/engine/dispatch.js

@@ -444,7 +444,10 @@ async function addToDispatchWithValidation(item, opts = {}) {
 
   let evaluation;
   try {
-    evaluation = await validate(wi, { engineConfig: config?.engine });
+    evaluation = await validate(wi, {
+      engineConfig: config?.engine,
+      project: _resolveEvalProjectContext(item, config),
+    });
   } catch (e) {
     log('warn', `pre-dispatch-eval: validator threw — failing open: ${e.message}`);
     return addToDispatch(item);
@@ -458,6 +461,37 @@ async function addToDispatchWithValidation(item, opts = {}) {
   return null;
 }
 
+/**
+ * Build the target-project identity passed to the pre-dispatch validator so the
+ * LLM knows which repo the work item targets. Without this the model has no way
+ * to know which project it is reasoning about and defaults to describing the
+ * Minions engine checkout it executes inside (cwd is hardcoded to MINIONS_DIR),
+ * producing false-invalid verdicts backed by fabricated file-existence claims
+ * about the wrong repo (W-mr25eg2400078d4b; repro WI W-mr2401ga0007830d
+ * targeting constellation). Best-effort — resolves the full project config to
+ * derive a canonical repo slug, but degrades gracefully to name/localPath only.
+ * @returns {{name?: string, slug?: string, localPath?: string}|null}
+ */
+function _resolveEvalProjectContext(item, config) {
+  const metaProject = item?.meta?.project;
+  if (!metaProject) return null;
+  const name = typeof metaProject === 'string' ? metaProject : metaProject.name;
+  const ctx = {};
+  if (name) ctx.name = String(name);
+  if (metaProject && typeof metaProject === 'object' && metaProject.localPath) {
+    ctx.localPath = String(metaProject.localPath);
+  }
+  try {
+    const full = _resolveDispatchProject(name || metaProject, config);
+    if (full && typeof full === 'object') {
+      if (!ctx.localPath && full.localPath) ctx.localPath = String(full.localPath);
+      const slug = shared.getProjectPrScope(full);
+      if (slug) ctx.slug = slug;
+    }
+  } catch { /* best-effort — name/localPath alone still help */ }
+  return Object.keys(ctx).length > 0 ? ctx : null;
+}
+
 
 function _resolveDispatchProject(projectRef, config) {
   if (!projectRef) return null;
@@ -580,6 +614,7 @@ function isRetryableFailureReason(reason = '', failureClass = '') {
       FAILURE_CLASS.LIVE_CHECKOUT_DIRTY, // P-a3f9b204 — live-checkout refused to spawn because operator localPath is dirty; mechanical retry won't fix it (operator must commit/stash/discard). NOTE (W-mqzmkoqt000hbca2): engine.js#spawnAgent ALWAYS passes an explicit `agentRetryable` for this class, so this Set entry is never the actual gate — when auto-cleanup (liveCheckoutAutoReset/AutoStash) is enabled the engine overrides to retryable. Kept as a defensive safety net for any caller that omits the explicit override.
       FAILURE_CLASS.LIVE_CHECKOUT_MID_OPERATION, // P-a7f3c1d9 — live-checkout refused to spawn because the operator tree is mid-operation (in-progress merge/rebase/cherry-pick/bisect or detached HEAD); mechanical retry won't fix it (operator must finish/abort the op or checkout a branch)
       FAILURE_CLASS.LIVE_CHECKOUT_BLOB_FETCH, // PL-live-checkout-reliability-hardening — live-checkout `git checkout <existing-branch>` failed hydrating the tree through the auth-less GVFS cache server (blobless partial clone, headless); deterministic, so mechanical retry just reproduces it (operator must hydrate the branch with their own creds, then re-dispatch)
+      FAILURE_CLASS.LIVE_CHECKOUT_WORKTREE_CONFLICT, // W-mr28h2j2000y0de1 — live-checkout `git checkout <existing-branch>` failed because that branch is already checked out in another worktree; structural conflict, so mechanical retry just reproduces it (operator must `git worktree remove` the other tree or finish its WIP, then re-dispatch)
       FAILURE_CLASS.OUTPUT_TRUNCATED, // P-8e4c2a17 — agent stdout exceeded the hard capture cap before the terminal result event; mechanical retry just reproduces the overflow (agent must reduce output volume or the task must be split)
     ]);
     if (neverRetry.has(failureClass)) return false;

package/engine/gh-comment.js

@@ -43,6 +43,7 @@ const { execFileSync: _execFileSync } = require('child_process');
 const { resolveTokenForSlug: _defaultResolveTokenForSlug } = require('./gh-token');
 const {
   buildHarnessUsedSection,
+  buildSkippedSkillSection,
   linkifyBrandTrailer,
   MINIONS_BRAND_URL,
   // Neutral marker + body builder now lives in comment-format.js so the GitHub
@@ -155,13 +156,14 @@ function postPrComment({
   kind,
   workItemId,
   harnessUsed,
+  skillSkipped,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed, skillSkipped });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {
@@ -185,13 +187,14 @@ function postPrReviewComment({
   kind,
   workItemId,
   harnessUsed,
+  skillSkipped,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
 } = {}) {
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed, skillSkipped });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {
@@ -222,6 +225,7 @@ function postPrReview({
   kind,
   workItemId,
   harnessUsed,
+  skillSkipped,
   timeoutMs = 30000,
   execFileSync = _execFileSync,
   resolveTokenForSlug,
@@ -234,7 +238,7 @@ function postPrReview({
   }
   _validateRepo(repo);
   _validatePrNumber(prNumber);
-  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed });
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, body, harnessUsed, skillSkipped });
   const file = _writeTempBodyFile(finalBody);
   const env = _resolveTokenEnvForRepo(repo, resolveTokenForSlug);
   try {
@@ -254,6 +258,7 @@ module.exports = {
   // Builders / parsers (pure functions — usable from anywhere)
   buildMinionsCommentBody,
   buildHarnessUsedSection, // re-export of engine/comment-format.js for comment callers
+  buildSkippedSkillSection, // re-export of engine/comment-format.js for comment callers
   linkifyBrandTrailer, // re-export of engine/comment-format.js for comment callers
   MINIONS_BRAND_URL, // re-export of engine/comment-format.js for comment callers
   parseMinionsMarker,