@yemi33/minions 0.1.2077 → 0.1.2079

package/dashboard/js/refresh.js

@@ -511,8 +511,17 @@ let _lastStatusOkAt = Date.now();
 let _consecutiveStatusFails = 0;
 let _unreachableSince = 0; // 0 = currently reachable
 let _unreachableAgeTimer = null;
-const _UNREACHABLE_FAIL_THRESHOLD = 2;
-const _UNREACHABLE_AGE_MS = 12000;
+// 3 + 20s (was 2 + 12s) — the prior thresholds tripped a banner on a single
+// safeFetch abort (timeout 15s in state.js) because the OR'd age side was
+// already satisfied. With safeFetch=15s, the age budget needs >15s to avoid
+// the trip-on-first-slow-response footgun. 3 consecutive fails ≈ 12s of real
+// outage at the 4s poll cadence, which still surfaces the banner promptly
+// during a real dashboard crash but tolerates one slow rebuild + retry.
+const _UNREACHABLE_FAIL_THRESHOLD = 3;
+const _UNREACHABLE_AGE_MS = 20000;
+// Once the banner is up we throttle polls (exponential, capped at 30s) to
+// avoid hammering a struggling dashboard / network. Reset on recovery.
+let _nextPollAllowedAt = 0;
 
 function _formatAge(ms) {
   if (ms < 1000) return 'just now';
@@ -595,10 +604,26 @@ window._resetDashboardUnreachableForTest = function() {
   _lastStatusOkAt = Date.now();
   _consecutiveStatusFails = 0;
   _unreachableSince = 0;
+  _nextPollAllowedAt = 0;
   if (_unreachableAgeTimer) { clearInterval(_unreachableAgeTimer); _unreachableAgeTimer = null; }
   delete window._dashboardUnreachable;
 };
 
+// Visibility wake-up: Chromium throttles setInterval on hidden tabs to ~1/min,
+// so _lastStatusOkAt can drift far past the age threshold while the tab is
+// backgrounded. When the user refocuses, state.js fires refresh() (line 206)
+// — without this reset the age side of the OR is already satisfied and a
+// single transient post-wake failure (DNS not yet up after suspend, mid-
+// restart server) trips the banner before any real evidence of trouble.
+// Reset BEFORE state.js calls refresh() — listener order is fine because
+// both fire on the same event; this listener registered first runs first.
+document.addEventListener('visibilitychange', function() {
+  if (document.visibilityState === 'visible' && !_unreachableSince) {
+    _lastStatusOkAt = Date.now();
+    _consecutiveStatusFails = 0;
+  }
+});
+
 // ── Refresh diagnostics (W-mphejzx100081972) ─────────────────────────────
 // Ring buffer capturing the last 50 /api/status poll cycles so a user
 // reporting "the dashboard didn't auto-update when X changed" can paste
@@ -649,6 +674,11 @@ document.addEventListener('visibilitychange', function() {
 
 async function refresh() {
   if (_refreshInFlight) return;
+  // Backoff gate — only active while the unreachable banner is up. Skips
+  // setInterval ticks until _nextPollAllowedAt is reached so a downed
+  // dashboard isn't hammered at the steady 4s cadence (which produces
+  // console-spam and adds load to whatever's wedged).
+  if (_nextPollAllowedAt && Date.now() < _nextPollAllowedAt) return;
   _refreshInFlight = true;
   const _diagOn = _isRefreshDiagOn();
   const _t0 = _diagOn ? Date.now() : 0;
@@ -730,6 +760,7 @@ async function refresh() {
     // instead of just dismissing the banner.
     _lastStatusOkAt = Date.now();
     _consecutiveStatusFails = 0;
+    _nextPollAllowedAt = 0;
     if (_unreachableSince) _markDashboardReachable();
     const _renderStart = _diagOn ? Date.now() : 0;
     let _diagChanges = null;
@@ -762,6 +793,14 @@ async function refresh() {
     if (_consecutiveStatusFails >= _UNREACHABLE_FAIL_THRESHOLD || ageMs > _UNREACHABLE_AGE_MS) {
       _markDashboardUnreachable(e);
     }
+    // Backoff: once we've tripped the banner, throttle subsequent polls
+    // (4s → 8s → 16s → 30s cap). Reset to 0 in the success path below so
+    // recovery snaps back to the steady 4s cadence on the next tick.
+    if (_unreachableSince) {
+      const failsSinceTrip = Math.max(1, _consecutiveStatusFails - _UNREACHABLE_FAIL_THRESHOLD + 1);
+      const backoffMs = Math.min(30000, 4000 * Math.pow(2, failsSinceTrip - 1));
+      _nextPollAllowedAt = Date.now() + backoffMs;
+    }
   }
   finally {
     _refreshInFlight = false;

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.2077",
+  "version": "0.1.2079",
   "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.
+
+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.