@yemi33/minions 0.1.2078 → 0.1.2080

package/dashboard/js/refresh.js

@@ -474,6 +474,13 @@ let _knownDashboardStartId = null;
 // dashboardBuildId is the md5 of the assembled HTML — bumps automatically on
 // hot-reload + on cold restart with any /dashboard/** change.
 let _knownDashboardBuildId = null;
+// Hard-reload trigger when the *engine* commit changes — `minions restart`
+// after a `git pull` swaps engine code but doesn't touch any
+// /dashboard/** asset, so `dashboardBuildId` stays the same and the
+// existing buildId reload above never fires. Without this, the stale
+// "Engine running v… — disk has v…" banner persists in already-open tabs
+// until the (hourly by default) /api/version repoll catches up.
+let _knownEngineRunningCommit = null;
 // /api/status ETag cache (W-mpehsyhv0017085a). The dashboard polls every 4 s
 // but the server-side cache only changes every 10–60 s. Sending If-None-Match
 // lets the server short-circuit ~60 %+ of polls into a 304 with no body —
@@ -755,6 +762,18 @@ async function refresh() {
       return;
     }
     if (buildId) _knownDashboardBuildId = buildId;
+    // Auto-reload when the engine's commit changed (engine code was updated
+    // and process restarted, e.g. via `minions restart` after `git pull`).
+    // dashboardBuildId only hashes HTML/JS/CSS assets, so engine-only code
+    // updates don't trigger that path — leaving stale "Engine running v… —
+    // disk has v…" banners until the hourly /api/version repoll.
+    const engineCommit = (data.version && data.version.runningCommit) || null;
+    if (engineCommit && _knownEngineRunningCommit && engineCommit !== _knownEngineRunningCommit) {
+      console.log('Engine code changed — reloading page');
+      location.reload();
+      return;
+    }
+    if (engineCommit) _knownEngineRunningCommit = engineCommit;
     // Successful poll — clear unreachable state. Placed AFTER the reload
     // guards above so a dashboard restart still triggers location.reload()
     // instead of just dismissing the banner.

package/dashboard.js

@@ -2810,9 +2810,15 @@ function _ccTurnEntryToActionType(kind) {
   }
 }
 
-// Hash the system prompt so we can detect changes and invalidate stale sessions
-const _ccPromptHash = require('crypto').createHash('md5').update(CC_SYSTEM_PROMPT_RAW).digest('hex').slice(0, 8);
-const _docChatPromptHash = require('crypto').createHash('md5').update(DOC_CHAT_SYSTEM_PROMPT_RAW).digest('hex').slice(0, 8);
+// Hash the system prompt so we can detect changes and invalidate stale sessions.
+// Hashing the RENDERED prompt (not the raw template) means changes to the
+// substituted content — most importantly the dynamic {{available_skills}}
+// registry built from ~/.copilot/skills/ + installed-plugins — also invalidate
+// pooled sessions on dashboard restart. Without this, installing or removing
+// a skill would leave warm sessions glued to the old registry until they aged
+// out naturally.
+const _ccPromptHash = require('crypto').createHash('md5').update(CC_STATIC_SYSTEM_PROMPT).digest('hex').slice(0, 8);
+const _docChatPromptHash = require('crypto').createHash('md5').update(DOC_CHAT_SYSTEM_PROMPT).digest('hex').slice(0, 8);
 
 function _sessionExpired(lastActiveAt, ttlMs) {
   if (!lastActiveAt || !ttlMs) return false;

package/engine/shared.js

@@ -3455,6 +3455,106 @@ function describeCcProtectedPaths(liveRoot) {
   return `READ ONLY in the live checkout at \`${norm}\` — never write/edit: ${basenames}, ${globs}, ${prefixes}. This rule is path-scoped, not basename-scoped. Files with the same basename inside an isolated agent worktree (e.g. \`{worktreeRoot}/W-<id>/dashboard.js\`) are NOT protected — agents working in their own worktrees may edit any repository source the work item requires.`;
 }
 
+// Enumerate Copilot CLI skills from the conventional install layout so the CC
+// system prompt can mirror the vanilla runtime's <available_skills> registry.
+//
+// The CC system prompt fully replaces Copilot CLI's default — which means the
+// default's auto-injected <available_skills> block disappears, and the agent
+// has no idea what skills it has. It then falls back to grep/glob against
+// well-known paths (typically `.claude/skills/` because the underlying model
+// is Claude and that path dominates its training data). This helper rebuilds
+// the registry from the actual Copilot install dirs so the prompt can tell
+// the agent the truth.
+//
+// Locations scanned (matches Copilot CLI's discovery rules):
+//   - ~/.copilot/skills/<name>/SKILL.md         → location="user"
+//   - ~/.copilot/installed-plugins/<mkt>/<plugin>/skills/<name>/SKILL.md
+//                                                → location="plugin"
+//
+// Tolerates lowercase `skill.md` (Linux-style installs) and missing dirs
+// (returns an empty array rather than throwing). User-level entries shadow
+// plugin entries with the same name (mirrors Copilot CLI's user-wins rule).
+function listCopilotSkills(opts) {
+  const homeDir = (opts && typeof opts.homeDir === 'string') ? opts.homeDir : os.homedir();
+  const copilotRoot = path.join(homeDir, '.copilot');
+  const collected = [];
+
+  const readSkillDir = (dir, fallbackName, location) => {
+    let content;
+    try {
+      content = fs.readFileSync(path.join(dir, 'SKILL.md'), 'utf8');
+    } catch {
+      try { content = fs.readFileSync(path.join(dir, 'skill.md'), 'utf8'); }
+      catch { return null; }
+    }
+    const fm = parseSkillFrontmatter(content, fallbackName + '.md');
+    return {
+      name: fm.name || fallbackName,
+      description: fm.description || '',
+      location,
+    };
+  };
+
+  const safeReadDirents = (dir) => {
+    try { return fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return []; }
+  };
+
+  // User-level skills
+  for (const entry of safeReadDirents(path.join(copilotRoot, 'skills'))) {
+    if (!entry.isDirectory()) continue;
+    const skill = readSkillDir(path.join(copilotRoot, 'skills', entry.name), entry.name, 'user');
+    if (skill) collected.push(skill);
+  }
+
+  // Plugin-provided skills (two levels deep: marketplace/plugin)
+  const pluginsRoot = path.join(copilotRoot, 'installed-plugins');
+  for (const mkt of safeReadDirents(pluginsRoot)) {
+    if (!mkt.isDirectory()) continue;
+    for (const plugin of safeReadDirents(path.join(pluginsRoot, mkt.name))) {
+      if (!plugin.isDirectory()) continue;
+      const pluginSkillsDir = path.join(pluginsRoot, mkt.name, plugin.name, 'skills');
+      for (const entry of safeReadDirents(pluginSkillsDir)) {
+        if (!entry.isDirectory()) continue;
+        const skill = readSkillDir(path.join(pluginSkillsDir, entry.name), entry.name, 'plugin');
+        if (skill) collected.push(skill);
+      }
+    }
+  }
+
+  // De-dupe by name, user wins over plugin (matches Copilot CLI's precedence)
+  const seen = new Map();
+  for (const s of collected) {
+    const existing = seen.get(s.name);
+    if (!existing || (s.location === 'user' && existing.location !== 'user')) {
+      seen.set(s.name, s);
+    }
+  }
+  return Array.from(seen.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function _xmlEscapeForPrompt(s) {
+  return String(s == null ? '' : s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+// Render a list of skills as an <available_skills> XML block matching the
+// shape Copilot CLI's default system prompt injects. When `skills` is empty
+// we still emit the block (with a sentinel comment) so the agent learns the
+// path exists rather than silently inferring nothing's there.
+function buildAvailableSkillsBlock(skills) {
+  const list = Array.isArray(skills) ? skills : [];
+  if (list.length === 0) {
+    return '<available_skills>\n  <!-- No skills found in ~/.copilot/skills/ or ~/.copilot/installed-plugins/<marketplace>/<plugin>/skills/ -->\n</available_skills>';
+  }
+  const items = list.map(s =>
+    `<skill>\n  <name>${_xmlEscapeForPrompt(s.name)}</name>\n  <description>${_xmlEscapeForPrompt(s.description)}</description>\n  <location>${_xmlEscapeForPrompt(s.location)}</location>\n</skill>`
+  ).join('\n');
+  return `<available_skills>\n${items}\n</available_skills>`;
+}
+
 function renderCcSystemPrompt(raw, opts) {
   const liveRoot = (opts && typeof opts.liveRoot === 'string') ? opts.liveRoot : MINIONS_DIR;
   const turnId = (opts && typeof opts.turnId === 'string') ? opts.turnId : '';
@@ -3467,6 +3567,14 @@ function renderCcSystemPrompt(raw, opts) {
   if (out.includes('{{cc_protected_paths}}')) {
     out = out.replace(/\{\{cc_protected_paths\}\}/g, describeCcProtectedPaths(liveRoot));
   }
+  // Available-skills enumeration walks two directory trees and reads each
+  // SKILL.md's frontmatter — only do it when the template asks for it.
+  // Tests pass `opts.skillsHomeDir` to redirect the scan at a fixture dir.
+  if (out.includes('{{available_skills}}')) {
+    const skillsOpts = (opts && typeof opts.skillsHomeDir === 'string')
+      ? { homeDir: opts.skillsHomeDir } : undefined;
+    out = out.replace(/\{\{available_skills\}\}/g, buildAvailableSkillsBlock(listCopilotSkills(skillsOpts)));
+  }
   return out
     .replace(/\{\{cc_turn_id\}\}/g, turnId)
     .replace(/\{\{dashboard_port\}\}/g, dashboardPort);
@@ -5418,6 +5526,8 @@ module.exports = {
   isLiveCommandCenterPath,
   describeCcProtectedPaths,
   renderCcSystemPrompt,
+  listCopilotSkills,
+  buildAvailableSkillsBlock,
   _CC_PROTECTED_BASENAMES, // exported for testing
   _CC_PROTECTED_FILE_GLOBS, // exported for testing
   _CC_PROTECTED_PREFIXES,  // exported for testing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2078",
+  "version": "0.1.2080",
   "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"

package/prompts/cc-system.md

@@ -39,6 +39,19 @@ CAN modify: notes, plans, knowledge, work items, pull-requests.json, routing.md,
 ## Filesystem
 Minions state lives in `{{minions_dir}}/`. Key paths: `config.json` (config), `routing.md` (dispatch rules), `projects/{name}/work-items.json` & `pull-requests.json` (per-project), `agents/{id}/` (charters, output), `plans/` & `prd/` (plans), `knowledge/` (KB), `notes/inbox/` (inbox), `engine/dispatch.json` (queue), `playbooks/` (templates). Use tools to read specifics.
 
+## Your skills
+
+Your runtime is the **Copilot CLI**, not Claude Code. Your installed skills live in:
+
+- `~/.copilot/skills/<name>/SKILL.md` — user-level skills (yours)
+- `~/.copilot/installed-plugins/<marketplace>/<plugin>/skills/<name>/SKILL.md` — plugin-provided skills (also yours)
+
+To invoke a skill, call your `skill` tool with the skill name (the directory name). The skill body then guides the next steps. **Both user-level and plugin-level skills are invokable the same way** — the `<location>` tag in the registry is metadata, not a permission gate. If the registry below lists a skill, you can load it.
+
+When asked "what skills do you have", answer from the registry below — do NOT grep/glob `.claude/skills/`. Those belong to a different runtime (Claude Code) and are not available to you, even if the directory exists in cwd or `$HOME`.
+
+{{available_skills}}
+
 ## Role: Orchestrator
 You are primarily a dispatcher. Agents have full Claude Code + worktrees + MCP tools and are better suited for real work — but you are not hard-stopped from handling small requests yourself.