@yemi33/minions 0.1.2147 → 0.1.2149

package/engine/discover-review-skills.js

@@ -1,279 +1,25 @@
 /**
- * engine/discover-review-skills.js — W-mq16xtdx001a347e
+ * engine/discover-review-skills.js — backward-compat shim for PR #82
+ * (W-mq16xtdx001a347e).
  *
- * Cheap, bounded filesystem walk that surfaces project-local review tooling
- * (skills, slash-commands, copilot-instructions slash-command mentions) so
- * Minions review dispatches reliably steer agents toward the right skill
- * instead of reviewing every PR from first principles.
+ * PR #82 introduced `discover-review-skills.js` as a review-only helper. The
+ * follow-on W-mq1cczi90006b21f generalized it into
+ * `engine/discover-project-skills.js`, which discovers every project skill
+ * and classifies them into an intent vocabulary.
  *
- * Walk surfaces:
- *   - .claude/skills/*\/SKILL.md          — name/description frontmatter
- *   - .claude/commands/*.md                — filename + first heading
- *   - .github/copilot-instructions.md      — slash-command mentions (top N bytes)
- *   - CLAUDE.md                            — slash-command mentions (top N bytes)
- *
- * Returns a deduplicated array of:
- *   { kind: 'skill'|'command'|'slash-command', name, path, oneLineDescription }
- *
- * Contract:
- *   - Worktree missing / unreadable → returns [] (never throws)
- *   - Single bounded readdir per surface (no recursive grep)
- *   - File-count + walltime budget caps the walk in pathological repos
- *   - Pure: no engine state mutations, no logging beyond debug
+ * This file re-exports the two public PR-82 names so existing imports keep
+ * resolving without forcing every consumer to migrate in lockstep. The shim
+ * filters to the `review` intent and renders the original "## Project review
+ * skills" header copy. New code should import directly from
+ * engine/discover-project-skills.js and call `filterByIntents` itself.
  */
 
-const fs = require('fs');
-const path = require('path');
-
-// Heuristic match — "review", "swarm", or the explicit constellation-review id.
-// Word-bounded so we don't match arbitrary substrings like "previewer" or
-// "swarmm" inside unrelated names.
-const KEYWORD_RE = /\b(review|review-swarm|swarm|code-review|pr-review|constellation-review)\b/i;
-
-// Slash-command extractor — pulls `/foo-review`, `/review-swarm`, etc. out of
-// markdown prose. Anchored so `/path/to/file` doesn't match (must look like a
-// slash-command token: leading `/` immediately followed by an id with no `/`).
-const SLASH_COMMAND_RE = /(?<![A-Za-z0-9/_-])\/([a-z][a-z0-9-]*)(?![A-Za-z0-9/])/g;
-
-const DEFAULTS = {
-  maxFilesPerSurface: 50,    // hard cap on skill packs / command files we'll read
-  maxBytesPerFile: 8 * 1024, // only need frontmatter + first heading
-  docsScanMaxBytes: 32 * 1024, // CLAUDE.md / copilot-instructions.md top window
-  walltimeMs: 250,           // bail rather than block dispatch on pathological FS
-};
-
-function _now() { return Date.now(); }
-
-function _safeReadHead(filePath, maxBytes) {
-  let fd;
-  try {
-    fd = fs.openSync(filePath, 'r');
-    const buf = Buffer.alloc(maxBytes);
-    const n = fs.readSync(fd, buf, 0, maxBytes, 0);
-    return buf.slice(0, n).toString('utf8');
-  } catch { return ''; }
-  finally { if (fd !== undefined) { try { fs.closeSync(fd); } catch { /* ignore */ } } }
-}
-
-function _parseFrontmatter(content) {
-  const m = String(content || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!m) return {};
-  const out = {};
-  for (const line of m[1].split(/\r?\n/)) {
-    const lm = line.match(/^([\w-]+):\s*(.*)$/);
-    if (!lm) continue;
-    out[lm[1].toLowerCase()] = lm[2].trim().replace(/^["']|["']$/g, '');
-  }
-  return out;
-}
-
-function _firstHeading(content) {
-  const lines = String(content || '').split(/\r?\n/);
-  for (const line of lines) {
-    const m = line.match(/^#+\s+(.+?)\s*$/);
-    if (m) return m[1].trim();
-  }
-  return '';
-}
-
-function _firstNonEmptyLine(content) {
-  const lines = String(content || '').split(/\r?\n/);
-  for (const line of lines) {
-    const t = line.trim();
-    if (t && !t.startsWith('---') && !t.startsWith('#')) return t;
-  }
-  return '';
-}
-
-function _truncate(s, max) {
-  const text = String(s || '').trim();
-  if (text.length <= max) return text;
-  return text.slice(0, max - 1).trim() + '…';
-}
-
-function _discoverSkills(projectPath, opts, deadline) {
-  const out = [];
-  const skillsDir = path.join(projectPath, '.claude', 'skills');
-  let entries;
-  try { entries = fs.readdirSync(skillsDir, { withFileTypes: true }); } catch { return out; }
-  let scanned = 0;
-  for (const ent of entries) {
-    if (scanned >= opts.maxFilesPerSurface) break;
-    if (_now() > deadline) break;
-    if (!ent.isDirectory()) continue;
-    const skillPath = path.join(skillsDir, ent.name, 'SKILL.md');
-    let stat;
-    try { stat = fs.statSync(skillPath); } catch { continue; }
-    if (!stat.isFile()) continue;
-    scanned += 1;
-    const head = _safeReadHead(skillPath, opts.maxBytesPerFile);
-    if (!head) continue;
-    const fm = _parseFrontmatter(head);
-    const name = fm.name || ent.name;
-    const desc = fm.description || '';
-    const hay = `${name} ${desc}`;
-    if (!KEYWORD_RE.test(hay)) continue;
-    out.push({
-      kind: 'skill',
-      name: String(name),
-      path: path.relative(projectPath, skillPath).split(path.sep).join('/'),
-      oneLineDescription: _truncate(desc || _firstHeading(head) || name, 200),
-    });
-  }
-  return out;
-}
-
-function _discoverCommands(projectPath, opts, deadline) {
-  const out = [];
-  const cmdDir = path.join(projectPath, '.claude', 'commands');
-  let entries;
-  try { entries = fs.readdirSync(cmdDir, { withFileTypes: true }); } catch { return out; }
-  let scanned = 0;
-  for (const ent of entries) {
-    if (scanned >= opts.maxFilesPerSurface) break;
-    if (_now() > deadline) break;
-    if (!ent.isFile()) continue;
-    if (!/\.md$/i.test(ent.name)) continue;
-    scanned += 1;
-    const base = ent.name.replace(/\.md$/i, '');
-    const cmdPath = path.join(cmdDir, ent.name);
-    const head = _safeReadHead(cmdPath, opts.maxBytesPerFile);
-    const heading = _firstHeading(head);
-    const hay = `${base} ${heading}`;
-    if (!KEYWORD_RE.test(hay)) continue;
-    out.push({
-      kind: 'command',
-      name: `/${base}`,
-      path: path.relative(projectPath, cmdPath).split(path.sep).join('/'),
-      oneLineDescription: _truncate(heading || _firstNonEmptyLine(head) || base, 200),
-    });
-  }
-  return out;
-}
-
-function _extractSlashCommandsFromDoc(content) {
-  const found = new Map();
-  const text = String(content || '');
-  let m;
-  SLASH_COMMAND_RE.lastIndex = 0;
-  while ((m = SLASH_COMMAND_RE.exec(text)) !== null) {
-    const id = m[1];
-    if (!KEYWORD_RE.test(id)) continue;
-    if (!found.has(id)) found.set(id, m.index);
-  }
-  return [...found.keys()];
-}
-
-function _discoverDocSlashCommands(projectPath, opts, deadline, alreadySeen) {
-  const out = [];
-  const docPaths = [
-    path.join(projectPath, '.github', 'copilot-instructions.md'),
-    path.join(projectPath, 'CLAUDE.md'),
-  ];
-  for (const docPath of docPaths) {
-    if (_now() > deadline) break;
-    let stat;
-    try { stat = fs.statSync(docPath); } catch { continue; }
-    if (!stat.isFile()) continue;
-    const head = _safeReadHead(docPath, opts.docsScanMaxBytes);
-    if (!head) continue;
-    const ids = _extractSlashCommandsFromDoc(head);
-    const relDoc = path.relative(projectPath, docPath).split(path.sep).join('/');
-    for (const id of ids) {
-      const fullName = `/${id}`;
-      if (alreadySeen.has(fullName)) continue;
-      alreadySeen.add(fullName);
-      out.push({
-        kind: 'slash-command',
-        name: fullName,
-        path: relDoc,
-        oneLineDescription: `Documented review entrypoint in ${relDoc}`,
-      });
-    }
-  }
-  return out;
-}
-
-/**
- * @param {object} args
- * @param {string} args.projectPath — absolute path to the project worktree / checkout
- * @param {object} [args.opts] — override defaults (mostly for tests)
- * @returns {Array<{kind:string,name:string,path:string,oneLineDescription:string}>}
- */
-function discoverReviewSkills(args) {
-  const projectPath = args && args.projectPath;
-  if (!projectPath || typeof projectPath !== 'string') return [];
-  try { if (!fs.statSync(projectPath).isDirectory()) return []; } catch { return []; }
-
-  const opts = Object.assign({}, DEFAULTS, args.opts || {});
-  const deadline = _now() + Math.max(1, opts.walltimeMs);
-
-  const seenKey = new Set(); // dedupe across surfaces by `${kind}:${name}`
-  const seenSlash = new Set();
-  const all = [];
-
-  for (const entry of _discoverSkills(projectPath, opts, deadline)) {
-    const key = `skill:${entry.name}`;
-    if (seenKey.has(key)) continue;
-    seenKey.add(key);
-    all.push(entry);
-  }
-
-  for (const entry of _discoverCommands(projectPath, opts, deadline)) {
-    const key = `command:${entry.name}`;
-    if (seenKey.has(key)) continue;
-    seenKey.add(key);
-    seenSlash.add(entry.name); // /foo from .claude/commands subsumes doc-mention
-    all.push(entry);
-  }
-
-  for (const entry of _discoverDocSlashCommands(projectPath, opts, deadline, seenSlash)) {
-    const key = `slash-command:${entry.name}`;
-    if (seenKey.has(key)) continue;
-    seenKey.add(key);
-    all.push(entry);
-  }
-
-  return all;
-}
-
-/**
- * Format a discovery result list as a Markdown block ready to splice into the
- * review playbook. Returns empty string when the list is empty so the caller
- * can no-op cleanly (no stray header, no blank padding lines).
- *
- * @param {Array} entries — output of discoverReviewSkills()
- * @returns {string}
- */
-function renderReviewSkillsBlock(entries) {
-  if (!Array.isArray(entries) || entries.length === 0) return '';
-  const lines = [];
-  lines.push('## Project review skills (prefer these when applicable)');
-  lines.push('');
-  lines.push("This project ships purpose-built review tooling. When the diff under review is within scope of one of these skills, INVOKE IT FIRST and use its findings as the primary signal — your verdict can then be anchored to what the skill returned plus any gaps you spot on top.");
-  lines.push('');
-  for (const e of entries) {
-    const kindHint = e.kind === 'skill' ? `skill: \`${e.name}\``
-      : e.kind === 'command' ? `\`${e.name}\``
-      : `\`${e.name}\``;
-    const pathHint = e.path ? ` (\`${e.path}\`)` : '';
-    const desc = e.oneLineDescription ? ` — ${e.oneLineDescription}` : '';
-    lines.push(`- ${kindHint}${pathHint}${desc}`);
-  }
-  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.");
-  return lines.join('\n');
-}
+const {
+  discoverReviewSkills,
+  renderReviewSkillsBlock,
+} = require('./discover-project-skills');
 
 module.exports = {
   discoverReviewSkills,
   renderReviewSkillsBlock,
-  // exported for tests
-  _internal: {
-    KEYWORD_RE,
-    SLASH_COMMAND_RE,
-    DEFAULTS,
-    _parseFrontmatter,
-    _extractSlashCommandsFromDoc,
-  },
 };

package/engine/dispatch.js

@@ -400,6 +400,7 @@ function isRetryableFailureReason(reason = '', failureClass = '') {
       FAILURE_CLASS.WORKTREE_PREFLIGHT, // pre-spawn worktree validation — recompute will produce the same failure
       FAILURE_CLASS.WORKTREE_DIRTY,     // #2996: reused worktree was dirty and could not be auto-healed — non-retryable for this dispatch attempt; the engine quarantined the worktree so the next discovery cycle creates a fresh one
       FAILURE_CLASS.WORKTREE_DIVERGENT, // #2996: reused worktree's local branch had unpushed commits — engine quarantined + backed up the local ref; non-retryable for this dispatch (next discovery creates fresh worktree on origin/<branch>)
+      FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED, // W-mq5n1zx5: quarantine rename couldn't release the worktree dir even after retry + force-remove fallback. Non-retryable at the dispatch level so the per-agent retry counter isn't bumped (environmental, not the agent's fault); the WI auto-recovery loop in engine.js#discoverFromWorkItems re-queues without touching _retriesByAgent.
       FAILURE_CLASS.INVALID_KEEP_PROCESSES_WORKDIR, // W-mp6k7ywi000fa33c — keep-pids cwd is not a real git worktree; re-running won't fix the structural issue
       FAILURE_CLASS.INVALID_KEEP_PROCESSES_SCHEMA, // W-mp7i902u000l991f — keep-pids.json failed shape validation; re-running with the same wrong file won't fix it
       FAILURE_CLASS.INVALID_MANAGED_SPAWN, // W-mpbhxg3b000u8411 — managed-spawn.json failed validation; re-running with the same wrong file won't fix it
@@ -770,6 +771,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
             [FAILURE_CLASS.WORKTREE_PREFLIGHT]: 'worktree preflight rejected (nested in project root or rootDir collapsed to drive root)',
             [FAILURE_CLASS.WORKTREE_DIRTY]: 'reused worktree had uncommitted edits and could not be auto-healed (#2996) — engine quarantined the dir so the next dispatch creates a fresh worktree',
             [FAILURE_CLASS.WORKTREE_DIVERGENT]: 'reused worktree had unpushed local commits ahead of origin (#2996) — engine backed up the local ref and quarantined the dir so the next dispatch starts from origin/<branch>',
+            [FAILURE_CLASS.WORKTREE_QUARANTINE_ENV_BLOCKED]: 'quarantine rename was blocked by the OS (Windows EBUSY/EPERM) even after retry + force-remove fallback — environmental, not the agent\'s fault; auto-recovery loop will re-queue without bumping per-agent retries',
             [FAILURE_CLASS.INVALID_KEEP_PROCESSES_WORKDIR]: 'keep_processes cwd is not a real git worktree (rerun in a `git worktree add` directory)',
             [FAILURE_CLASS.INVALID_KEEP_PROCESSES_SCHEMA]: 'keep-pids.json failed shape validation (wrong keys/types/values — see inbox alert for the canonical shape)',
             [FAILURE_CLASS.INVALID_MANAGED_SPAWN]: 'managed-spawn.json failed validation (bad schema, workdir, or allowlist — see inbox alert)',

package/engine/github.js

@@ -748,6 +748,20 @@ async function pollPrStatus(config) {
       updated = true;
     }
 
+    // #3079 — Track GitHub target branch name + clear stale merge-conflict
+    // dispatch state when the PR is retargeted (e.g. `gh pr edit --base
+    // master` after parent PR merges). Mirrors ado.js applyAdoPrMetadata.
+    // First-poll seeding (no prior baseRefName) is a no-op so we don't
+    // strip state immediately after upsert.
+    const nextBaseRefName = String(prData.base?.ref || '').trim();
+    if (nextBaseRefName && pr.baseRefName !== nextBaseRefName) {
+      if (shared.resetMergeConflictStateOnRetarget(pr, nextBaseRefName)) {
+        log('info', `GitHub: PR ${pr.id} retargeted ${pr.baseRefName} → ${nextBaseRefName}, clearing stale MERGE_CONFLICT dispatch records`);
+      }
+      pr.baseRefName = nextBaseRefName;
+      updated = true;
+    }
+
     // P-w1a3f9b2 — Phase 1.1: plumb mergeable / isDraft / mergeStateStatus /
     // headRefOid onto the PR object so watches captureState (engine/watches.js)
     // and future predicates (Phase 2.1: head-commit-change, mergeable-flipped,

package/engine/lifecycle.js

@@ -2291,6 +2291,15 @@ function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChang
           return out;
         })()
       : {}),
+    // #3079 — MERGE_CONFLICT noops record the composite guard key (source
+    // head + base SHA + target ref name). The same-head guard at
+    // engine.js:5676 reads this back and compares against the current
+    // PR's prMergeConflictGuardKey, so a retarget (target ref change) or
+    // a parent-merge (base SHA change) naturally releases the pause even
+    // when the source head didn't move.
+    ...(cause === shared.PR_FIX_CAUSE.MERGE_CONFLICT
+      ? { mergeConflictKey: shared.prMergeConflictGuardKey(target) }
+      : {}),
   };
   target.lastDispatchedAt = now;
   target.lastDispatchOutcome = 'noop';
@@ -2664,6 +2673,14 @@ function updatePrAfterFixError(pr, project, source, options = {}) {
           || '');
       if (commentKey) next.lastProcessedCommentKey = commentKey;
     }
+    // #3079 — Refresh mergeConflictKey from live target state so a
+    // mid-flight retarget reflects in the agent-error record too. The
+    // engine.js skipConflictFix guard prefers mergeConflictKey over
+    // legacy headSha; without this refresh, the prior record's stale
+    // key could re-fire the suppression even after a retarget.
+    if (cause === shared.PR_FIX_CAUSE.MERGE_CONFLICT) {
+      next.mergeConflictKey = shared.prMergeConflictGuardKey(target);
+    }
     target._lastDispatchByCause[cause] = next;
     result = { cause, indeterminate: true, errorClass };
     log('warn', `Updated ${pr.id} → recorded ${cause} agent-error fix attempt (indeterminate=true) — same-head guard relaxed for next tick${errorMessage ? ` (${errorMessage.slice(0, 80)})` : ''}`);

package/engine/playbook-intents.js

@@ -0,0 +1,76 @@
+/**
+ * engine/playbook-intents.js — W-mq1cczi90006b21f
+ *
+ * Maps Minions playbook names (work-item types) to the intent buckets each
+ * playbook should surface from project-local skill discovery. The mapping is
+ * the single source of truth for "which playbook gets which slice of the
+ * skills block" — engine/playbook.js consults this at render time.
+ *
+ * Intent vocabulary (defined in engine/discover-project-skills.js):
+ *   review | build | fix | test | plan | research | deploy | observability | meta
+ *
+ * Adding a new playbook? Add an entry here. Playbooks not in this map fall
+ * through to NO skills block (the engine treats undefined as the empty set,
+ * which is the safe default — agents see no header rather than a noisy one).
+ *
+ * Adding a new intent? Add the keyword regex to INTENT_KEYWORDS in
+ * engine/discover-project-skills.js AND a row to this map (or update an
+ * existing playbook to include it). Then document the verb in
+ * docs/project-skills.md.
+ */
+
+// Canonical mapping. Lower-cased playbook names; intent values must be
+// members of INTENT_VOCABULARY in engine/discover-project-skills.js.
+const PLAYBOOK_INTENTS = Object.freeze({
+  // Review-flavored playbooks — preserves PR-82 behavior verbatim.
+  review:        ['review'],
+
+  // Fix dispatches often need to re-run review tooling after the fix lands,
+  // and may also touch tests; surface review+test alongside debug/triage.
+  fix:           ['fix', 'test', 'review'],
+
+  // Implementation surfaces build/scaffold/codemod skills plus the matching
+  // test skills, and research for codebase investigation.
+  implement:        ['build', 'test', 'research'],
+  'implement-shared': ['build', 'test', 'research'],
+
+  // Planning surfaces planning + research (codebase exploration is part of
+  // good planning).
+  plan:          ['plan', 'research'],
+  'plan-to-prd': ['plan', 'research'],
+  decompose:     ['plan', 'research'],
+
+  // Doc / verify / build-and-test playbooks — keep tight intent sets so
+  // we don't dump build-bumping skills into a docs prompt.
+  docs:          ['research'],
+  verify:        ['test', 'review'],
+  'build-and-test': ['build', 'test'],
+  test:          ['test'],
+
+  // Exploration / asks: research-heavy.
+  explore:       ['research'],
+
+  // qa-validate: targeted at test/qa skills.
+  'qa-validate': ['test'],
+
+  // Followup-dispatch is a template (not a top-level playbook); the engine
+  // inherits the parent dispatch's intent set when rendering follow-ups.
+  // See engine/playbook.js → renderPlaybook for the inheritance plumb.
+});
+
+/**
+ * Look up the intent set for a playbook name. Returns [] for unknown
+ * playbooks (caller treats empty as "render no block").
+ *
+ * @param {string} playbookName
+ * @returns {string[]}
+ */
+function intentsForPlaybook(playbookName) {
+  if (!playbookName || typeof playbookName !== 'string') return [];
+  return PLAYBOOK_INTENTS[playbookName.toLowerCase()] || [];
+}
+
+module.exports = {
+  PLAYBOOK_INTENTS,
+  intentsForPlaybook,
+};

package/engine/playbook.js

@@ -339,6 +339,17 @@ const PLAYBOOK_OPTIONAL_VARS = new Set([
   'role',                  // 'primary' | 'co-service'
   'primary_project',       // canonical primary project name; empty on single-project sessions
   'co_services_json',      // JSON-encoded co-service project names (e.g. ["api","worker"]); empty when none
+  // W-mq16xtdx001a347e (PR-82) — project-local review-skill discovery vars.
+  // Always rendered (empty string when no discoveries); listed here so the
+  // unresolved-var check doesn't complain when discovery returns nothing or
+  // projects legitimately resolve it to ''.
+  'project_review_skills_block',
+  'skip_project_review_skills',
+  // W-mq1cczi90006b21f — generic, intent-filtered project skills block.
+  // Spliced by review/fix/implement/plan/etc. when discovery + intent map
+  // produce matches. Optional for the same reason as the review-only alias.
+  'project_skills_block',
+  'skip_project_skills',
 ]);
 
 const PLAYBOOK_REQUIRED_VARS = {
@@ -695,30 +706,57 @@ function renderPlaybook(type, vars) {
     } catch (e) { log('warn', `managed-spawn live-processes inject failed: ${e.message}`); }
   }
 
-  // W-mq16xtdx001a347e — review dispatches: discover project-local review
-  // tooling (.claude/skills, .claude/commands, copilot-instructions slash-
-  // command mentions) and render a "Project review skills" block near the top
-  // of the playbook. Default-ON for `review` type; suppressed when the
-  // dispatcher passes `meta.skipProjectReviewSkills` (threaded as
-  // vars.skip_project_review_skills). Renders empty string when discovery
-  // returns no matches so first-principles reviewers see no stray header.
-  if (type === 'review' && !vars.skip_project_review_skills) {
+  // W-mq16xtdx001a347e (PR #82) + W-mq1cczi90006b21f (generalization) —
+  // surface project-local skills relevant to the playbook being dispatched.
+  //
+  // PR-82 hard-scoped this to type === 'review'. This wiring generalizes it:
+  //   1. Discovery walks every project skill / command / documented slash-
+  //      command (engine/discover-project-skills.js).
+  //   2. engine/playbook-intents.js maps playbook → intent set.
+  //   3. Discovered entries are filtered to the playbook's intent set and
+  //      rendered into `project_skills_block`. Empty intent set or zero
+  //      matches → empty string (no stray header).
+  //
+  // Header copy: review dispatches keep PR-82's "## Project review skills"
+  // header (existing agents/tests grep for it). All other playbooks use the
+  // generalized "## Project skills" header.
+  //
+  // Backward-compat: `project_review_skills_block` and
+  // `vars.skip_project_review_skills` remain wired so external consumers of
+  // the PR-82 names keep working. They alias to the generic var/flag.
+  const skipProjectSkills = !!(vars.skip_project_skills || vars.skip_project_review_skills);
+  let projectSkillsBlock = '';
+  if (!skipProjectSkills) {
     try {
-      const discover = require('./discover-review-skills');
+      const discover = require('./discover-project-skills');
+      const { intentsForPlaybook } = require('./playbook-intents');
       const projectPath = matchedProject?.localPath || '';
       if (projectPath) {
-        const entries = discover.discoverReviewSkills({ projectPath });
-        vars.project_review_skills_block = discover.renderReviewSkillsBlock(entries);
-      } else {
-        vars.project_review_skills_block = '';
+        // Inherit intent set from parent dispatch type when the engine
+        // passes vars.parent_dispatch_type (followup-dispatch flow).
+        const effectiveType = vars.parent_dispatch_type || type;
+        const intents = intentsForPlaybook(effectiveType);
+        if (intents.length > 0) {
+          const entries = discover.discoverProjectSkills({ projectPath });
+          const filtered = discover.filterByIntents(entries, intents);
+          // type === 'review' keeps PR-82 header copy + meta.review.* outcome
+          // guidance; everything else uses the generic header that points at
+          // meta.skill.* in the completion report.
+          projectSkillsBlock = (type === 'review')
+            ? discover.renderReviewSkillsBlock(filtered)
+            : discover.renderProjectSkillsBlock(filtered);
+        }
       }
     } catch (e) {
-      log('warn', `discover-review-skills failed: ${e.message}`);
-      vars.project_review_skills_block = '';
+      log('warn', `discover-project-skills failed: ${e.message}`);
     }
-  } else {
-    vars.project_review_skills_block = '';
   }
+  vars.project_skills_block = projectSkillsBlock;
+  // Backward-compat alias for any consumer that still references
+  // {{project_review_skills_block}} directly. Same content; cheaper than
+  // re-rendering. Non-review playbooks that don't reference the alias
+  // ignore it (it's in PLAYBOOK_OPTIONAL_VARS).
+  vars.project_review_skills_block = projectSkillsBlock;
 
   // W-mpeiwz6k0005bf34-c — opt-in qa-validate context block. Injected only
   // when the dispatcher set vars.qa_run_id (truthy) from the work item's
@@ -1129,10 +1167,11 @@ function buildPrDispatch(agentId, config, project, pr, type, extraVars, taskLabe
   const vars = {
     ...buildBaseVars(agentId, config, project),
     branch_name: extraVars?.pr_branch || '',
-    // W-mq16xtdx001a347e — honor meta.skipProjectReviewSkills on PR-built
-    // dispatches (auto re-reviews, conflict-fix follow-ups, etc.). Default
-    // OFF: review dispatches surface the project-local review skills block.
+    // W-mq16xtdx001a347e + W-mq1cczi90006b21f — honor both meta flag names
+    // (skipProjectReviewSkills is the PR-82 alias). Default OFF: review/fix
+    // dispatches surface the project-local skills block.
     skip_project_review_skills: !!(meta && meta.skipProjectReviewSkills),
+    skip_project_skills: !!(meta && (meta.skipProjectSkills || meta.skipProjectReviewSkills)),
     ...extraVars,
     task_id: dispatchId,
   };