@yemi33/minions 0.1.1680 → 0.1.1682

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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
+-  plan completion lifecycle audit fixes (#1982)
+
 ## 0.1.1680 (2026-05-02)
 
 ### Other

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 || '';
 }
@@ -2309,12 +2319,14 @@ const server = http.createServer(async (req, res) => {
       // If archived, temporarily restore to active so checkPlanCompletion can find it
       const activePath = path.join(prdDir, body.file);
       if (fromArchive) {
-        const plan = safeJson(prdPath);
-        if (!plan) return jsonReply(res, 500, { error: 'Could not parse PRD file' });
-        plan.status = 'approved';
-        delete plan.completedAt;
-        delete plan.planStale;
-        safeWrite(activePath, plan);
+        const archivedPlan = safeJson(prdPath);
+        if (!archivedPlan) return jsonReply(res, 500, { error: 'Could not parse PRD file' });
+        mutateJsonFileLocked(activePath, () => {
+          archivedPlan.status = 'approved';
+          delete archivedPlan.completedAt;
+          delete archivedPlan.planStale;
+          return archivedPlan;
+        }, { defaultValue: archivedPlan });
       }
 
       const config = queries.getConfig();
@@ -2347,11 +2359,10 @@ const server = http.createServer(async (req, res) => {
       }
 
       // No existing verify — clear completion flag and trigger fresh creation
-      const planData = safeJson(activePath);
-      if (planData?._completionNotified) {
-        planData._completionNotified = false;
-        safeWrite(activePath, planData);
-      }
+      mutateJsonFileLocked(activePath, (planData) => {
+        if (planData?._completionNotified) planData._completionNotified = false;
+        return planData;
+      }, { defaultValue: {}, skipWriteIfUnchanged: true });
 
       const lifecycle = require('./engine/lifecycle');
       lifecycle.checkPlanCompletion({ item: { sourcePlan: body.file, id: 'manual' } }, config);
@@ -3572,15 +3583,18 @@ const server = http.createServer(async (req, res) => {
       const body = await readBody(req);
       if (!body.file) return jsonReply(res, 400, { error: 'file required' });
       const planPath = resolvePlanPath(body.file);
-      const plan = safeJsonObj(planPath);
-      const wasStale = !!plan.planStale;
-      plan.status = 'approved';
-      plan.approvedAt = new Date().toISOString();
-      plan.approvedBy = body.approvedBy || os.userInfo().username;
-      delete plan.pausedAt;
-      delete plan.planStale;
-      delete plan._completionNotified;
-      safeWrite(planPath, plan);
+      let wasStale = false;
+      const plan = mutateJsonFileLocked(planPath, (data) => {
+        if (!data || Array.isArray(data) || typeof data !== 'object') data = {};
+        wasStale = !!data.planStale;
+        data.status = 'approved';
+        data.approvedAt = new Date().toISOString();
+        data.approvedBy = body.approvedBy || os.userInfo().username;
+        delete data.pausedAt;
+        delete data.planStale;
+        delete data._completionNotified;
+        return data;
+      }, { defaultValue: {} });
 
       // Resume paused work items across all projects
       let resumed = 0;
@@ -3662,10 +3676,12 @@ const server = http.createServer(async (req, res) => {
       const body = await readBody(req);
       if (!body.file) return jsonReply(res, 400, { error: 'file required' });
       const planPath = resolvePlanPath(body.file);
-      const plan = safeJsonObj(planPath);
-      plan.status = 'paused';
-      plan.pausedAt = new Date().toISOString();
-      safeWrite(planPath, plan);
+      mutateJsonFileLocked(planPath, (plan) => {
+        if (!plan || Array.isArray(plan) || typeof plan !== 'object') plan = {};
+        plan.status = 'paused';
+        plan.pausedAt = new Date().toISOString();
+        return plan;
+      }, { defaultValue: {} });
 
       // Propagate pause to materialized work items across all projects:
       // kill any active agent process and reset non-completed items to paused.
@@ -3799,12 +3815,14 @@ const server = http.createServer(async (req, res) => {
       const body = await readBody(req);
       if (!body.file) return jsonReply(res, 400, { error: 'file required' });
       const planPath = resolvePlanPath(body.file);
-      const plan = safeJsonObj(planPath);
-      plan.status = 'rejected';
-      plan.rejectedAt = new Date().toISOString();
-      plan.rejectedBy = body.rejectedBy || os.userInfo().username;
-      if (body.reason) plan.rejectionReason = body.reason;
-      safeWrite(planPath, plan);
+      const plan = mutateJsonFileLocked(planPath, (data) => {
+        if (!data || Array.isArray(data) || typeof data !== 'object') data = {};
+        data.status = 'rejected';
+        data.rejectedAt = new Date().toISOString();
+        data.rejectedBy = body.rejectedBy || os.userInfo().username;
+        if (body.reason) data.rejectionReason = body.reason;
+        return data;
+      }, { defaultValue: {} });
 
       // Teams notification for plan rejection — non-blocking
       try { teams.teamsNotifyPlanEvent({ name: plan.plan_summary || body.file, file: body.file }, 'plan-rejected').catch(() => {}); } catch {}
@@ -3956,18 +3974,23 @@ const server = http.createServer(async (req, res) => {
 
       let archivedSource = null;
       let plan = {};
+      const archiveWarnings = [];
       if (isPrd) {
         try {
-          plan = safeJsonObj(archivePath) || {};
-          plan.status = 'archived';
-          plan.archivedAt = new Date().toISOString();
-          safeWrite(archivePath, plan);
+          plan = mutateJsonFileLocked(archivePath, (data) => {
+            if (!data || Array.isArray(data) || typeof data !== 'object') data = {};
+            data.status = 'archived';
+            data.archivedAt = new Date().toISOString();
+            return data;
+          }, { defaultValue: {} }) || {};
           // Without removing the .backup sidecar, safeJson would auto-restore the
           // pre-completion snapshot on engine restart, re-triggering plan completion
           // and spawning duplicate verify tasks (regression of #f28162b0).
-          const backupPath = planPath + '.backup';
-          try { fs.unlinkSync(backupPath); } catch {
-            try { fs.writeFileSync(backupPath, JSON.stringify({ status: 'archived' })); } catch { /* best-effort */ }
+          const backupCleanup = shared.neutralizeJsonBackupSidecar(planPath);
+          if (!backupCleanup.ok) {
+            const warning = `Archive backup cleanup failed for ${body.file}: unlink failed (${backupCleanup.unlinkError}); fallback neutralize failed (${backupCleanup.writeError})`;
+            archiveWarnings.push(warning);
+            console.warn(warning);
           }
           if (plan.source_plan) {
             const mdPath = path.join(PLANS_DIR, plan.source_plan);
@@ -4006,7 +4029,9 @@ const server = http.createServer(async (req, res) => {
       } catch (e) { console.error('plan worktree cleanup:', e.message); }
 
       invalidateStatusCache();
-      return jsonReply(res, 200, { ok: true, archived: body.file, archivedSource, cancelledItems });
+      const payload = { ok: true, archived: body.file, archivedSource, cancelledItems };
+      if (archiveWarnings.length > 0) payload.warnings = archiveWarnings;
+      return jsonReply(res, 200, payload);
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
@@ -4047,12 +4072,14 @@ const server = http.createServer(async (req, res) => {
       const body = await readBody(req);
       if (!body.file || !body.feedback) return jsonReply(res, 400, { error: 'file and feedback required' });
       const planPath = resolvePlanPath(body.file);
-      const plan = safeJsonObj(planPath);
-      plan.status = 'revision-requested';
-      plan.revision_feedback = body.feedback;
-      plan.revisionRequestedAt = new Date().toISOString();
-      plan.revisionRequestedBy = body.requestedBy || os.userInfo().username;
-      safeWrite(planPath, plan);
+      const plan = mutateJsonFileLocked(planPath, (data) => {
+        if (!data || Array.isArray(data) || typeof data !== 'object') data = {};
+        data.status = 'revision-requested';
+        data.revision_feedback = body.feedback;
+        data.revisionRequestedAt = new Date().toISOString();
+        data.revisionRequestedBy = body.requestedBy || os.userInfo().username;
+        return data;
+      }, { defaultValue: {} });
 
       // Create a work item to revise the plan
       const wiPath = path.join(MINIONS_DIR, 'work-items.json');
@@ -4478,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/docs/plan-lifecycle.md

@@ -6,8 +6,8 @@ How plans go from idea to verified, running code.
 
 ```
 /plan "feature description"
-  → agent writes plan JSON (plan-*.json)
-  → engine chains plan → PRD (plan-to-prd)
+  → agent writes plan markdown (plans/plan-*.md)
+  → human reviews and explicitly runs plan-to-prd
   → agent converts plan into structured PRD items with acceptance criteria
   → engine materializes PRD items as work items (PL-W001, PL-W002, ...)
   → engine dispatches work items respecting dependency order
@@ -15,6 +15,7 @@ How plans go from idea to verified, running code.
   → engine auto-reviews PRs, handles feedback loops
   → all items done → engine creates VERIFY task
   → verify agent builds everything, starts webapp, writes testing guide
+  → human archives the PRD/plan from the dashboard when ready
 ```
 
 ## Dependency Management
@@ -66,7 +67,7 @@ When all PRD items reach `done` or `failed` status, `checkPlanCompletion()` fire
 1. **Completion summary** written to `notes/inbox/` with results, timing, and PR list
 2. **Verification task** created (type `verify`, priority `high`) — see below
 3. **PR work item** created for shared-branch plans (to merge the feature branch)
-4. **Plan archived** to `plans/archive/`
+4. **PRD status** persisted as `completed` with `_completionNotified`; files stay active until manual archive
 
 ## Verification Task
 
@@ -109,6 +110,21 @@ git merge "origin/feat/PL-W005" --no-edit
 
 The verify agent and the user can then build and run from these paths.
 
+## Manual Archive Lifecycle
+
+Archiving is a deliberate dashboard action, not a post-verify side effect. When a PRD completes, `checkPlanCompletion()` writes the completion summary, persists `status: "completed"` plus `_completionNotified`, and creates the verify work item. The PRD remains in `prd/` and its source plan remains in `plans/` so humans can review the guide, inspect the final state, resume stale work, or reopen items before hiding the plan from active views.
+
+The verify agent does not call `archivePlan()`. After the testing guide and any follow-up PR work are satisfactory, use the dashboard archive action, which calls `POST /api/plans/archive` with the active PRD or plan filename.
+
+Manual archive behavior:
+
+1. For PRD JSON files, the dashboard moves `prd/<file>.json` to `prd/archive/<file>.json`, marks the archived JSON with `status: "archived"` and `archivedAt`, and removes or neutralizes the active `.backup` sidecar so `safeJson()` cannot restore a stale completed PRD on restart.
+2. If the PRD has `source_plan`, the matching `plans/<source>.md` is moved to `plans/archive/<source>.md`.
+3. Pending or queued work items linked to the archived PRD are cancelled with `_cancelledBy: "plan-archived"`; completed work items remain as history.
+4. Plan worktrees are cleaned up by the archive handler/lifecycle cleanup path.
+
+Use unarchive only when the archived PRD/plan should reappear in active views. Reopening completed work should happen before archive, or after unarchive, so the materializer can see the active PRD file.
+
 ## Human Feedback on PRs
 
 After PRs are created, humans can leave comments containing `@minions` to trigger fix tasks. If you're the only human commenting, any comment triggers a fix — no keyword needed. See `pollPrHumanComments()` in `engine/ado.js`.
@@ -130,11 +146,11 @@ After PRs are created, humans can leave comments containing `@minions` to trigge
 
 | File | Purpose |
 |------|---------|
-| `plans/*.json` | Active plan files with PRD items |
-| `plans/archive/` | Completed/archived plans |
+| `plans/*.md` | Source plans awaiting review or linked to active PRDs |
+| `prd/*.json` | Active PRDs with materializable items |
+| `plans/archive/`, `prd/archive/` | Manually archived plans and PRDs |
 | `playbooks/verify.md` | Verification task playbook |
 | `playbooks/implement.md` | Implementation playbook |
 | `playbooks/plan-to-prd.md` | Plan → PRD conversion playbook |
-| `engine/lifecycle.js` | `checkPlanCompletion`, `chainPlanToPrd` |
+| `engine/lifecycle.js` | `checkPlanCompletion`, completion hooks, PRD sync |
 | `engine.js` | `spawnAgent` (dependency merging), `resolveDependencyBranches` |
-

package/engine/copilot-models.json

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