@yemi33/minions 0.1.2179 → 0.1.2180

package/engine/queries.js

@@ -1041,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();
@@ -1069,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 {
@@ -1247,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, '/');
@@ -1255,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');
@@ -1269,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;
@@ -1285,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 || ''));
@@ -1305,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`;
     }
@@ -2737,7 +2910,11 @@ module.exports = {
   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,