@yemi33/minions 0.1.2178 → 0.1.2180

package/engine/queries.js

@@ -734,6 +734,118 @@ function getPrs(project) {
 let _prsCache = null;
 let _prsCacheAt = 0;
 
+// ── W-mqba5ulq000nd255 — cross-project PR de-dupe helpers ────────────────────
+//
+// When a dispatching agent in project A reports a PR URL that actually lives
+// on project B's repo, the engine historically wrote the PR into BOTH project
+// files. The A copy got stamped with `_invalidProjectScope` (a tracking
+// breadcrumb) but was never pruned. getPullRequests' legacy first-write-wins
+// dedupe then surfaced the wrong scope first, masking the real record. These
+// helpers collapse those duplicates at read time, with field-merge so we
+// never drop prdItems, sourcePlan, itemType, minionsReview, or
+// _automationFixCauses that lived on the loser.
+
+// Timestamps that signal "this record was touched recently". Highest of the
+// three breaks ties when neither record has a scope advantage.
+function _prFreshnessMs(pr) {
+  if (!pr) return 0;
+  const cands = [pr.lastPushedAt, pr.mergedAt, pr.lastPolledAt, pr.lastPolled, pr._attachedAt, pr.created];
+  let best = 0;
+  for (const c of cands) {
+    if (!c) continue;
+    const t = typeof c === 'number' ? c : Date.parse(c);
+    if (Number.isFinite(t) && t > best) best = t;
+  }
+  return best;
+}
+
+function _groupPrRecordsById(prs) {
+  const groups = new Map();
+  const order = [];
+  for (const pr of prs) {
+    if (!pr || !pr.id) continue;
+    if (!groups.has(pr.id)) {
+      const g = [];
+      groups.set(pr.id, g);
+      order.push(g);
+    }
+    groups.get(pr.id).push(pr);
+  }
+  return order;
+}
+
+// Choose the winning record from a group of cross-scope duplicates. Fields
+// the winner left empty are filled from the loser(s). Returns the winner +
+// the dropped sibling records so the caller can log the pruning decision.
+function _pickPrDedupeWinner(group, projects) {
+  if (group.length === 1) return { winner: group[0], dropped: [] };
+
+  // Map each project name -> its canonical scope, so we can detect when a
+  // record's _scope matches the PR url-derived scope (preference #2 below).
+  const projectScopeByName = new Map();
+  for (const p of projects || []) {
+    if (!p || !p.name) continue;
+    const sc = shared.getProjectPrScope(p);
+    if (sc) projectScopeByName.set(p.name, sc);
+  }
+
+  // Resolve the PR's "correct" scope from its URL (independent of _scope).
+  // Falls back to the canonical id when the URL is absent. Group members
+  // share the same id so any non-empty url is sufficient.
+  let urlScope = '';
+  for (const pr of group) {
+    const info = shared.getPrScopeInfo(pr, pr.url || '');
+    if (info && info.scope) { urlScope = info.scope; break; }
+  }
+
+  // Score each candidate. Higher is better. Composite key:
+  //  bit 2: no _invalidProjectScope stamp (best signal)
+  //  bit 1: _scope matches url-derived scope
+  //  bit 0: freshness rank (broken into a separate tiebreak after)
+  function scoreOf(pr) {
+    const scopeOk = !pr._invalidProjectScope ? 1 : 0;
+    const projectScope = projectScopeByName.get(pr._scope) || '';
+    const matchesUrl = urlScope && projectScope && projectScope === urlScope ? 1 : 0;
+    return (scopeOk << 1) | matchesUrl;
+  }
+
+  let winnerIdx = 0;
+  let winnerScore = scoreOf(group[0]);
+  let winnerFresh = _prFreshnessMs(group[0]);
+  for (let i = 1; i < group.length; i++) {
+    const s = scoreOf(group[i]);
+    const f = _prFreshnessMs(group[i]);
+    if (s > winnerScore || (s === winnerScore && f > winnerFresh)) {
+      winnerIdx = i;
+      winnerScore = s;
+      winnerFresh = f;
+    }
+  }
+
+  const winner = group[winnerIdx];
+  const dropped = group.filter((_, i) => i !== winnerIdx);
+
+  // Field-merge: fill empty winner fields from any loser. Winner wins on
+  // every field it has; losers only contribute where the winner is missing
+  // the field entirely (undefined, null, '', or empty array).
+  function isEmpty(v) {
+    if (v == null) return true;
+    if (typeof v === 'string') return v === '';
+    if (Array.isArray(v)) return v.length === 0;
+    return false;
+  }
+  const mergeKeys = ['prdItems', 'sourcePlan', 'itemType', 'minionsReview', '_automationFixCauses'];
+  for (const loser of dropped) {
+    for (const key of mergeKeys) {
+      if (isEmpty(winner[key]) && !isEmpty(loser[key])) {
+        winner[key] = loser[key];
+      }
+    }
+  }
+
+  return { winner, dropped };
+}
+
 function getPullRequests(config) {
   const now = Date.now();
   if (_prsCache && (now - _prsCacheAt) < 1000) return _prsCache;
@@ -741,14 +853,34 @@ function getPullRequests(config) {
   const projects = getProjects(config);
   const projectByName = new Map(projects.map(p => [p.name, p]));
   const allPrs = [];
-  const seenIds = new Set();
 
   // SQL is the canonical (and only) PR store after Phase 9.
   const store = require('./pull-requests-store');
   const sqlPrs = store.readAllPullRequests() || [];
 
-  for (const pr of sqlPrs) {
-    if (!pr?.id || seenIds.has(pr.id)) continue;
+  // W-mqba5ulq000nd255 — Read-side de-dupe across project scopes. When the
+  // same canonical pr.id appears under multiple scopes (e.g. an agent in
+  // project A reported a PR URL that actually lives on project B's repo,
+  // landing a stub stamped with _invalidProjectScope in A while the real
+  // record lives in B), collapse to one record using the preference order:
+  //   1. record where `_invalidProjectScope` is FALSY
+  //   2. record whose scope matches the PR url-derived scope
+  //   3. most-recently-updated (lastPushedAt / mergedAt / _attachedAt)
+  //   4. first-seen
+  // Then merge non-conflicting fields from the loser into the winner so we
+  // never lose prdItems, sourcePlan, itemType, minionsReview, or
+  // _automationFixCauses if only the loser carried them.
+  const groups = _groupPrRecordsById(sqlPrs);
+  for (const group of groups) {
+    const { winner, dropped } = _pickPrDedupeWinner(group, projects);
+    if (dropped.length > 0) {
+      try {
+        const droppedScopes = dropped.map(d => d._scope || 'unknown').join(', ');
+        shared.log('info', `[pull-requests] de-duped ${winner.id} across ${group.length} records, kept _project=${winner._scope || 'unknown'}, dropped [${droppedScopes}]`);
+      } catch { /* logging is best-effort */ }
+    }
+
+    const pr = winner;
     const scope = pr._scope;
     delete pr._scope;
     if (scope === 'central') {
@@ -769,7 +901,6 @@ function getPullRequests(config) {
     // _noOpFixes themselves.
     pr._pausedCauses = shared.getPrPausedCauses(pr);
     allPrs.push(pr);
-    seenIds.add(pr.id);
   }
   allPrs.sort((a, b) => {
     // W-mpej044m00076d63: sort by the full ISO `created` timestamp DESC so
@@ -910,6 +1041,121 @@ function _skillsCacheKeyFor(config, homeDir) {
   return JSON.stringify({ homeDir, projects });
 }
 
+// ── Harness helpers (P-f5a91c30) ────────────────────────────────────────────
+//
+// `getUserHarnesses(homeDir)` and `getProjectHarnesses(project)` are the
+// shared aggregation layer over the per-runtime adapter methods
+// `getSkillRoots`, `getCommandRoots`, and `getMcpConfigPaths`. They iterate
+// every registered runtime, union the contributions, and dedup by absolute
+// path so the same dir (e.g. `~/.agents/skills` — exposed by Codex + Copilot)
+// only surfaces once. Each surviving entry tracks which runtimes contributed
+// it via `runtimes: [name, ...]` so diagnostics can show provenance.
+//
+// Consumers: dashboard `/api/status` skills/MCP slices (via collectSkillFiles
+// / collectCommandFiles refactor), the planned `/api/harness/diagnostics`
+// endpoint, `engine.js#spawnAgent` for `computeAddDirs` project-local asset
+// propagation, and `minions doctor --harness` (preflight.js still calls the
+// per-adapter methods directly there to label by adapter — that's intentional).
+//
+// Return shape:
+//   { skills: HarnessEntry[], commands: HarnessEntry[], mcps: HarnessEntry[] }
+// where HarnessEntry =
+//   { dir|file: string, scope: string, projectName?: string, runtimes: string[] }
+// `skills`/`commands` use `dir`; `mcps` uses `file`. Both keys are present on
+// the same shape for ergonomic destructure.
+
+function _addHarnessEntry(out, byPath, runtimeName, pathValue, payload) {
+  if (!pathValue) return;
+  const abs = path.resolve(pathValue);
+  const existing = byPath.get(abs);
+  if (existing) {
+    if (!existing.runtimes.includes(runtimeName)) existing.runtimes.push(runtimeName);
+    return;
+  }
+  const entry = { ...payload, runtimes: [runtimeName] };
+  byPath.set(abs, entry);
+  out.push(entry);
+}
+
+function _collectHarnessesScope(scopeFilter, runtimeOpts) {
+  const skills = [];
+  const commands = [];
+  const mcps = [];
+  const skillsByPath = new Map();
+  const commandsByPath = new Map();
+  const mcpsByPath = new Map();
+  let runtimeNames = [];
+  try {
+    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    runtimeNames = listRuntimes();
+    for (const runtimeName of runtimeNames) {
+      let runtime;
+      try { runtime = resolveRuntime(runtimeName); } catch { continue; }
+      if (!runtime) continue;
+
+      if (typeof runtime.getSkillRoots === 'function') {
+        let roots = [];
+        try { roots = runtime.getSkillRoots(runtimeOpts) || []; } catch { roots = []; }
+        for (const root of roots) {
+          if (!root || !root.dir) continue;
+          if (!scopeFilter(root)) continue;
+          _addHarnessEntry(skills, skillsByPath, runtimeName, root.dir, {
+            dir: path.resolve(root.dir),
+            scope: root.scope,
+            projectName: root.projectName,
+          });
+        }
+      }
+
+      if (typeof runtime.getCommandRoots === 'function') {
+        let roots = [];
+        try { roots = runtime.getCommandRoots(runtimeOpts) || []; } catch { roots = []; }
+        for (const root of roots) {
+          if (!root || !root.dir) continue;
+          if (!scopeFilter(root)) continue;
+          _addHarnessEntry(commands, commandsByPath, runtimeName, root.dir, {
+            dir: path.resolve(root.dir),
+            scope: root.scope,
+            projectName: root.projectName,
+          });
+        }
+      }
+
+      if (typeof runtime.getMcpConfigPaths === 'function') {
+        let entries = [];
+        try { entries = runtime.getMcpConfigPaths(runtimeOpts) || []; } catch { entries = []; }
+        for (const entry of entries) {
+          if (!entry || !entry.file) continue;
+          if (!scopeFilter(entry)) continue;
+          _addHarnessEntry(mcps, mcpsByPath, runtimeName, entry.file, {
+            file: path.resolve(entry.file),
+            scope: entry.scope,
+            projectName: entry.projectName,
+          });
+        }
+      }
+    }
+  } catch { /* runtime registry optional in partial installs */ }
+  return { skills, commands, mcps };
+}
+
+function getUserHarnesses(homeDir = os.homedir()) {
+  return _collectHarnessesScope(
+    (entry) => entry.scope !== 'project',
+    { homeDir },
+  );
+}
+
+function getProjectHarnesses(project) {
+  if (!project || !project.localPath) {
+    return { skills: [], commands: [], mcps: [] };
+  }
+  return _collectHarnessesScope(
+    (entry) => entry.scope === 'project',
+    { homeDir: os.homedir(), project },
+  );
+}
+
 function collectSkillFiles(config) {
   const now = Date.now();
   config = config || getConfig();
@@ -938,18 +1184,22 @@ function collectSkillFiles(config) {
           projectName: root.projectName,
         });
       }
-      for (const project of projects) {
-        if (!project.localPath) continue;
-        for (const root of runtime.getSkillRoots({ homeDir, project })) {
-          if (root.scope !== 'project') continue;
-          _collectNativeSkillsDir(root.dir, root.scope, seenFor(root.scope, root.projectName), skillFiles, {
-            projectName: root.projectName,
-          });
-        }
-      }
     }
   } catch { /* runtime registry optional in partial installs */ }
 
+  // Project-scope skill roots: aggregate across runtimes via the shared
+  // getProjectHarnesses helper so dedup-by-absolute-path happens once
+  // (e.g. `<repo>/.agents/skills` is exposed by both Codex and Copilot).
+  for (const project of projects) {
+    if (!project.localPath) continue;
+    for (const root of getProjectHarnesses(project).skills) {
+      if (root.scope !== 'project') continue;
+      _collectNativeSkillsDir(root.dir, root.scope, seenFor(root.scope, root.projectName), skillFiles, {
+        projectName: root.projectName,
+      });
+    }
+  }
+
   // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json
   // Plugins use commands/*.md and/or skills/<name>/SKILL.md and/or skills/SKILL.md
   try {
@@ -1116,7 +1366,10 @@ function collectCommandFiles(config) {
   function addCommandDir(rootDir, scope, extra = {}) {
     const root = path.resolve(rootDir);
     for (const cmd of _collectMarkdownFilesRecursive(root)) {
-      const key = `${scope}:${extra.projectName || ''}:${root}:${cmd.rel}`;
+      // Dedup is by absolute path + relative-file so runtimes that share a
+      // dir (none today for commands, but the shape mirrors collectSkillFiles)
+      // don't double-list.
+      const key = `${root}:${cmd.rel}`;
       if (seen.has(key)) continue;
       seen.add(key);
       const commandName = cmd.rel.replace(/\.md$/, '').replace(/\\/g, '/');
@@ -1124,7 +1377,20 @@ function collectCommandFiles(config) {
     }
   }
 
-  addCommandDir(path.join(homeDir, '.claude', 'commands'), 'claude-code');
+  // User-scope command roots from every runtime adapter (was hard-coded to
+  // `~/.claude/commands`; Copilot exposes `~/.copilot/commands` and Codex
+  // currently returns nothing — adapters fall in/out as their CLIs evolve).
+  try {
+    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    for (const runtimeName of listRuntimes()) {
+      const runtime = resolveRuntime(runtimeName);
+      if (typeof runtime.getCommandRoots !== 'function') continue;
+      for (const root of runtime.getCommandRoots({ homeDir })) {
+        if (!root || !root.dir || root.scope === 'project') continue;
+        addCommandDir(root.dir, root.scope);
+      }
+    }
+  } catch { /* runtime registry optional in partial installs */ }
 
   try {
     const pluginsFile = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
@@ -1138,9 +1404,15 @@ function collectCommandFiles(config) {
     }
   } catch { /* optional */ }
 
+  // Project-scope command roots aggregated across runtimes via the shared
+  // getProjectHarnesses helper. Dedup-by-absolute-path is handled inside the
+  // helper so adapters that name the same dir don't double-list here.
   for (const project of getProjects(config)) {
     if (!project.localPath) continue;
-    addCommandDir(path.resolve(project.localPath, '.claude', 'commands'), 'project', { projectName: project.name });
+    for (const root of getProjectHarnesses(project).commands) {
+      if (!root || !root.dir || root.scope !== 'project') continue;
+      addCommandDir(root.dir, root.scope, { projectName: root.projectName || project.name });
+    }
   }
 
   return commandFiles;
@@ -1154,10 +1426,42 @@ function _commandTitle(content, fallback) {
   return fallback;
 }
 
+// Dashboard-facing wrapper over `collectCommandFiles`. Returns a normalized
+// per-entry shape the tools.html "Slash commands" panel + `/api/status`
+// slow-state slice render directly. Includes the resolved title (from YAML
+// `description:` frontmatter or first `# heading`) and a `dir`-with-forward-
+// slashes copy so the renderer can build display strings without re-walking
+// the file on the client. Sort matches getCommandIndex (project → plugin →
+// per-runtime user) so the panel and the agent-facing index stay in lockstep.
+function getCommands(config) {
+  try {
+    const commandFiles = collectCommandFiles(config).sort((a, b) => {
+      const priority = { project: 0, plugin: 1, 'claude-code': 2, copilot: 3, codex: 4 };
+      return (priority[a.scope] ?? 9) - (priority[b.scope] ?? 9)
+        || String(a.projectName || '').localeCompare(String(b.projectName || ''))
+        || String(a.commandName || '').localeCompare(String(b.commandName || ''));
+    });
+    return commandFiles.map(({ file, dir, rel, scope, commandName, projectName, pluginName }) => {
+      const content = safeRead(path.join(dir, file)) || '';
+      return {
+        commandName,
+        title: _commandTitle(content, commandName),
+        file,
+        rel: rel || file,
+        dir: dir.replace(/\\/g, '/'),
+        scope,
+        projectName: projectName || null,
+        pluginName: pluginName || null,
+      };
+    });
+  } catch { return []; }
+}
+
 function getCommandIndex(config) {
   try {
     const commandFiles = collectCommandFiles(config).sort((a, b) => {
-      const priority = { project: 0, plugin: 1, 'claude-code': 2 };
+      // Lower numbers sort first. Unknown scopes (future runtimes) fall to 9.
+      const priority = { project: 0, plugin: 1, 'claude-code': 2, copilot: 3 };
       return (priority[a.scope] ?? 9) - (priority[b.scope] ?? 9)
         || String(a.projectName || '').localeCompare(String(b.projectName || ''))
         || String(a.commandName || '').localeCompare(String(b.commandName || ''));
@@ -1174,7 +1478,7 @@ function getCommandIndex(config) {
         ? `project:${projectName || 'unknown'}`
         : scope === 'plugin'
           ? `plugin:${pluginName || 'unknown'}`
-          : 'claude-code';
+          : scope || 'unknown';
       index += `- \`/${commandName}\` (${label}) — ${title}\n`;
       index += `  File: \`${dir.replace(/\\/g, '/')}/${f}\`\n`;
     }
@@ -2597,12 +2901,20 @@ module.exports = {
 
   // Pull requests
   getPrs, getPullRequests,
+  // W-mqba5ulq000nd255 — exported for direct unit testing of the cross-project
+  // PR dedupe helpers.
+  _pickPrDedupeWinner,
+  _groupPrRecordsById,
 
   // Skills
   collectSkillFiles, getSkills, getSkillIndex, invalidateSkillsCache,
 
   // Commands
-  collectCommandFiles, getCommandIndex,
+  collectCommandFiles, getCommandIndex, getCommands,
+
+  // Harness aggregation (P-f5a91c30) — shared union over per-runtime
+  // getSkillRoots / getCommandRoots / getMcpConfigPaths.
+  getUserHarnesses, getProjectHarnesses,
 
   // Knowledge base
   getKnowledgeBaseEntries, getKnowledgeBaseEntriesSnapshot, getKnowledgeBaseIndex,

package/engine/runtimes/claude.js

@@ -800,6 +800,40 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
   return targets;
 }
 
+// Slash-command roots. Mirrors getSkillRoots' shape so consumers can iterate
+// runtimes generically. Plugin-installed command dirs are NOT enumerated here
+// — those are discovered dynamically from `~/.claude/plugins/installed_plugins.json`
+// in engine/queries.js#collectCommandFiles and stay there because they require
+// a registry read, not a fixed dir.
+function getCommandRoots({ homeDir = os.homedir(), project = null } = {}) {
+  const roots = [
+    { dir: path.join(homeDir, '.claude', 'commands'), scope: 'claude-code' },
+  ];
+  if (project?.localPath) {
+    const projectName = project.name || path.basename(project.localPath);
+    roots.push(
+      { dir: path.join(project.localPath, '.claude', 'commands'), scope: 'project', projectName },
+    );
+  }
+  return roots;
+}
+
+// MCP config files this runtime reads. The user-scope file is `~/.claude.json`
+// (which holds more than mcpServers but the engine only reads the mcpServers
+// slice). Project-scope `<root>/.mcp.json` is a cross-runtime convention —
+// Claude and Copilot both read it — so it appears in both adapters; consumers
+// that aggregate across runtimes should dedupe by absolute path.
+function getMcpConfigPaths({ homeDir = os.homedir(), project = null } = {}) {
+  const paths = [
+    { file: path.join(homeDir, '.claude.json'), scope: 'claude-code' },
+  ];
+  if (project?.localPath) {
+    const projectName = project.name || path.basename(project.localPath);
+    paths.push({ file: path.join(project.localPath, '.mcp.json'), scope: 'project', projectName });
+  }
+  return paths;
+}
+
 // Heuristic: does `model` look like a Claude model identifier? Powers the
 // preflight "stale model after CLI switch" warning in cli.js. Returning false
 // means "this looks wrong for Claude" — gpt-5.4 / o3-* / codex etc. Keep this
@@ -828,6 +862,8 @@ module.exports = {
   getUserAssetDirs,
   getSkillRoots,
   getSkillWriteTargets,
+  getCommandRoots,
+  getMcpConfigPaths,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,

package/engine/runtimes/codex.js

@@ -395,6 +395,23 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
   return targets;
 }
 
+// Slash-command roots. Codex CLI does not yet surface user-defined commands
+// (per docs/harness-propagation.md adapter table). Return empty to satisfy the
+// contract — consumers iterate runtimes and handle empty arrays gracefully.
+// Replace with real paths once the CLI ships an official command discovery
+// surface so the engine automatically picks them up.
+function getCommandRoots({ homeDir = os.homedir(), project = null } = {}) {
+  return [];
+}
+
+// MCP config files. Codex MCP wiring is not yet a stable contract (see
+// harness-propagation table). Return empty until the CLI ships an official
+// config path; consumers that aggregate across runtimes will simply skip
+// codex's contribution.
+function getMcpConfigPaths({ homeDir = os.homedir(), project = null } = {}) {
+  return [];
+}
+
 function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
   if (!agentId || agentId.startsWith('temp-') || !agentsDir) return null;
   const sessionPath = path.join(agentsDir, agentId, 'session.json');
@@ -835,6 +852,8 @@ module.exports = {
   getUserAssetDirs,
   getSkillRoots,
   getSkillWriteTargets,
+  getCommandRoots,
+  getMcpConfigPaths,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,

package/engine/runtimes/copilot.js

@@ -526,42 +526,6 @@ function buildSpawnFlags(opts = {}) {
   return flags;
 }
 
-function getUserAssetDirs({ homeDir = os.homedir() } = {}) {
-  return [
-    path.join(homeDir, '.copilot'),
-    path.join(homeDir, '.agents'),
-  ];
-}
-
-function getSkillRoots({ homeDir = os.homedir(), project = null } = {}) {
-  const roots = [
-    { scope: 'copilot', dir: path.join(homeDir, '.copilot', 'skills') },
-    { scope: 'agent-skill', dir: path.join(homeDir, '.agents', 'skills') },
-  ];
-  if (project?.localPath) {
-    roots.push(
-      {
-        scope: 'project',
-        projectName: project.name,
-        dir: path.join(project.localPath, '.github', 'skills'),
-      },
-      {
-        scope: 'project',
-        projectName: project.name,
-        dir: path.join(project.localPath, '.agents', 'skills'),
-      },
-    );
-  }
-  return roots;
-}
-
-function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
-  return {
-    personal: path.join(homeDir, '.copilot', 'skills'),
-    project: project?.localPath ? path.join(project.localPath, '.github', 'skills') : null,
-  };
-}
-
 // Stamped into every session.json this adapter writes so the pre-spawn resume
 // path can detect "session was produced by a different runtime" — Copilot
 // rejects Claude session IDs (and vice versa) with "No conversation found",
@@ -1297,6 +1261,31 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
   return targets;
 }
 
+// Slash-command roots. Copilot CLI's project-scope command discovery is not
+// yet a confirmed contract (the harness-propagation doc annotates the user
+// path as "probe"); leaving project rows empty matches that. Add them here
+// once the CLI ships an official path so consumers automatically pick them up.
+function getCommandRoots({ homeDir = os.homedir(), project = null } = {}) {
+  return [
+    { dir: path.join(homeDir, '.copilot', 'commands'), scope: 'copilot' },
+  ];
+}
+
+// MCP config files. The user-scope file is `~/.copilot/mcp-config.json`.
+// Project-scope `<root>/.mcp.json` is the cross-runtime convention Copilot
+// also honors; it also appears in claude.getMcpConfigPaths, so consumers that
+// aggregate across runtimes should dedupe by absolute path.
+function getMcpConfigPaths({ homeDir = os.homedir(), project = null } = {}) {
+  const paths = [
+    { file: path.join(homeDir, '.copilot', 'mcp-config.json'), scope: 'copilot' },
+  ];
+  if (project?.localPath) {
+    const projectName = project.name || path.basename(project.localPath);
+    paths.push({ file: path.join(project.localPath, '.mcp.json'), scope: 'project', projectName });
+  }
+  return paths;
+}
+
 module.exports = {
   name: 'copilot',
   capabilities,
@@ -1313,6 +1302,8 @@ module.exports = {
   getUserAssetDirs,
   getSkillRoots,
   getSkillWriteTargets,
+  getCommandRoots,
+  getMcpConfigPaths,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,