@yemi33/minions 0.1.1007 → 0.1.1009

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 
-## 0.1.1007 (2026-04-16)
+## 0.1.1009 (2026-04-16)
+
+### Other
+- chore: trigger publish workflow test
+
+## 0.1.1008 (2026-04-16)
 
 ### Features
 - fix duplicate PR creation + cancel stale review dispatches on PR close (#1137)
@@ -25,6 +30,8 @@
 - implement dashboard loop/watch management panel
 
 ### Fixes
+-  harden audited state transitions
+- scrub stale temp agent IDs from metrics.json (#1129)
 -  harden repo-scoped PR identity handling
 -  only gate reviews/fixes when no free agent slots remain
 -  extend auto-link fallback to ADO projects
@@ -43,8 +50,6 @@
 -  build fix sets fixDispatched to block same-tick conflict fix
 -  ENGINE_DEFAULTS undefined in tick + playbook empty-var false positives
 -  defer review setCooldown to post-gating in discoverWork
--  move review verdict check before updateWorkItemStatus(DONE)
--  address review feedback — move writeToInbox outside lock, add absolute condition auto-expire
 
 ### Other
 - refactor: migrate PR links to array format and consolidate shared helpers

package/dashboard/js/render-kb.js

@@ -27,6 +27,19 @@ async function refreshKnowledgeBase() {
   } catch (e) { console.error('kb refresh:', e.message); }
 }
 
+function kbNewestFirst(a, b) {
+  return (b.sortTs || 0) - (a.sortTs || 0) ||
+    (b.date || '').localeCompare(a.date || '') ||
+    (a.title || '').localeCompare(b.title || '');
+}
+
+function kbPinnedNewestFirst(a, b) {
+  const aPinned = isPinned(kbPinKey(a.category, a.file));
+  const bPinned = isPinned(kbPinKey(b.category, b.file));
+  if (aPinned !== bPinned) return aPinned ? -1 : 1;
+  return kbNewestFirst(a, b);
+}
+
 function renderKnowledgeBase() {
   _syncPinsFromServer();
   const tabsEl = document.getElementById('kb-tabs');
@@ -74,18 +87,13 @@ function renderKnowledgeBase() {
   let items;
   if (_kbActiveTab === 'pinned') {
     items = allItems.filter(i => isPinned(kbPinKey(i.category, i.file)));
+    items.sort(kbNewestFirst);
   } else if (_kbActiveTab === 'all') {
     items = allItems.slice();
-    items.sort((a, b) => (b.date || '').localeCompare(a.date || ''));
+    items.sort(kbPinnedNewestFirst);
   } else {
     items = allItems.filter(i => i.category === _kbActiveTab);
-  }
-
-  // Stable sort — pinned items float to top (skip on pinned tab where all are pinned)
-  if (_kbActiveTab !== 'pinned') {
-    items.sort(function(a, b) {
-      return (isPinned(kbPinKey(a.category, a.file)) ? 0 : 1) - (isPinned(kbPinKey(b.category, b.file)) ? 0 : 1);
-    });
+    items.sort(kbPinnedNewestFirst);
   }
 
   if (items.length === 0) {

package/dashboard.js

@@ -720,6 +720,7 @@ async function executeCCActions(actions) {
           const kbDir = path.join(MINIONS_DIR, 'knowledge', category);
           if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
           shared.safeWrite(path.join(kbDir, slug + '.md'), `# ${action.title}\n\n${action.content || action.description || ''}`);
+          queries.invalidateKnowledgeBaseCache();
           results.push({ type: 'knowledge', ok: true });
           break;
         }
@@ -1874,13 +1875,18 @@ const server = http.createServer(async (req, res) => {
       if (!body.source || !body.itemId) return jsonReply(res, 400, { error: 'source and itemId required' });
       const planPath = resolvePlanPath(body.source);
       if (!fs.existsSync(planPath)) return jsonReply(res, 404, { error: 'plan file not found' });
-      const plan = safeJsonObj(planPath);
-      if (!plan) return jsonReply(res, 500, { error: 'failed to read plan file' });
-      const idx = (plan.missing_features || []).findIndex(f => f.id === body.itemId);
-      if (idx < 0) return jsonReply(res, 404, { error: 'item not found in plan' });
-
-      plan.missing_features.splice(idx, 1);
-      safeWrite(planPath, plan);
+      let removed = false;
+      mutateJsonFileLocked(planPath, (plan) => {
+        if (!plan || Array.isArray(plan) || typeof plan !== 'object') plan = { missing_features: [] };
+        const features = Array.isArray(plan.missing_features) ? plan.missing_features : [];
+        const idx = features.findIndex(f => f.id === body.itemId);
+        if (idx < 0) return plan;
+        features.splice(idx, 1);
+        plan.missing_features = features;
+        removed = true;
+        return plan;
+      }, { defaultValue: { missing_features: [] } });
+      if (!removed) return jsonReply(res, 404, { error: 'item not found in plan' });
 
       // Also remove any materialized work item for this plan item
       let cancelled = false;
@@ -2237,7 +2243,7 @@ const server = http.createServer(async (req, res) => {
     for (const cat of shared.KB_CATEGORIES) result[cat] = [];
     for (const e of entries) {
       if (!result[e.cat]) result[e.cat] = [];
-      result[e.cat].push({ file: e.file, category: e.cat, title: e.title, agent: e.agent, date: e.date, size: e.size, preview: e.preview });
+      result[e.cat].push({ file: e.file, category: e.cat, title: e.title, agent: e.agent, date: e.date, sortTs: e.sortTs, size: e.size, preview: e.preview });
     }
     const swept = safeJson(path.join(ENGINE_DIR, 'kb-swept.json'));
     if (swept) result.lastSwept = swept.timestamp;
@@ -2409,9 +2415,12 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
         if (!fs.existsSync(srcPath)) continue;
         if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
         try {
+          const srcStats = fs.statSync(srcPath);
           const content = safeRead(srcPath);
           const updated = content.replace(/^(category:\s*).+$/m, `$1${r.to}`);
-          safeWrite(path.join(destDir, entry.file), updated);
+          const destPath = path.join(destDir, entry.file);
+          safeWrite(destPath, updated);
+          fs.utimesSync(destPath, srcStats.atime, srcStats.mtime);
           safeUnlink(srcPath);
           reclassified++;
         } catch (e) { console.error('kb reclassify:', e.message); }
@@ -2431,6 +2440,7 @@ If nothing to do: { "duplicates": [], "reclassify": [], "remove": [] }`;
 
       const summary = `${merged} duplicates merged, ${removed} stale removed, ${reclassified} reclassified${pruned ? ', ' + pruned + ' old swept files pruned' : ''}`;
       safeWrite(path.join(ENGINE_DIR, 'kb-swept.json'), JSON.stringify({ timestamp: new Date().toISOString(), summary }));
+      queries.invalidateKnowledgeBaseCache();
       global._kbSweepLastResult = { ok: true, summary, plan };
       global._kbSweepLastCompletedAt = Date.now();
     } catch (e) {
@@ -3276,6 +3286,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
       const kbFile = path.join(kbDir, name);
       safeWrite(kbFile, kbContent);
+      queries.invalidateKnowledgeBaseCache();
 
       // Move inbox item to archive
       const archiveDir = path.join(MINIONS_DIR, 'notes', 'archive');
@@ -4679,6 +4690,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       const header = '# ' + title + '\n\n*Created by human teammate on ' + new Date().toISOString().slice(0, 10) + '*\n\n';
       safeWrite(filePath, header + content);
+      queries.invalidateKnowledgeBaseCache();
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, path: filePath });
     }},

package/engine/cleanup.js

@@ -9,7 +9,7 @@ const shared = require('./shared');
 const queries = require('./queries');
 
 const { exec, execSilent, log, ts, ENGINE_DEFAULTS } = shared;
-const { safeJson, safeWrite, safeReadDir, mutateWorkItems, getProjects, projectWorkItemsPath, projectPrPath,
+const { safeJson, safeWrite, safeReadDir, mutateWorkItems, mutateJsonFileLocked, getProjects, projectWorkItemsPath, projectPrPath,
   sanitizeBranch, KB_CATEGORIES } = shared;
 const { getDispatch, getAgentStatus } = queries;
 
@@ -667,6 +667,9 @@ function runCleanup(config, verbose = false) {
     }
   } catch { /* optional — file may not exist */ }
 
+  // 14. Scrub stale temp agent keys from metrics.json
+  try { scrubStaleMetrics(); } catch { /* best-effort cleanup */ }
+
   if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed > 0) {
     log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.pidFiles} PID files`);
   }
@@ -674,9 +677,27 @@ function runCleanup(config, verbose = false) {
   return cleaned;
 }
 
+// ─── Metrics Scrub ──────────────────────────────────────────────────────────
+
+/** Remove stale temp-*, agent1, and _test-* keys from metrics.json.
+ *  Mirrors the guard in lifecycle.js updateMetrics() — cleans up keys
+ *  that were written before that guard existed. */
+function scrubStaleMetrics() {
+  const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
+  if (!fs.existsSync(metricsPath)) return;
+  mutateJsonFileLocked(metricsPath, metrics => {
+    for (const key of Object.keys(metrics)) {
+      if (key.startsWith('temp-') || key === 'agent1' || key.startsWith('_test')) {
+        delete metrics[key];
+      }
+    }
+  });
+}
+
 // ─── Exports ─────────────────────────────────────────────────────────────────
 
 module.exports = {
   runCleanup,
+  scrubStaleMetrics,
   worktreeDirMatchesBranch,  // exported for testing
 };

package/engine/lifecycle.js

@@ -13,6 +13,7 @@ const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, ex
 const { trackEngineUsage } = require('./llm');
 const queries = require('./queries');
 const { isBranchActive } = require('./cooldown');
+const { worktreeDirMatchesBranch } = require('./cleanup');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
   MINIONS_DIR, ENGINE_DIR, PLANS_DIR, PRD_DIR, INBOX_DIR, AGENTS_DIR } = queries;
 
@@ -1065,8 +1066,10 @@ const PENDING_REBASES_PATH = path.join(ENGINE_DIR, 'pending-rebases.json');
 
 function queuePendingRebase(pr, project, mergedItemId) {
   mutateJsonFileLocked(PENDING_REBASES_PATH, (pending) => {
-    if (pending.some(e => e.prId === pr.id)) return; // already queued
+    const prDisplayId = shared.getPrDisplayId(pr);
+    if (pending.some(e => e.projectName === project.name && shared.getPrDisplayId(e.prId) === prDisplayId)) return pending; // already queued
     pending.push({ prId: pr.id, branch: pr.branch, projectName: project.name, mergedItemId, queuedAt: ts(), attempts: 0 });
+    return pending;
   }, { defaultValue: [] });
 }
 
@@ -1087,9 +1090,11 @@ async function processPendingRebases(config) {
     const project = shared.getProjects(config).find(p => p.name === entry.projectName);
     if (!project) continue;
 
-    const prs = safeJson(projectPrPath(project)) || [];
-    const pr = prs.find(p => p.id === entry.prId && p.status === PR_STATUS.ACTIVE);
+    const prs = getPrs(project);
+    const pr = shared.findPrRecord(prs, entry.prId, project);
+    if (pr && pr.id !== entry.prId) entry.prId = pr.id;
     if (!pr) continue; // PR closed/merged since queuing
+    if (pr.status !== PR_STATUS.ACTIVE) continue; // PR closed/merged since queuing
 
     const result = await rebaseBranchOntoMain(pr, project, config);
     if (!result.success) {
@@ -1120,12 +1125,11 @@ async function handlePostMerge(pr, project, config, newStatus) {
     const root = path.resolve(project.localPath);
     const wtRoot = path.resolve(root, config.engine?.worktreeRoot || '../worktrees');
     // Find worktrees matching this branch — dir format is {slug}-{branch}-{suffix}
-    const branchSlug = shared.sanitizeBranch(pr.branch).toLowerCase();
     try {
       const dirs = require('fs').readdirSync(wtRoot);
       for (const dir of dirs) {
         const dirLower = dir.toLowerCase();
-        if (dirLower.includes(branchSlug) || dir === pr.branch || dir === `bt-${prNum}`) {
+        if (worktreeDirMatchesBranch(dirLower, pr.branch) || dir === pr.branch || dir === `bt-${prNum}`) {
           const wtPath = path.join(wtRoot, dir);
           try {
             if (!require('fs').statSync(wtPath).isDirectory()) continue;
@@ -1802,7 +1806,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
         // Find the worktree directory for this dispatch's branch
         const branchSlug = shared.sanitizeBranch ? shared.sanitizeBranch(meta.branch) : meta.branch.replace(/[^a-zA-Z0-9._\-\/]/g, '-');
         const dirs = fs.readdirSync(worktreeRoot).filter(d => {
-          return d.includes(branchSlug) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
+          return worktreeDirMatchesBranch(d.toLowerCase(), meta.branch) && fs.statSync(path.join(worktreeRoot, d)).isDirectory();
         });
         // Only remove if no other active dispatch uses this branch
         const dispatch = getDispatch();

package/engine/pipeline.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
+const queries = require('./queries');
 const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, ENGINE_DEFAULTS } = shared;
 const http = require('http');
 const { parseCronExpr, shouldRunNow } = require('./scheduler');
@@ -144,6 +145,46 @@ function resolveStageConfig(stage, run) {
   return resolved;
 }
 
+function collectPipelinePrRefs(pipeline, run) {
+  const refs = [];
+  const seen = new Set();
+  function addPrRef(resource) {
+    if (!resource) return;
+    let type = '';
+    let id = '';
+    let url = '';
+    if (typeof resource === 'string') {
+      id = resource.trim();
+      url = /^https?:\/\//i.test(id) ? id : '';
+    } else if (typeof resource === 'object') {
+      type = String(resource.type || '').trim().toLowerCase();
+      id = String(resource.label || resource.id || '').trim();
+      url = String(resource.url || '').trim();
+    } else {
+      return;
+    }
+    if (type && type !== 'pr') return;
+    const refId = id || url;
+    if (!refId && !url) return;
+    const prNumber = shared.getPrNumber({ id: refId, url });
+    if (!type && prNumber == null) return;
+    const key = url || refId;
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    refs.push({ id: refId, url });
+  }
+  for (const res of (pipeline?.monitoredResources || [])) addPrRef(res);
+  for (const stage of (pipeline?.stages || [])) {
+    for (const res of (stage?.monitoredResources || [])) addPrRef(res);
+  }
+  if (run) {
+    for (const [, stageState] of Object.entries(run.stages || {})) {
+      for (const prRef of (stageState.artifacts?.prs || [])) addPrRef(prRef);
+    }
+  }
+  return refs;
+}
+
 // ── Condition Evaluation ─────────────────────────────────────────────────────
 
 /**
@@ -186,27 +227,12 @@ function evaluateCondition(condition, ctx) {
       return pipelineRuns.length >= threshold;
     }
     case 'allBuildsGreen': {
-      // True when all PRs in monitoredResources (or run artifacts) have buildStatus 'passing'
-      const projects = shared.getProjects(config);
-      const allPrs = projects.reduce((acc, p) => {
-        return acc.concat(safeJson(shared.projectPrPath(p)) || []);
-      }, []);
-
-      // Collect PR IDs to check: from monitoredResources (type: 'pr') or run artifact PRs
-      const prIds = new Set();
-      for (const res of (pipeline?.monitoredResources || [])) {
-        const r = typeof res === 'string' ? { label: res } : res;
-        if (r.type === 'pr' && r.label) prIds.add(r.label);
-      }
-      // Also check PRs from run artifacts
-      if (run) {
-        for (const [, s] of Object.entries(run.stages || {})) {
-          for (const prId of (s.artifacts?.prs || [])) prIds.add(prId);
-        }
-      }
-      if (prIds.size === 0) return false; // no PRs to check = can't confirm green
-      for (const prId of prIds) {
-        const pr = allPrs.find(p => p.id === prId);
+      // True when all PRs in monitoredResources (pipeline-level or stage-level) or run artifacts have buildStatus 'passing'
+      const allPrs = queries.getPullRequests(config);
+      const prRefs = collectPipelinePrRefs(pipeline, run);
+      if (prRefs.length === 0) return false; // no PRs to check = can't confirm green
+      for (const prRef of prRefs) {
+        const pr = shared.findPrRecord(allPrs, prRef);
         if (!pr || pr.buildStatus !== 'passing') return false;
       }
       return true;

package/engine/queries.js

@@ -630,6 +630,11 @@ let _kbCache = null;
 let _kbCacheTs = 0;
 const KB_CACHE_TTL = 30000; // 30s — KB changes infrequently
 
+function invalidateKnowledgeBaseCache() {
+  _kbCache = null;
+  _kbCacheTs = 0;
+}
+
 function getKnowledgeBaseEntries() {
   const now = Date.now();
   if (_kbCache && (now - _kbCacheTs) < KB_CACHE_TTL) return _kbCache;
@@ -639,23 +644,32 @@ function getKnowledgeBaseEntries() {
     const catDir = path.join(KNOWLEDGE_DIR, cat);
     const files = safeReadDir(catDir).filter(f => f.endsWith('.md'));
     for (const f of files) {
-      const content = safeRead(path.join(catDir, f)) || '';
+      const filePath = path.join(catDir, f);
+      const content = safeRead(filePath) || '';
       const titleMatch = content.match(/^#\s+(.+)/m);
       const title = titleMatch ? titleMatch[1].trim() : f.replace(/\.md$/, '');
       const agentMatch = f.match(/^\d{4}-\d{2}-\d{2}-(\w+)-/);
-      const dateMatch = f.match(/^(\d{4}-\d{2}-\d{2})/);
+      const dateMatch = f.match(/^(\d{4}-\d{2}-\d{2})/) || content.match(/^date:\s*(\d{4}-\d{2}-\d{2})$/m);
       const sourceMatch = content.match(/^source:\s*(.+)/m);
+      let sortTs = 0;
+      try { sortTs = fs.statSync(filePath).mtimeMs || 0; } catch {}
+      const displayDate = dateMatch ? dateMatch[1] : (sortTs ? new Date(sortTs).toISOString().slice(0, 10) : '');
       entries.push({
         cat, file: f, title,
         agent: agentMatch ? agentMatch[1] : '',
-        date: dateMatch ? dateMatch[1] : '',
+        date: displayDate,
+        sortTs,
         source: sourceMatch ? sourceMatch[1].trim() : '',
         preview: content.slice(0, 200),
         size: content.length,
       });
     }
   }
-  entries.sort((a, b) => (b.date || '').localeCompare(a.date || ''));
+  entries.sort((a, b) =>
+    (b.sortTs || 0) - (a.sortTs || 0) ||
+    (b.date || '').localeCompare(a.date || '') ||
+    a.title.localeCompare(b.title)
+  );
   _kbCache = entries;
   _kbCacheTs = now;
   return entries;
@@ -1092,6 +1106,7 @@ module.exports = {
   readHeadTail, // exported for testing
   detectInFlightTool, // exported for testing
   resetPrdInfoCache,
+  invalidateKnowledgeBaseCache,
 
   // Core state
   getConfig, getControl, getDispatch, getDispatchQueue, invalidateDispatchCache,

package/engine/teams.js

@@ -526,7 +526,7 @@ async function teamsNotifyPrEvent(pr, event, project, prFilePath) {
   if (!cfg.notifyEvents || !cfg.notifyEvents.includes(event)) return;
 
   // Dedup check — don't re-notify the same event
-  if (pr._teamsNotifiedEvents && pr._teamsNotifiedEvents.includes(event)) return;
+  if (!prFilePath && pr._teamsNotifiedEvents && pr._teamsNotifiedEvents.includes(event)) return;
 
   const card = cards.buildPrCard(pr, event, project);
 
@@ -535,24 +535,45 @@ async function teamsNotifyPrEvent(pr, event, project, prFilePath) {
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) return;
 
+  let claimedEvent = false;
+  let shouldPost = true;
   try {
-    await teamsPost(convKeys[0], card);
-    log('info', `Teams PR notification sent: ${event} for ${pr.id}`);
-
-    // Record dedup — update _teamsNotifiedEvents on PR via lock
     if (prFilePath) {
       mutateJsonFileLocked(prFilePath, (prs) => {
         if (!Array.isArray(prs)) return prs;
         const target = shared.findPrRecord(prs, pr);
-        if (target) {
-          if (!target._teamsNotifiedEvents) target._teamsNotifiedEvents = [];
-          if (!target._teamsNotifiedEvents.includes(event)) {
-            target._teamsNotifiedEvents.push(event);
-          }
+        if (!target) return prs;
+        if (!target._teamsNotifiedEvents) target._teamsNotifiedEvents = [];
+        if (target._teamsNotifiedEvents.includes(event)) {
+          shouldPost = false;
+          return prs;
         }
+        target._teamsNotifiedEvents.push(event);
+        claimedEvent = true;
+        return prs;
       }, { defaultValue: [] });
     }
+    if (!shouldPost) return;
+    await teamsPost(convKeys[0], card);
+    if (pr && typeof pr === 'object') {
+      if (!Array.isArray(pr._teamsNotifiedEvents)) pr._teamsNotifiedEvents = [];
+      if (!pr._teamsNotifiedEvents.includes(event)) pr._teamsNotifiedEvents.push(event);
+    }
+    log('info', `Teams PR notification sent: ${event} for ${pr.id}`);
   } catch (err) {
+    if (claimedEvent && prFilePath) {
+      try {
+        mutateJsonFileLocked(prFilePath, (prs) => {
+          if (!Array.isArray(prs)) return prs;
+          const target = shared.findPrRecord(prs, pr);
+          if (!target || !Array.isArray(target._teamsNotifiedEvents)) return prs;
+          target._teamsNotifiedEvents = target._teamsNotifiedEvents.filter(e => e !== event);
+          return prs;
+        }, { defaultValue: [] });
+      } catch (revertErr) {
+        log('warn', `Teams PR dedup revert failed for ${pr.id}: ${revertErr.message}`);
+      }
+    }
     log('warn', `Teams PR notification failed for ${pr.id}: ${err.message}`);
   }
 }

package/package.json

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