@yemi33/minions 0.1.1681 → 0.1.1682

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.1682 (2026-05-02)
+
+### Features
+- index Copilot plugin skills and surface as separate dashboard tab
+
+### Other
+- test(meeting): add direct unit tests for internal scoring/formatting/path-resolution helpers (#1985)
+- docs: document new optional runtime adapter methods for skills
+- Keep runtime skills adapter-owned
+- docs: update copilot instructions
+
 ## 0.1.1681 (2026-05-02)
 
 ### Features

package/dashboard/js/render-skills.js

@@ -13,13 +13,28 @@ function renderSkills(skills) {
     return;
   }
 
-  const sourceIcon = (s) => s === 'claude-code' ? '⚡' : s === 'plugin' ? '🔌' : s?.startsWith('project:') ? '📁' : '🔧';
-  const sourceLabel = (s) => s === 'plugin' ? 'plugin' : s?.startsWith('project:') ? s.replace('project:', '') : 'global';
+  const SOURCE_META = {
+    'claude-code':    { icon: '⚡', label: 'global',  group: 'global'  },
+    'copilot':        { icon: '🤖', label: 'copilot', group: 'copilot' },
+    'agent-skill':    { icon: '🤝', label: 'agent',   group: 'agent'   },
+    'plugin':         { icon: '🔌', label: 'plugin',  group: 'plugins' },
+    'copilot-plugin': { icon: '🤖', label: 'copilot', group: 'copilot' },
+  };
+  const metaOf = (s) => {
+    if (SOURCE_META[s]) return SOURCE_META[s];
+    if (s && s.startsWith('project:')) {
+      const name = s.slice('project:'.length);
+      return { icon: '📁', label: name, group: name };
+    }
+    return { icon: '🔧', label: 'global', group: 'global' };
+  };
+  const sourceIcon = (s) => metaOf(s).icon;
+  const sourceLabel = (s) => metaOf(s).label;
 
   // Group by source
   const groups = {};
   for (const r of skills) {
-    const key = r.source === 'plugin' ? 'plugins' : r.source?.startsWith('project:') ? r.source.replace('project:', '') : 'global';
+    const key = metaOf(r.source).group;
     if (!groups[key]) groups[key] = [];
     groups[key].push(r);
   }

package/dashboard.js

@@ -170,10 +170,20 @@ function _normalizeSkillDirForCompare(dir) {
   return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
 }
 
+// Mirrors the source string emitted by `getSkills()` so `_resolveSkillReadPath`
+// can match a request's `source` param against the entries collectSkillFiles returns.
+const _SKILL_ENTRY_SOURCE_BY_SCOPE = {
+  'claude-code': 'claude-code',
+  'copilot': 'copilot',
+  'agent-skill': 'agent-skill',
+  'plugin': 'plugin',
+  'copilot-plugin': 'copilot-plugin',
+};
+
 function _skillEntrySource(entry) {
   if (!entry) return '';
-  if (entry.scope === 'claude-code') return 'claude-code';
-  if (entry.scope === 'plugin') return 'plugin';
+  const mapped = _SKILL_ENTRY_SOURCE_BY_SCOPE[entry.scope];
+  if (mapped) return mapped;
   if (entry.scope === 'project') return 'project:' + entry.projectName;
   return entry.scope || '';
 }
@@ -4495,17 +4505,35 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     let content = '';
     const skillPath = _resolveSkillReadPath({ file, dir, source, config: CONFIG });
     if (skillPath) content = safeRead(skillPath) || '';
+    // Fallback when caller didn't supply `dir`: try the source's known native
+    // locations. `_resolveSkillReadPath` only matches entries returned by
+    // `collectSkillFiles`, so a skill that already has `dir` will resolve there.
     if (!content && !dir) {
-      // Fallback: search Claude Code skills, then project skills
       const home = os.homedir();
-      const claudePath = path.join(home, '.claude', 'skills', file.replace('.md', '').replace('SKILL', ''), 'SKILL.md');
-      content = safeRead(claudePath) || '';
-      if (!content) {
-        if (source.startsWith('project:')) {
-          const proj = PROJECTS.find(p => p.name === source.replace('project:', ''));
-          if (proj) content = safeRead(path.join(proj.localPath, '.claude', 'skills', file)) || '';
+      const skillStem = file.replace(/\.md$/, '').replace(/^SKILL$/, '');
+      const candidates = [];
+      if (source === 'claude-code' || !source) {
+        candidates.push(path.join(home, '.claude', 'skills', skillStem, 'SKILL.md'));
+      }
+      if (source === 'copilot') {
+        candidates.push(path.join(home, '.copilot', 'skills', skillStem, 'SKILL.md'));
+      }
+      if (source === 'agent-skill') {
+        candidates.push(path.join(home, '.agents', 'skills', skillStem, 'SKILL.md'));
+      }
+      if (source.startsWith('project:')) {
+        const proj = PROJECTS.find(p => p.name === source.slice('project:'.length));
+        if (proj?.localPath) {
+          for (const sub of ['.claude', '.github', '.agents']) {
+            candidates.push(path.join(proj.localPath, sub, 'skills', file));
+            candidates.push(path.join(proj.localPath, sub, 'skills', skillStem, 'SKILL.md'));
+          }
         }
       }
+      for (const c of candidates) {
+        content = safeRead(c) || '';
+        if (content) break;
+      }
     }
     res.setHeader('Content-Type', 'text/plain; charset=utf-8');
     res.setHeader('Access-Control-Allow-Origin', '*');

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-02T13:35:00.752Z"
+  "cachedAt": "2026-05-02T15:15:12.425Z"
 }

package/engine/lifecycle.js

@@ -1626,9 +1626,23 @@ function checkForLearnings(agentId, agentInfo, taskDesc) {
   log('warn', `${agentInfo?.name || agentId} didn't write learnings — no follow-up queued`);
 }
 
-function extractSkillsFromOutput(output, agentId, dispatchItem, config) {
+function skillWriteTargets(runtimeName, project = null) {
+  try {
+    const runtime = resolveRuntime(runtimeName || 'claude');
+    if (typeof runtime.getSkillWriteTargets === 'function') {
+      return runtime.getSkillWriteTargets({ homeDir: os.homedir(), project });
+    }
+  } catch { /* fall through to Claude-compatible legacy target */ }
+  return {
+    personal: path.join(os.homedir(), '.claude', 'skills'),
+    project: project?.localPath ? path.resolve(project.localPath, '.claude', 'skills') : null,
+  };
+}
+
+function extractSkillsFromOutput(output, agentId, dispatchItem, config, runtimeName = null) {
 
   if (!output) return;
+  const effectiveRuntime = runtimeName || dispatchItem?.meta?.runtimeName || dispatchItem?.runtimeName || 'claude';
   let fullText = '';
   for (const line of output.split('\n')) {
     try {
@@ -1666,6 +1680,9 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config) {
     if (scope === 'project' && project) {
       const proj = shared.getProjects(config).find(p => p.name === project);
       if (proj) {
+        const projectSkillRoot = skillWriteTargets(effectiveRuntime, proj).project
+          || path.resolve(proj.localPath, '.claude', 'skills');
+        const projectSkillPath = path.join(projectSkillRoot, skillDirName, 'SKILL.md');
         const centralPath = path.join(MINIONS_DIR, 'work-items.json');
         let skillId = null;
         mutateJsonFileLocked(centralPath, data => {
@@ -1673,7 +1690,7 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config) {
           if (data.some(i => i.title === `Add skill: ${name}` && i.status !== WI_STATUS.FAILED)) return data;
           skillId = `SK${String(data.filter(i => i.id?.startsWith('SK')).length + 1).padStart(3, '0')}`;
           data.push({ id: skillId, type: 'implement', title: `Add skill: ${name}`,
-            description: `Create project-level skill \`${skillDirName}/SKILL.md\` in ${project}.\n\nWrite this file to \`${proj.localPath}/.claude/skills/${skillDirName}/SKILL.md\` via a PR.\n\n## Skill Content\n\n\`\`\`\n${enrichedBlock}\n\`\`\``,
+            description: `Create project-level skill \`${skillDirName}/SKILL.md\` in ${project}.\n\nWrite this file to \`${projectSkillPath}\` via a PR.\n\n## Skill Content\n\n\`\`\`\n${enrichedBlock}\n\`\`\``,
             priority: 'low', status: WI_STATUS.QUEUED, created: ts(), createdBy: `engine:skill-extraction:${agentName}` });
           return data;
         }, { skipWriteIfUnchanged: true });
@@ -1682,18 +1699,18 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config) {
         }
       }
     } else {
-      // Write in Claude Code native format: ~/.claude/skills/<name>/SKILL.md
-      const claudeSkillsDir = path.join(os.homedir(), '.claude', 'skills');
-      const skillDir = path.join(claudeSkillsDir, name.replace(/[^a-z0-9-]/g, '-'));
+      const personalSkillRoot = skillWriteTargets(effectiveRuntime).personal;
+      const skillDir = path.join(personalSkillRoot, name.replace(/[^a-z0-9-]/g, '-'));
       const skillPath = path.join(skillDir, 'SKILL.md');
       if (!fs.existsSync(skillPath)) {
-        // Convert to Claude Code format: only name + description in frontmatter
+        // Native skill format: only name + description in frontmatter.
         const description = m('description') || m('trigger') || `Auto-extracted skill from ${agentName}`;
         const body = fmMatch[2] || '';
         const ccContent = `---\nname: ${name}\ndescription: ${description}\n---\n\n${body.trim()}\n`;
         if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
         shared.safeWrite(skillPath, ccContent);
-        log('info', `Extracted skill "${name}" from ${agentName} → ~/.claude/skills/${name.replace(/[^a-z0-9-]/g, '-')}/SKILL.md`);
+        try { require('./queries').invalidateSkillsCache(); } catch {}
+        log('info', `Extracted skill "${name}" from ${agentName} → ${skillPath}`);
       } else {
         log('info', `Skill "${name}" already exists, skipping`);
       }

package/engine/meeting.js

@@ -45,7 +45,7 @@ function getStructuredNoteArtifacts(structuredCompletion) {
 
 function isPathInside(parent, child) {
   const rel = path.relative(parent, child);
-  return rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+  return Boolean(rel && !rel.startsWith('..') && !path.isAbsolute(rel));
 }
 
 function resolveMeetingNoteArtifactPath(artifactPath) {
@@ -114,27 +114,34 @@ function formatMeetingContributions(entries, agents, emptyText, label, maxBytes)
   return truncateMeetingContext(combined, maxBytes, label);
 }
 
-function cleanMeetingSummaryText(text) {
+function stripMeetingSummaryMarkdown(text) {
   return String(text || '')
     .replace(/\r/g, '')
-    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/```[\s\S]*?```/g, '\n')
     .replace(/`([^`]+)`/g, '$1')
     .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-    .replace(/^[#>*-]+\s*/gm, '')
+    .replace(/^\s*(?:[#>*-]+|\d+[.)])\s*/gm, '');
+}
+
+function cleanMeetingSummaryText(text) {
+  return stripMeetingSummaryMarkdown(text)
     .replace(/\s+/g, ' ')
     .trim();
 }
 
 function splitMeetingSummaryFragments(text) {
-  return cleanMeetingSummaryText(text)
-    .split(/\n+|(?:[.!?])\s+|;\s+/)
-    .map(s => s.trim())
+  return stripMeetingSummaryMarkdown(text)
+    .split(/\n+|[.!?]+\s*|;\s*/)
+    .map(s => s.replace(/\s+/g, ' ').trim())
     .filter(Boolean);
 }
 
 function truncateMeetingSummary(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, Math.max(0, maxLen - 1)).trimEnd() + '…';
+  const value = String(text || '');
+  if (!value) return '';
+  if (!Number.isFinite(maxLen) || maxLen <= 0) return '';
+  if (value.length < maxLen) return value;
+  return value.slice(0, Math.max(0, maxLen - 1)) + '…';
 }
 
 function formatMeetingSummaryBullets(entries, agents, emptyText, maxLen) {
@@ -148,13 +155,14 @@ function formatMeetingSummaryBullets(entries, agents, emptyText, maxLen) {
 }
 
 function scoreMeetingTakeaway(fragment) {
-  const lower = fragment.toLowerCase();
+  const value = String(fragment || '');
+  const lower = value.toLowerCase();
   let score = 0;
   if (/(should|must|need to|needs to|recommend|recommended|action|next step|follow up|fix|mitigat|investigat|verify|test|block)/.test(lower)) score += 4;
   if (/(agree|aligned|consensus|support|prefer)/.test(lower)) score += 3;
   if (/(disagree|however|but|risk|risky|concern|trade-off|question|uncertain|worry)/.test(lower)) score += 3;
-  if (fragment.length >= 40 && fragment.length <= 180) score += 2;
-  if (fragment.length > 220) score -= 1;
+  if (value.length >= 40 && value.length <= 180) score += 2;
+  if (value.length > 220) score -= 1;
   return score;
 }
 
@@ -195,7 +203,9 @@ function collectMeetingNextSteps(meeting) {
       }
     }
   }
-  return ['- Review the findings and debate, then add a human-written conclusion if more nuance is needed.'];
+  return steps.length
+    ? steps
+    : ['- Review the findings and debate, then add a human-written conclusion if more nuance is needed.'];
 }
 
 function buildTimedOutMeetingConclusion(meeting, agents) {
@@ -615,4 +625,17 @@ module.exports = {
   discoverMeetingWork, collectMeetingFindings, checkMeetingTimeouts,
   addMeetingNote, advanceMeetingRound, endMeeting, archiveMeeting, unarchiveMeeting, deleteMeeting,
   EMPTY_OUTPUT_PATTERNS,
+  // exported for testing — engine code MUST go through
+  // getMeetings/discoverMeetingWork/collectMeetingFindings/checkMeetingTimeouts,
+  // never these helpers directly.
+  isPathInside,
+  resolveMeetingNoteArtifactPath,
+  cleanMeetingSummaryText,
+  splitMeetingSummaryFragments,
+  truncateMeetingSummary,
+  formatMeetingSummaryBullets,
+  scoreMeetingTakeaway,
+  collectMeetingTakeaways,
+  collectMeetingNextSteps,
+  buildTimedOutMeetingConclusion,
 };

package/engine/playbook.js

@@ -5,12 +5,13 @@
  */
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
 const { safeJson, safeRead, getProjects, log, ts, dateStamp, truncateTextBytes, ENGINE_DEFAULTS, WI_STATUS, WORK_TYPE, PR_STATUS, DISPATCH_RESULT } = shared;
-const { getConfig, getDispatch, getNotes, getAgentCharter, getPrs, AGENTS_DIR } = queries;
+const { getConfig, getDispatch, getNotes, getAgentCharter, getPrs, getKnowledgeBaseIndex, AGENTS_DIR } = queries;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
 const PLAYBOOKS_DIR = path.join(MINIONS_DIR, 'playbooks');
@@ -394,8 +395,8 @@ function renderPlaybook(type, vars) {
   content += '````\n```skill\n';
   content += `---\nname: short-descriptive-name\ndescription: One-line description of what this skill does\nallowed-tools: Bash, Read, Edit\ntrigger: when should an agent use this\nscope: minions\nproject: any\n---\n\n# Skill Title\n\n## Steps\n1. ...\n2. ...\n\n## Notes\n...\n`;
   content += '```\n````\n\n';
-  content += `- Set \`scope: minions\` for cross-project or Minions-wide skills; the engine writes them to ~/.claude/skills/ so they are available in normal Claude windows too\n`;
-  content += `- Set \`scope: project\` + \`project: <name>\` only for repo-specific skills; the engine queues a PR to <project>/.claude/skills/\n`;
+  content += `- Set \`scope: minions\` for cross-project or Minions-wide skills; the engine writes them to the selected runtime's native personal skills directory\n`;
+  content += `- Set \`scope: project\` + \`project: <name>\` only for repo-specific skills; the engine queues a PR to the selected runtime's native project skills directory\n`;
   content += `- Emit at most one skill block per task unless you uncovered two clearly distinct reusable workflows\n`;
   content += `- Do NOT create a skill for one-off bug fixes, isolated command output, obvious repo facts, or anything already covered by existing docs/playbooks/skills\n`;
 
@@ -503,7 +504,7 @@ function buildSystemPrompt(agentId, config, project) {
   prompt += `3. Follow the project conventions in CLAUDE.md if present\n`;
   prompt += `4. Write learnings to the path specified in the task prompt (format: \`notes/inbox/{agent}-{work-item-id}-{date}-{time}.md\`)\n`;
   prompt += `5. Agent status is managed by the engine via dispatch.json — agents do not need to track their own status\n`;
-  prompt += `6. If you discover a repeatable workflow, output it as a \\\`\\\`\\\`skill fenced block — minions-scoped skills are auto-extracted to ~/.claude/skills/ so they are available in normal Claude windows too\n\n`;
+  prompt += `6. If you discover a repeatable workflow, output it as a \\\`\\\`\\\`skill fenced block — minions-scoped skills are auto-extracted to the selected runtime's native personal skills directory\n\n`;
 
   return prompt;
 }
@@ -514,6 +515,26 @@ function buildAgentContext(agentId, config, project) {
   project = project || getProjects(config)[0] || {};
   let context = '';
 
+  function appendContextFile(heading, filePath, maxBytes, extra = '') {
+    if (!filePath) return;
+    const content = safeRead(filePath);
+    if (!content || !content.trim()) return;
+    const truncated = Buffer.byteLength(content, 'utf8') > maxBytes
+      ? truncateTextBytes(content, maxBytes, '\n\n_...truncated; read the full file if needed_')
+      : content;
+    context += `## ${heading}\n\n`;
+    if (extra) context += `${extra}\n\n`;
+    context += `${truncated}\n\n`;
+  }
+
+  function appendIndex(heading, body, maxBytes) {
+    if (!body || !String(body).trim()) return;
+    const truncated = Buffer.byteLength(body, 'utf8') > maxBytes
+      ? truncateTextBytes(body, maxBytes, '\n\n_...index truncated; use Glob/Read for the full list_')
+      : body;
+    context += `## ${heading}\n\n${truncated.replace(/^## .+\n\n/, '')}\n`;
+  }
+
 
   // Agent history — last 5 tasks only (keeps it relevant, avoids 37KB dumps)
   const history = safeRead(path.join(AGENTS_DIR, agentId, 'history.md'));
@@ -527,16 +548,19 @@ function buildAgentContext(agentId, config, project) {
 
   // Project conventions (from CLAUDE.md) — always relevant for code quality
   if (project.localPath) {
-    const claudeMd = safeRead(path.join(project.localPath, 'CLAUDE.md'));
-    if (claudeMd && claudeMd.trim()) {
-      const truncated = claudeMd.length > 8192 ? claudeMd.slice(0, 8192) + '\n\n...(truncated)' : claudeMd;
-      context += `## Project Conventions (from CLAUDE.md)\n\n${truncated}\n\n`;
-    }
+    appendContextFile('Project Conventions (from CLAUDE.md)', path.join(project.localPath, 'CLAUDE.md'), 8192);
+    appendContextFile('Project Agent Instructions (from AGENTS.md)', path.join(project.localPath, 'AGENTS.md'), 8192,
+      'These instructions are explicitly injected because some runtimes suppress automatic AGENTS.md loading. Follow them unless they conflict with the Minions task contract or playbook.');
+    appendContextFile('Project Copilot Instructions (from .github/copilot-instructions.md)', path.join(project.localPath, '.github', 'copilot-instructions.md'), 8192,
+      'Follow these repository instructions unless they conflict with the Minions task contract or playbook.');
   }
 
-  // KB and skills: NOT injected — agents can Glob/Read when needed
-  // This saves ~27KB per dispatch. Reference note so agents know they exist:
-  context += `## Reference Files\n\nKnowledge base entries are in \`knowledge/{category}/*.md\`. User-level Minions skills live in \`~/.claude/skills/\`, and project-specific skills live in \`<project>/.claude/skills/\`. Use Glob/Read when relevant.\n\n`;
+  appendContextFile('User Claude Instructions (from ~/.claude/CLAUDE.md)', path.join(os.homedir(), '.claude', 'CLAUDE.md'), 8192,
+    'These are the user-level Claude Code instructions available in regular Claude usage. Follow them unless they conflict with the Minions task contract or playbook.');
+
+  appendIndex('Knowledge Base Reference', getKnowledgeBaseIndex(), 8192);
+
+  context += `## Reference Files\n\nKnowledge base entries are in \`knowledge/{category}/*.md\`, and project-local playbooks live in \`projects/<project>/playbooks/\`. Runtime-native skills and commands are left to the selected CLI runtime; Minions does not inject their contents into the task prompt.\n\n`;
 
   // Minions awareness: what's in flight, who's doing what
   const dispatch = getDispatch();

package/engine/queries.js

@@ -722,31 +722,120 @@ function buildPrUrlFromId(prId, pr, projects) {
 
 // ── Skills ──────────────────────────────────────────────────────────────────
 
+// Walk a `skills/` dir and push SKILL.md entries — handles both flat
+// (skills/SKILL.md → pluginName) and nested (skills/<entry>/SKILL.md →
+// pluginName:entry) layouts. Used by both Claude and Copilot plugin scans.
+function _collectPluginSkillsDir(skillsDir, pluginName, scope, seenSet, out) {
+  let entries;
+  try { entries = fs.readdirSync(skillsDir, { withFileTypes: true }); } catch { return; }
+  for (const dirent of entries) {
+    const entry = dirent.name;
+    const entryPath = path.join(skillsDir, entry);
+    if (entry === 'SKILL.md') {
+      if (!seenSet.has(pluginName)) {
+        out.push({ file: 'SKILL.md', dir: skillsDir, scope, skillName: pluginName });
+        seenSet.add(pluginName);
+      }
+    } else if (dirent.isDirectory()) {
+      const nestedSkill = path.join(entryPath, 'SKILL.md');
+      if (fs.existsSync(nestedSkill)) {
+        const name = pluginName + ':' + entry;
+        if (!seenSet.has(name)) {
+          out.push({ file: 'SKILL.md', dir: entryPath, scope, skillName: name });
+          seenSet.add(name);
+        }
+      }
+    }
+  }
+}
+
+function _collectNativeSkillsDir(skillsDir, scope, seenSet, out, extra = {}) {
+  let entries;
+  try { entries = fs.readdirSync(skillsDir, { withFileTypes: true }); } catch { return; }
+  for (const dirent of entries) {
+    const entry = dirent.name;
+    if (entry === 'README.md') continue;
+    const entryPath = path.join(skillsDir, entry);
+    if (dirent.isDirectory()) {
+      const skillFile = path.join(entryPath, 'SKILL.md');
+      const nestedSkillFile = path.join(entryPath, 'skills', 'SKILL.md');
+      if (fs.existsSync(skillFile) && !seenSet.has(entry)) {
+        out.push({ file: 'SKILL.md', dir: entryPath, scope, skillName: entry, ...extra });
+        seenSet.add(entry);
+      } else if (fs.existsSync(nestedSkillFile) && !seenSet.has(entry)) {
+        out.push({ file: 'SKILL.md', dir: path.join(entryPath, 'skills'), scope, skillName: entry, ...extra });
+        seenSet.add(entry);
+      }
+    } else if (entry.endsWith('.md') && scope === 'project') {
+      const key = extra.projectName ? `${extra.projectName}:${entry}` : entry;
+      if (seenSet.has(key)) continue;
+      out.push({ file: entry, dir: skillsDir, scope, ...extra });
+      seenSet.add(key);
+    }
+  }
+}
+
+let _skillsCache = null;
+let _skillsCacheTs = 0;
+let _skillsCacheKey = null;
+let _skillIndexCache = null;
+let _skillIndexCacheTs = 0;
+let _skillIndexCacheKey = null;
+const SKILLS_CACHE_TTL = 30000; // 30s — skill files change rarely (agent extraction, manual authoring)
+
+function invalidateSkillsCache() {
+  _skillsCache = null;
+  _skillsCacheTs = 0;
+  _skillsCacheKey = null;
+  _skillIndexCache = null;
+  _skillIndexCacheTs = 0;
+  _skillIndexCacheKey = null;
+}
+
+function _skillsCacheKeyFor(config, homeDir) {
+  const projects = getProjects(config).map(p => [p.name || '', p.localPath || '']);
+  return JSON.stringify({ homeDir, projects });
+}
+
 function collectSkillFiles(config) {
+  const now = Date.now();
   config = config || getConfig();
+  const homeDir = os.homedir();
+  const projects = getProjects(config);
+  const cacheKey = _skillsCacheKeyFor(config, homeDir);
+  if (_skillsCache && _skillsCacheKey === cacheKey && (now - _skillsCacheTs) < SKILLS_CACHE_TTL) return _skillsCache;
   const skillFiles = [];
   const seen = new Set(); // dedup by name
 
-  // 1. Claude Code native skills: ~/.claude/skills/<name>/SKILL.md
-  const homeDir = os.homedir();
-  const claudeSkillsDir = path.join(homeDir, '.claude', 'skills');
+  // 1. Runtime-native skills. Runtime adapters own their native locations so
+  // Minions stays a thin orchestration layer rather than a parallel skills system.
+  const seenByScope = new Map();
+  function seenFor(scope, projectName) {
+    const key = scope === 'project' ? `project:${projectName || ''}` : scope;
+    if (!seenByScope.has(key)) seenByScope.set(key, new Set());
+    return seenByScope.get(key);
+  }
   try {
-    const dirs = fs.readdirSync(claudeSkillsDir).filter(d => {
-      try { return fs.statSync(path.join(claudeSkillsDir, d)).isDirectory(); } catch { return false; }
-    });
-    for (const d of dirs) {
-      // Check both <name>/SKILL.md and <name>/skills/SKILL.md (Claude Code uses both)
-      const skillFile = path.join(claudeSkillsDir, d, 'SKILL.md');
-      const nestedSkillFile = path.join(claudeSkillsDir, d, 'skills', 'SKILL.md');
-      if (fs.existsSync(skillFile)) {
-        skillFiles.push({ file: 'SKILL.md', dir: path.join(claudeSkillsDir, d), scope: 'claude-code', skillName: d });
-        seen.add(d);
-      } else if (fs.existsSync(nestedSkillFile)) {
-        skillFiles.push({ file: 'SKILL.md', dir: path.join(claudeSkillsDir, d, 'skills'), scope: 'claude-code', skillName: d });
-        seen.add(d);
+    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    for (const runtimeName of listRuntimes()) {
+      const runtime = resolveRuntime(runtimeName);
+      if (typeof runtime.getSkillRoots !== 'function') continue;
+      for (const root of runtime.getSkillRoots({ homeDir })) {
+        _collectNativeSkillsDir(root.dir, root.scope, seenFor(root.scope, root.projectName), skillFiles, {
+          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 { /* optional */ }
+  } catch { /* runtime registry optional in partial installs */ }
 
   // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json
   // Plugins use commands/*.md and/or skills/<name>/SKILL.md and/or skills/SKILL.md
@@ -772,60 +861,42 @@ function collectSkillFiles(config) {
       } catch { /* optional */ }
 
       // skills/<name>/SKILL.md or skills/SKILL.md (newer style)
-      const skillsDir = path.join(install.installPath, 'skills');
-      try {
-        const entries = fs.readdirSync(skillsDir);
-        for (const entry of entries) {
-          const entryPath = path.join(skillsDir, entry);
-          if (entry === 'SKILL.md') {
-            // Flat: skills/SKILL.md
-            const name = pluginName;
-            if (!seen.has(name)) {
-              skillFiles.push({ file: 'SKILL.md', dir: skillsDir, scope: 'plugin', skillName: name });
-              seen.add(name);
-            }
-          } else {
-            try {
-              if (!fs.statSync(entryPath).isDirectory()) continue;
-            } catch { continue; }
-            // Nested: skills/<name>/SKILL.md
-            const nestedSkill = path.join(entryPath, 'SKILL.md');
-            if (fs.existsSync(nestedSkill)) {
-              const name = pluginName + ':' + entry;
-              if (!seen.has(name)) {
-                skillFiles.push({ file: 'SKILL.md', dir: entryPath, scope: 'plugin', skillName: name });
-                seen.add(name);
-              }
-            }
-          }
-        }
-      } catch { /* optional */ }
+      _collectPluginSkillsDir(path.join(install.installPath, 'skills'), pluginName, 'plugin', seen, skillFiles);
     }
   } catch { /* optional */ }
 
-  // 2. Project-specific skills: <project>/.claude/skills/<name>.md or <name>/SKILL.md
-  for (const project of getProjects(config)) {
-    const projectSkillsDir = path.resolve(project.localPath, '.claude', 'skills');
-    try {
-      const entries = fs.readdirSync(projectSkillsDir);
-      for (const entry of entries) {
-        if (entry === 'README.md') continue;
-        const entryPath = path.join(projectSkillsDir, entry);
-        const stat = fs.statSync(entryPath);
-        if (stat.isDirectory()) {
-          const skillFile = path.join(entryPath, 'SKILL.md');
-          if (fs.existsSync(skillFile)) {
-            skillFiles.push({ file: 'SKILL.md', dir: entryPath, scope: 'project', projectName: project.name, skillName: entry });
-          }
-        } else if (entry.endsWith('.md')) {
-          skillFiles.push({ file: entry, dir: projectSkillsDir, scope: 'project', projectName: project.name });
-        }
+  // 1c. Copilot installed plugin skills:
+  //   ~/.copilot/installed-plugins/<source>/<plugin>/skills/<skill>/SKILL.md
+  // Separate dedup set so plugins installed in both engines surface in both tabs.
+  const copilotSeen = new Set();
+  try {
+    const sources = fs.readdirSync(path.join(homeDir, '.copilot', 'installed-plugins'), { withFileTypes: true });
+    for (const sourceDirent of sources) {
+      if (!sourceDirent.isDirectory()) continue;
+      const sourceDir = path.join(homeDir, '.copilot', 'installed-plugins', sourceDirent.name);
+      let plugins;
+      try { plugins = fs.readdirSync(sourceDir, { withFileTypes: true }); } catch { continue; }
+      for (const pluginDirent of plugins) {
+        if (!pluginDirent.isDirectory()) continue;
+        _collectPluginSkillsDir(path.join(sourceDir, pluginDirent.name, 'skills'), pluginDirent.name, 'copilot-plugin', copilotSeen, skillFiles);
       }
-    } catch { /* optional */ }
-  }
+    }
+  } catch { /* optional */ }
+
+  _skillsCache = skillFiles;
+  _skillsCacheTs = now;
+  _skillsCacheKey = cacheKey;
   return skillFiles;
 }
 
+const SKILL_SOURCE_BY_SCOPE = {
+  'claude-code': 'claude-code',
+  'copilot': 'copilot',
+  'agent-skill': 'agent-skill',
+  'plugin': 'plugin',
+  'copilot-plugin': 'copilot-plugin',
+};
+
 function getSkills(config) {
   const all = [];
   for (const { file: f, dir, scope, projectName, skillName } of collectSkillFiles(config)) {
@@ -835,9 +906,10 @@ function getSkills(config) {
       if (scope === 'project' && meta.project === 'any') meta.project = projectName;
       // Check if auto-generated by an agent
       const isAutoGenerated = content.includes('Auto-extracted') || content.includes('author:') || content.includes('createdBy:');
+      const source = SKILL_SOURCE_BY_SCOPE[scope] || (scope === 'project' ? 'project:' + projectName : 'minions');
       all.push({
         ...meta, file: f, dir: dir.replace(/\\/g, '/'),
-        source: scope === 'claude-code' ? 'claude-code' : scope === 'plugin' ? 'plugin' : scope === 'project' ? 'project:' + projectName : 'minions',
+        source,
         scope,
         autoGenerated: isAutoGenerated,
       });
@@ -847,8 +919,17 @@ function getSkills(config) {
 }
 
 function getSkillIndex(config) {
+  const now = Date.now();
+  config = config || getConfig();
+  const cacheKey = _skillsCacheKeyFor(config, os.homedir());
+  if (_skillIndexCache !== null && _skillIndexCacheKey === cacheKey && (now - _skillIndexCacheTs) < SKILLS_CACHE_TTL) return _skillIndexCache;
   try {
-    const skillFiles = collectSkillFiles(config);
+    const skillFiles = collectSkillFiles(config).sort((a, b) => {
+      const priority = { project: 0, plugin: 1, 'copilot-plugin': 1, copilot: 2, 'agent-skill': 2, 'claude-code': 2 };
+      return (priority[a.scope] ?? 9) - (priority[b.scope] ?? 9)
+        || String(a.projectName || '').localeCompare(String(b.projectName || ''))
+        || String(a.skillName || a.file || '').localeCompare(String(b.skillName || b.file || ''));
+    });
     if (skillFiles.length === 0) return '';
 
     let index = '## Available Minions Skills\n\n';
@@ -866,10 +947,113 @@ function getSkillIndex(config) {
       index += `**File:** \`${dir}/${f}\`\n`;
       index += `Read the full skill file before following the steps.\n\n`;
     }
+    _skillIndexCache = index;
+    _skillIndexCacheTs = now;
+    _skillIndexCacheKey = cacheKey;
     return index;
   } catch { return ''; }
 }
 
+// ── Claude/Copilot command docs ──────────────────────────────────────────────
+
+function _collectMarkdownFilesRecursive(rootDir, maxFiles = 100) {
+  const found = [];
+  function walk(dir, relPrefix = '') {
+    if (found.length >= maxFiles) return;
+    let entries;
+    try { entries = fs.readdirSync(dir); } catch { return; }
+    for (const entry of entries) {
+      if (found.length >= maxFiles) return;
+      if (entry === 'README.md') continue;
+      const full = path.join(dir, entry);
+      let stat;
+      try { stat = fs.statSync(full); } catch { continue; }
+      if (stat.isDirectory()) {
+        walk(full, path.join(relPrefix, entry));
+      } else if (entry.endsWith('.md')) {
+        found.push({ file: entry, dir, rel: path.join(relPrefix, entry).replace(/\\/g, '/') });
+      }
+    }
+  }
+  walk(rootDir);
+  return found;
+}
+
+function collectCommandFiles(config) {
+  config = config || getConfig();
+  const commandFiles = [];
+  const seen = new Set();
+  const homeDir = os.homedir();
+
+  function addCommandDir(rootDir, scope, extra = {}) {
+    const root = path.resolve(rootDir);
+    for (const cmd of _collectMarkdownFilesRecursive(root)) {
+      const key = `${scope}:${extra.projectName || ''}:${root}:${cmd.rel}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const commandName = cmd.rel.replace(/\.md$/, '').replace(/\\/g, '/');
+      commandFiles.push({ ...cmd, root, scope, commandName, ...extra });
+    }
+  }
+
+  addCommandDir(path.join(homeDir, '.claude', 'commands'), 'claude-code');
+
+  try {
+    const pluginsFile = path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json');
+    const registry = JSON.parse(safeRead(pluginsFile) || '{}');
+    for (const [pluginKey, installs] of Object.entries(registry.plugins || {})) {
+      if (!Array.isArray(installs) || installs.length === 0) continue;
+      const install = installs[0];
+      if (!install.installPath) continue;
+      const pluginName = pluginKey.split('@')[0];
+      addCommandDir(path.join(install.installPath, 'commands'), 'plugin', { pluginName });
+    }
+  } catch { /* optional */ }
+
+  for (const project of getProjects(config)) {
+    if (!project.localPath) continue;
+    addCommandDir(path.resolve(project.localPath, '.claude', 'commands'), 'project', { projectName: project.name });
+  }
+
+  return commandFiles;
+}
+
+function _commandTitle(content, fallback) {
+  const description = content.match(/^description:\s*["']?(.+?)["']?\s*$/m);
+  if (description) return description[1].trim();
+  const heading = content.match(/^#\s+(.+)/m);
+  if (heading) return heading[1].trim();
+  return fallback;
+}
+
+function getCommandIndex(config) {
+  try {
+    const commandFiles = collectCommandFiles(config).sort((a, b) => {
+      const priority = { project: 0, plugin: 1, 'claude-code': 2 };
+      return (priority[a.scope] ?? 9) - (priority[b.scope] ?? 9)
+        || String(a.projectName || '').localeCompare(String(b.projectName || ''))
+        || String(a.commandName || '').localeCompare(String(b.commandName || ''));
+    });
+    if (commandFiles.length === 0) return '';
+
+    let index = '## Available User Commands\n\n';
+    index += 'Claude/Copilot command markdown discovered from user, plugin, and project command packs. Read the file and adapt its workflow when it matches the task; do not assume slash-command invocation works inside non-interactive agent runs.\n\n';
+
+    for (const { file: f, dir, scope, projectName, pluginName, commandName } of commandFiles) {
+      const content = safeRead(path.join(dir, f)) || '';
+      const title = _commandTitle(content, commandName);
+      const label = scope === 'project'
+        ? `project:${projectName || 'unknown'}`
+        : scope === 'plugin'
+          ? `plugin:${pluginName || 'unknown'}`
+          : 'claude-code';
+      index += `- \`/${commandName}\` (${label}) — ${title}\n`;
+      index += `  File: \`${dir.replace(/\\/g, '/')}/${f}\`\n`;
+    }
+    return index + '\n';
+  } catch { return ''; }
+}
+
 // ── Knowledge Base ──────────────────────────────────────────────────────────
 
 let _kbCache = null;
@@ -1370,7 +1554,10 @@ module.exports = {
   getPrs, getPullRequests,
 
   // Skills
-  collectSkillFiles, getSkills, getSkillIndex,
+  collectSkillFiles, getSkills, getSkillIndex, invalidateSkillsCache,
+
+  // Commands
+  collectCommandFiles, getCommandIndex,
 
   // Knowledge base
   getKnowledgeBaseEntries, getKnowledgeBaseIndex,

package/engine/runtimes/claude.js

@@ -322,6 +322,29 @@ function buildPrompt(promptText, /* sysPromptText */ _sys) {
   return String(promptText == null ? '' : promptText);
 }
 
+function getUserAssetDirs({ homeDir = os.homedir() } = {}) {
+  return [path.join(homeDir, '.claude')];
+}
+
+function getSkillRoots({ homeDir = os.homedir(), project = null } = {}) {
+  const roots = [{ dir: path.join(homeDir, '.claude', 'skills'), scope: 'claude-code' }];
+  if (project?.localPath) {
+    roots.push({
+      dir: path.resolve(project.localPath, '.claude', 'skills'),
+      scope: 'project',
+      projectName: project.name,
+    });
+  }
+  return roots;
+}
+
+function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
+  return {
+    personal: path.join(homeDir, '.claude', 'skills'),
+    project: project?.localPath ? path.resolve(project.localPath, '.claude', 'skills') : null,
+  };
+}
+
 // ── Output Parsing ───────────────────────────────────────────────────────────
 
 /**
@@ -612,6 +635,32 @@ const capabilities = {
 // (fatal error message). Multi-line so all platforms see actionable guidance.
 const INSTALL_HINT = 'install from https://claude.ai/download or: npm install -g @anthropic-ai/claude-code';
 
+function getUserAssetDirs({ homeDir = os.homedir() } = {}) {
+  return [path.join(homeDir, '.claude')];
+}
+
+function getSkillRoots({ homeDir = os.homedir(), project = null } = {}) {
+  const roots = [
+    { dir: path.join(homeDir, '.claude', 'skills'), scope: 'claude-code' },
+  ];
+  if (project?.localPath) {
+    roots.push({
+      dir: path.join(project.localPath, '.claude', 'skills'),
+      scope: 'project',
+      projectName: project.name || path.basename(project.localPath),
+    });
+  }
+  return roots;
+}
+
+function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
+  const targets = { personal: path.join(homeDir, '.claude', 'skills') };
+  if (project?.localPath) {
+    targets.project = path.join(project.localPath, '.claude', 'skills');
+  }
+  return targets;
+}
+
 module.exports = {
   name: 'claude',
   capabilities,
@@ -624,6 +673,9 @@ module.exports = {
   buildSpawnFlags,
   buildArgs,
   buildPrompt,
+  getUserAssetDirs,
+  getSkillRoots,
+  getSkillWriteTargets,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,

package/engine/runtimes/copilot.js

@@ -29,6 +29,7 @@
 
 const fs = require('fs');
 const https = require('https');
+const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
 const { FAILURE_CLASS, safeWrite, ts } = require('../shared');
@@ -348,6 +349,41 @@ function buildPrompt(promptText, sysPromptText, opts = {}) {
   return `<system>\n${String(sysPromptText)}\n</system>\n\n${user}`;
 }
 
+function getUserAssetDirs({ homeDir = os.homedir() } = {}) {
+  return [
+    path.join(homeDir, '.copilot'),
+    path.join(homeDir, '.agents'),
+  ];
+}
+
+function getSkillRoots({ homeDir = os.homedir(), project = null } = {}) {
+  const roots = [
+    { dir: path.join(homeDir, '.copilot', 'skills'), scope: 'copilot' },
+    { dir: path.join(homeDir, '.agents', 'skills'), scope: 'agent-skill' },
+  ];
+  if (project?.localPath) {
+    for (const rel of [
+      ['.github', 'skills'],
+      ['.claude', 'skills'],
+      ['.agents', 'skills'],
+    ]) {
+      roots.push({
+        dir: path.resolve(project.localPath, ...rel),
+        scope: 'project',
+        projectName: project.name,
+      });
+    }
+  }
+  return roots;
+}
+
+function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
+  return {
+    personal: path.join(homeDir, '.copilot', 'skills'),
+    project: project?.localPath ? path.resolve(project.localPath, '.github', 'skills') : null,
+  };
+}
+
 // ── Output Parsing ──────────────────────────────────────────────────────────
 //
 // Whitelist of event types observed during the spike (docs/copilot-cli-schema.md
@@ -754,6 +790,36 @@ const capabilities = {
 //   - Direct:    download from https://github.com/github/copilot-cli/releases
 const INSTALL_HINT = 'install via WinGet (winget install --id GitHub.cli && gh extension install github/gh-copilot), Homebrew (brew install gh && gh extension install github/gh-copilot), or download standalone copilot from https://github.com/github/copilot-cli/releases';
 
+function getUserAssetDirs({ homeDir = os.homedir() } = {}) {
+  return [
+    path.join(homeDir, '.copilot'),
+    path.join(homeDir, '.agents'),
+  ];
+}
+
+function getSkillRoots({ homeDir = os.homedir(), project = null } = {}) {
+  const roots = [
+    { dir: path.join(homeDir, '.copilot', 'skills'), scope: 'copilot' },
+    { dir: path.join(homeDir, '.agents', 'skills'), scope: 'agent-skill' },
+  ];
+  if (project?.localPath) {
+    const projectName = project.name || path.basename(project.localPath);
+    roots.push(
+      { dir: path.join(project.localPath, '.github', 'skills'), scope: 'project', projectName },
+      { dir: path.join(project.localPath, '.agents', 'skills'), scope: 'project', projectName },
+    );
+  }
+  return roots;
+}
+
+function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
+  const targets = { personal: path.join(homeDir, '.copilot', 'skills') };
+  if (project?.localPath) {
+    targets.project = path.join(project.localPath, '.github', 'skills');
+  }
+  return targets;
+}
+
 module.exports = {
   name: 'copilot',
   capabilities,
@@ -767,6 +833,9 @@ module.exports = {
   buildSpawnFlags,
   buildArgs,
   buildPrompt,
+  getUserAssetDirs,
+  getSkillRoots,
+  getSkillWriteTargets,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,

package/engine/spawn-agent.js

@@ -174,15 +174,18 @@ function main() {
     opts.sysPromptFile = sysTmpPath;
   }
 
-  // Skill discovery dirs — agents run with CWD set to an external repo
-  // worktree, so skills in the minions repo and the user's global ~/.claude
-  // dir are otherwise invisible. The adapter decides how to surface them
-  // (Claude → `--add-dir <path>`; Copilot → ignored).
+  // User asset discovery dirs — agents run with CWD set to an external repo
+  // worktree, so the adapter supplies any runtime-native global asset roots
+  // that should be visible from that cwd.
   const minionsDir = path.resolve(__dirname, '..');
-  const userClaudeDir = path.join(os.homedir(), '.claude');
+  const runtimeAssetDirs = typeof runtime.getUserAssetDirs === 'function'
+    ? runtime.getUserAssetDirs({ homeDir: os.homedir() })
+    : [];
   const addDirs = [minionsDir];
-  if (fs.existsSync(userClaudeDir) && path.resolve(userClaudeDir) !== path.resolve(minionsDir)) {
-    addDirs.push(userClaudeDir);
+  for (const userAssetDir of runtimeAssetDirs) {
+    if (fs.existsSync(userAssetDir) && path.resolve(userAssetDir) !== path.resolve(minionsDir)) {
+      addDirs.push(userAssetDir);
+    }
   }
 
   let resolved;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1681",
+  "version": "0.1.1682",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"