@yemi33/minions 0.1.2278 → 0.1.2280

package/dashboard.js

@@ -588,10 +588,18 @@ let _prRefVerifierOverride = null;   // test seam
 
 // Evict stale entries when the cache exceeds _PR_REF_VERIFY_CACHE_MAX to prevent
 // unbounded growth. Called after every Map.set() in verifyLoosePrRefIsPr.
+// Two-pass strategy: (1) evict TTL-expired entries; (2) if still over cap,
+// evict the oldest entries (LRU) until the cache is back within bounds.
 function _evictPrRefVerifyCacheIfNeeded() {
   if (_prRefVerifyCache.size <= _PR_REF_VERIFY_CACHE_MAX) return;
+  // Pass 1: evict TTL-expired entries.
   const cutoff = Date.now() - _PR_REF_VERIFY_TTL_MS;
   for (const [k, v] of _prRefVerifyCache) if (v.at < cutoff) _prRefVerifyCache.delete(k);
+  // Pass 2: LRU fallback — evict oldest entries if still over cap (e.g. burst of fresh entries).
+  if (_prRefVerifyCache.size <= _PR_REF_VERIFY_CACHE_MAX) return;
+  const toEvict = _prRefVerifyCache.size - _PR_REF_VERIFY_CACHE_MAX;
+  const sorted = [..._prRefVerifyCache.entries()].sort((a, b) => a[1].at - b[1].at);
+  for (let i = 0; i < toEvict; i++) _prRefVerifyCache.delete(sorted[i][0]);
 }
 
 // Test seam (issue #246) — inject a fake verifier so handler tests can assert

package/engine/pipeline.js

@@ -1239,10 +1239,10 @@ async function discoverPipelineWork(config) {
 module.exports = {
   PIPELINES_DIR,
   getPipelines, getPipeline, savePipeline, deletePipeline,
-  getPipelineRuns, getActiveRun, startRun, updateRunStage, completeRun,
+  getPipelineRuns, getActiveRun, startRun, updateRunStage, upsertRunStage, completeRun,
   discoverPipelineWork,
   evaluateCondition, // exported for testing
-  executeTaskStage, executePlanStage, executeScheduleStage, executeApiStage, isStageComplete, resolveTemplate, // exported for testing
+  truncatePipelineContext, executeTaskStage, executePlanStage, executeScheduleStage, executeApiStage, executeMeetingStage, executeMergePrsStage, isStageComplete, resolveTemplate, // exported for testing
   _resolvePipelineProjects, // exported for testing
   _findMeetingsInRun, _findExistingPlanForMeeting, _findExistingPrdForPlan, // exported for testing
 };

package/engine/preflight.js

@@ -626,14 +626,18 @@ function doctor(minionsHome) {
     runtimeResults.push({ name: 'Engine', ok: 'warn', message: 'not started — run: minions start (see docs/engine-restart.md)' });
   }
 
-  // Check dashboard (try HTTP)
+  // Check dashboard (try HTTP). Read the actual bound port from the
+  // dashboard-port.json beacon so the probe works when the dashboard falls
+  // back to a non-default port after EADDRINUSE scanning.
   const http = require('http');
+  const beaconData = shared.readDashboardPortFile(minionsHome);
+  const dashPort = (beaconData && beaconData.port) || shared.DEFAULT_DASHBOARD_PORT;
   const dashCheck = new Promise(resolve => {
-    const req = http.get('http://localhost:7331/api/health', { timeout: 2000 }, res => {
-      resolve({ name: 'Dashboard', ok: true, message: 'running on http://localhost:7331' });
+    const req = http.get(`http://localhost:${dashPort}/api/health`, { timeout: 2000 }, res => {
+      resolve({ name: 'Dashboard', ok: true, message: `running on http://localhost:${dashPort}` });
     });
-    req.on('error', () => resolve({ name: 'Dashboard', ok: 'warn', message: 'not reachable on :7331 — run: minions dash (see docs/engine-restart.md)' }));
-    req.on('timeout', () => { req.destroy(); resolve({ name: 'Dashboard', ok: 'warn', message: 'not reachable on :7331 — run: minions dash (see docs/engine-restart.md)' }); });
+    req.on('error', () => resolve({ name: 'Dashboard', ok: 'warn', message: `not reachable on :${dashPort} — run: minions dash (see docs/engine-restart.md)` }));
+    req.on('timeout', () => { req.destroy(); resolve({ name: 'Dashboard', ok: 'warn', message: `not reachable on :${dashPort} — run: minions dash (see docs/engine-restart.md)` }); });
   });
 
   return dashCheck.then(async dashResult => {
@@ -649,9 +653,9 @@ function doctor(minionsHome) {
       runtimeResults.push({ name: 'Playbooks', ok: false, message: 'no playbooks found in playbooks/ — run: minions init --force (see docs/distribution.md)' });
     }
 
-    // Check port 7331 availability (only if dashboard isn't running)
+    // Check port availability (only if dashboard isn't running)
     if (dashResult.ok !== true) {
-      runtimeResults.push({ name: 'Port 7331', ok: 'warn', message: 'dashboard not running — port status unknown (see docs/engine-restart.md)' });
+      runtimeResults.push({ name: `Port ${dashPort}`, ok: 'warn', message: `dashboard not running — port status unknown (see docs/engine-restart.md)` });
     }
 
     // Self-check the out-of-process recovery net. A registered-but-broken

package/engine/restart-health.js

@@ -15,7 +15,7 @@ const shared = require('./shared');
 // the literal is only a fallback if shared somehow failed to load.
 const DEFAULT_RESTART_HEALTH_TIMEOUT_MS =
   (shared.ENGINE_DEFAULTS && shared.ENGINE_DEFAULTS.restartHealthTimeoutMs) || 60000;
-const DEFAULT_RESTART_HEALTH_INTERVAL_MS = 250;
+const DEFAULT_RESTART_HEALTH_INTERVAL_MS = 100;
 // Consecutive dead-PID reads tolerated before fail-fast. A small guard avoids
 // a single flaky tasklist / kill(0) false-negative aborting a healthy boot.
 const DEFAULT_DEAD_POLLS_BEFORE_FAST_FAIL = 2;
@@ -45,7 +45,7 @@ function isProcessAlive(pid) {
       const out = execSync(`tasklist /FI "PID eq ${n}" /NH`, {
         encoding: 'utf8',
         windowsHide: true,
-        timeout: 3000,
+        timeout: 1000,
       });
       return new RegExp(`\\b${n}\\b`).test(out) && out.toLowerCase().includes('node');
     }
@@ -61,8 +61,8 @@ function isPortListening(port) {
   if (!Number.isInteger(n) || n <= 0) return false;
   try {
     if (process.platform === 'win32') {
-      const out = execSync(`netstat -ano -p TCP`, {
-        encoding: 'utf8', windowsHide: true, timeout: 3000, maxBuffer: 4 * 1024 * 1024,
+      const out = execSync(`netstat -ano | findstr ":${n} "`, {
+        encoding: 'utf8', windowsHide: true, timeout: 1000, maxBuffer: 64 * 1024, shell: true,
       });
       const re = new RegExp(`\\s127\\.0\\.0\\.1:${n}\\s+\\S+\\s+LISTENING`, 'i');
       const re6 = new RegExp(`\\s\\[::1?\\]:${n}\\s+\\S+\\s+LISTENING`, 'i');
@@ -70,12 +70,12 @@ function isPortListening(port) {
     }
     try {
       const out = execSync(`lsof -nP -iTCP:${n} -sTCP:LISTEN`, {
-        encoding: 'utf8', timeout: 3000,
+        encoding: 'utf8', timeout: 1000,
       });
       if (/\bLISTEN\b/i.test(out)) return true;
     } catch {}
     const out = execSync(`ss -ltn 'sport = :${n}' 2>/dev/null || netstat -ltn 2>/dev/null || netstat -an -p tcp 2>/dev/null`, {
-      encoding: 'utf8', timeout: 3000, shell: true,
+      encoding: 'utf8', timeout: 1000, shell: true,
     });
     return new RegExp(`(?:[:.])${n}\\b[^\\n]*\\b(?:LISTEN|LISTENING)\\b`, 'i').test(out);
   } catch { return false; }
@@ -152,7 +152,6 @@ async function checkRestartHealth(options = {}) {
     dashboardKind = 'process';
     const dpid = normalizePid(dashboardPid);
     const dashAlive = dpid ? isAlive(dpid) : false;
-    const portOpen = portCheck(dashboardPort);
     // Ownership gate (opt-in via requireBeaconOwner). "PID alive + port
     // listening" is NOT sufficient: a stale pre-restart dashboard still holding
     // the port satisfies the listening probe, so the verifier used to report
@@ -174,6 +173,10 @@ async function checkRestartHealth(options = {}) {
       beaconPid = beacon && normalizePid(beacon.pid);
       beaconOwned = !!(beacon && beaconPid === dpid && Number(beacon.port) === Number(dashboardPort));
     }
+    // If the beacon already confirms this PID owns the port, skip the expensive
+    // netstat — the dashboard writes dashboard-port.json in its listen() callback,
+    // so beacon.pid === dpid IS the port-bind signal.
+    const portOpen = (options.requireBeaconOwner && beaconOwned) ? true : portCheck(dashboardPort);
     dashboardOk = !!(dashAlive && portOpen && beaconOwned);
     dashboardDetail = `pid=${dpid || 'none'} alive=${dashAlive ? 'yes' : 'no'} port=${dashboardPort} listening=${portOpen ? 'yes' : 'no'}`
       + (options.requireBeaconOwner ? ` beaconPid=${beaconPid || 'none'} owned=${beaconOwned ? 'yes' : 'no'}` : '');

package/engine/shared.js

@@ -975,6 +975,19 @@ function _routeJsonReadToSql(p) {
  * reads (cooldowns, archived PRDs, ephemeral session state) where reviving a
  * stale `.backup` is actively harmful. See its JSDoc for selection guidance.
  */
+
+// PL-prd-no-backup (W-mqub65ez0004b3bd) — archived PRDs under prd/archive/ are
+// permanently removed terminal artifacts. They must NOT auto-restore from a
+// stale `.backup` sidecar (W-mouptdh1000h9f39: archived PRD came back and
+// re-dispatched work). Intentionally NARROW to prd/archive/ only:
+//   - prd/archive/*.json → no backup write + no safeJson restore
+//   - prd/*.json (root-level canonical)  → normal backup/restore lifecycle
+//     preserved so concurrent-sweep loss is recoverable (prd-rename-race.test.js).
+const _NO_BACKUP_JSON_RE = /(?:^|[\\/])prd[\\/]archive[\\/][^\\/]+\.json$/i;
+function _isNoBackupJsonPath(p) {
+  return typeof p === 'string' && _NO_BACKUP_JSON_RE.test(p);
+}
+
 function safeJson(p) {
   // Internal opt-out (positional second arg from mutateJsonFileLocked):
   // when truthy, skip the SQL-routing shim and do a raw disk read. Used
@@ -1008,6 +1021,8 @@ function safeJson(p) {
       console.error(`[safeJson] parse failure for ${path.basename(p)}: ${parseErr.message}`);
     }
   }
+  // Archived PRDs (prd/archive/) are permanently gone — skip .backup restore.
+  if (_isNoBackupJsonPath(p)) return null;
   // Primary missing or corrupted — try restoring from .backup sidecar.
   const backupPath = p + '.backup';
   try {
@@ -1837,9 +1852,14 @@ function mutateJsonFileLocked(filePath, mutateFn, {
     const finalData = next === undefined ? data : next;
     const shouldWrite = !skipWriteIfUnchanged || parsedInvalid || JSON.stringify(finalData) !== beforeSerialized;
     if (shouldWrite) {
-      // Back up last-known-good state before mutation (best-effort)
-      const backupPath = filePath + '.backup';
-      try { if (fileExists) fs.copyFileSync(filePath, backupPath); } catch { /* backup is best-effort */ }
+      // Back up last-known-good state before mutation (best-effort). SKIP for
+      // archived PRDs under prd/archive/: a .backup there is resurrection fuel
+      // (PL-prd-no-backup, W-mqub65ez0004b3bd). Root-level prd/*.json retains
+      // the backup lifecycle — concurrent-sweep loss must be recoverable.
+      if (!_isNoBackupJsonPath(filePath)) {
+        const backupPath = filePath + '.backup';
+        try { if (fileExists) fs.copyFileSync(filePath, backupPath); } catch { /* backup is best-effort */ }
+      }
       safeWrite(filePath, finalData);
       // Side-effect hook fired only when an actual write happened. Callers
       // use this to emit cache-invalidation signals (events table row) so

package/engine.js

@@ -6121,8 +6121,9 @@ function materializePlansAsWorkItems(config) {
         continue; // Skip — waiting for human approval
       }
     }
-    if (planStatus === PLAN_STATUS.PAUSED || planStatus === PLAN_STATUS.REJECTED || planStatus === PLAN_STATUS.REVISION_REQUESTED) {
-      continue; // Skip — paused or revision requested
+    if (planStatus === PLAN_STATUS.PAUSED || planStatus === PLAN_STATUS.REJECTED ||
+        planStatus === PLAN_STATUS.REVISION_REQUESTED || planStatus === PLAN_STATUS.COMPLETED) {
+      continue; // Skip — paused, rejected, revision-requested, or completed
     }
     // Stale PRDs: source plan was revised — don't materialize NEW items until user regenerates
     if (plan.planStale) {

package/package.json

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