@yemi33/minions 0.1.389 → 0.1.391

package/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
 
-## 0.1.389 (2026-04-06)
+## 0.1.391 (2026-04-06)
 
 ### Features
+-  track dashboard version — detect stale dashboard code separately
+- Replace magic strings in pipeline.js with STAGE_TYPE/PIPELINE_STATUS/MEETING_STATUS constants (#244)
 - Fix spawn-agent.js direct proc.kill() — use cross-platform helpers (#243)
 
 ## 0.1.388 (2026-04-06)

package/dashboard/js/render-dispatch.js

@@ -215,21 +215,27 @@ function renderVersionBanner(version) {
   if (!el) return;
   if (!version) { el.style.display = 'none'; return; }
 
-  const v = version.running || version.disk || '?';
-  const commitLabel = version.runningCommit ? ' (' + version.runningCommit + ')' : '';
-
-  if (version.stale) {
-    // Engine running old code — needs restart
-    el.style.cssText = 'font-size:9px;padding:2px 8px;background:rgba(210,153,34,0.15);border:1px solid rgba(210,153,34,0.3);border-radius:4px;color:var(--yellow);cursor:help';
-    el.textContent = '\u26A0 Engine running v' + (version.running || '?') + ' — disk has v' + (version.disk || '?') + '. Restart to apply.';
-    el.title = 'The engine process is running older code than what is on disk. Run: minions restart';
+  const v = version.dashboardRunning || version.running || version.disk || '?';
+  const commitLabel = version.dashboardRunningCommit ? ' (' + version.dashboardRunningCommit + ')' : '';
+  const warnStyle = 'font-size:9px;padding:2px 8px;background:rgba(210,153,34,0.15);border:1px solid rgba(210,153,34,0.3);border-radius:4px;color:var(--yellow);cursor:help';
+
+  if (version.engineStale && version.dashboardStale) {
+    el.style.cssText = warnStyle;
+    el.textContent = '\u26A0 Engine + Dashboard running old code. Run: minions restart';
+    el.title = 'Both processes are running v' + (version.running || '?') + ' but disk has v' + (version.disk || '?');
+  } else if (version.engineStale) {
+    el.style.cssText = warnStyle;
+    el.textContent = '\u26A0 Engine running v' + (version.running || '?') + ' — disk has v' + (version.disk || '?') + '. Restart engine.';
+    el.title = 'The engine process is running older code. Run: minions restart';
+  } else if (version.dashboardStale) {
+    el.style.cssText = warnStyle;
+    el.textContent = '\u26A0 Dashboard running v' + (version.dashboardRunning || '?') + ' — disk has v' + (version.disk || '?') + '. Run: minions restart';
+    el.title = 'The dashboard process is running older code. Run: minions restart';
   } else if (version.updateAvailable) {
-    // New version on npm
     el.style.cssText = 'font-size:9px;padding:2px 8px;background:rgba(63,185,80,0.1);border:1px solid rgba(63,185,80,0.3);border-radius:4px;color:var(--green);cursor:help';
     el.textContent = 'v' + v + commitLabel + ' — v' + version.latest + ' available. Run: npm update -g @yemi33/minions';
     el.title = 'A newer version is available on npm';
   } else {
-    // Up to date
     el.style.cssText = 'font-size:9px;color:var(--muted)';
     el.textContent = 'v' + v + commitLabel;
     el.title = 'Minions v' + v + (version.latest ? ' (latest)' : '');

package/dashboard.js

@@ -10,6 +10,14 @@ const zlib = require('zlib');
 const fs = require('fs');
 const path = require('path');
 const llm = require('./engine/llm');
+
+// Dashboard version stamp — captured at module load so it reflects the code actually running
+const _dashboardVersion = {
+  codeVersion: (() => { try { return require('./package.json').version; } catch { return null; } })(),
+  codeCommit: (() => { try { return require('child_process').execSync('git rev-parse --short HEAD', { cwd: __dirname, encoding: 'utf8', timeout: 5000, windowsHide: true }).trim(); } catch { return null; } })(),
+  startedAt: new Date().toISOString(),
+  pid: process.pid,
+};
 const shared = require('./engine/shared');
 const queries = require('./engine/queries');
 const os = require('os');
@@ -313,13 +321,20 @@ function getStatus() {
     version: (() => {
       const engine = getEngineState();
       const { diskVersion, diskCommit } = getDiskVersion();
+      const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
+                          !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
+      const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
+                             !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
       return {
         running: engine.codeVersion || null,
         runningCommit: engine.codeCommit || null,
+        dashboardRunning: _dashboardVersion.codeVersion,
+        dashboardRunningCommit: _dashboardVersion.codeCommit,
         disk: diskVersion,
         diskCommit,
-        stale: !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
-               !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit),
+        engineStale,
+        dashboardStale,
+        stale: engineStale || dashboardStale,
         latest: _npmVersionCache?.latest || null,
         updateAvailable: !!(diskVersion && _npmVersionCache?.latest && _npmVersionCache.latest !== diskVersion && _compareVersions(_npmVersionCache.latest, diskVersion) > 0),
       };
@@ -3435,15 +3450,22 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const npm = await checkNpmVersion();
       const { diskVersion, diskCommit } = getDiskVersion();
       const engine = getEngineState();
+      const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
+                          !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
+      const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
+                             !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
       return jsonReply(res, 200, {
         current: diskVersion,
         currentCommit: diskCommit,
-        running: engine.codeVersion || null,
-        runningCommit: engine.codeCommit || null,
+        engineRunning: engine.codeVersion || null,
+        engineRunningCommit: engine.codeCommit || null,
+        dashboardRunning: _dashboardVersion.codeVersion,
+        dashboardRunningCommit: _dashboardVersion.codeCommit,
         latest: npm.latest,
         updateAvailable: !!(diskVersion && npm.latest && _compareVersions(npm.latest, diskVersion) > 0),
-        stale: !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
-               !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit),
+        engineStale,
+        dashboardStale,
+        stale: engineStale || dashboardStale,
         checkedAt: npm.checkedAt,
       });
     }},

package/engine/pipeline.js

@@ -7,7 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
-const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, MEETING_STATUS } = shared;
+const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS } = shared;
 const { parseCronExpr, shouldRunNow } = require('./scheduler');
 
 const PIPELINES_DIR = path.join(__dirname, '..', 'pipelines');
@@ -130,22 +130,22 @@ async function executeStage(stage, run, pipeline, config) {
   const stageState = run.stages[stage.id];
 
   switch (resolved.type) {
-    case 'task':
+    case STAGE_TYPE.TASK:
       return executeTaskStage(resolved, stageState, run, config);
-    case 'meeting':
+    case STAGE_TYPE.MEETING:
       return executeMeetingStage(resolved, stageState, run, config);
-    case 'plan':
+    case STAGE_TYPE.PLAN:
       return executePlanStage(resolved, stageState, run, config);
-    case 'api':
+    case STAGE_TYPE.API:
       return executeApiStage(resolved, stageState, run);
-    case 'merge-prs':
+    case STAGE_TYPE.MERGE_PRS:
       return executeMergePrsStage(resolved, stageState, run, config);
-    case 'schedule':
+    case STAGE_TYPE.SCHEDULE:
       return executeScheduleStage(resolved, stageState, config);
-    case 'wait':
+    case STAGE_TYPE.WAIT:
       // wait stages just sit in waiting-human status until continued via API
       return { status: PIPELINE_STATUS.WAITING_HUMAN };
-    case 'parallel':
+    case STAGE_TYPE.PARALLEL:
       return executeParallelStage(resolved, stageState, run, pipeline, config);
     default:
       log('warn', `Pipeline: unknown stage type '${resolved.type}' in stage ${stage.id}`);
@@ -298,7 +298,7 @@ async function executePlanStage(stage, stageState, run, config) {
   }
 
   return {
-    status: 'running',
+    status: PIPELINE_STATUS.RUNNING,
     artifacts: {
       plans: [path.basename(filePath)],
       workItems: [wiId],
@@ -355,33 +355,33 @@ function executeScheduleStage(stage, stageState, config) {
     }
   }
   safeWrite(path.join(__dirname, '..', 'config.json'), config);
-  return { status: 'completed', completedAt: ts() };
+  return { status: PIPELINE_STATUS.COMPLETED, completedAt: ts() };
 }
 
 async function executeParallelStage(stage, stageState, run, pipeline, config) {
   const subStages = stage.stages || [];
   const subResults = {};
   for (const sub of subStages) {
-    if (!run.stages[sub.id] || run.stages[sub.id].status === 'pending') {
+    if (!run.stages[sub.id] || run.stages[sub.id].status === PIPELINE_STATUS.PENDING) {
       const result = await executeStage(sub, run, pipeline, config);
       subResults[sub.id] = result;
       run.stages[sub.id] = { ...run.stages[sub.id] || {}, ...result, startedAt: ts() };
     }
   }
   // Parent is running until all subs complete
-  return { status: 'running', artifacts: { subStages: subStages.map(s => s.id) } };
+  return { status: PIPELINE_STATUS.RUNNING, artifacts: { subStages: subStages.map(s => s.id) } };
 }
 
 // ── Stage Completion Checks ──────────────────────────────────────────────────
 
 function isStageComplete(stage, stageState, run, config) {
-  if (stageState.status === 'completed' || stageState.status === 'failed') return true;
-  if (stageState.status === 'pending' || stageState.status === 'waiting-human') return false;
+  if (stageState.status === PIPELINE_STATUS.COMPLETED || stageState.status === PIPELINE_STATUS.FAILED) return true;
+  if (stageState.status === PIPELINE_STATUS.PENDING || stageState.status === PIPELINE_STATUS.WAITING_HUMAN) return false;
 
   const artifacts = stageState.artifacts || {};
 
   switch (stage.type) {
-    case 'task': {
+    case STAGE_TYPE.TASK: {
       const wiPath = path.join(__dirname, '..', 'work-items.json');
       const workItems = safeJson(wiPath) || [];
       const ids = artifacts.workItems || [];
@@ -391,16 +391,16 @@ function isStageComplete(stage, stageState, run, config) {
         return !wi || wi.status === WI_STATUS.DONE || wi.status === WI_STATUS.FAILED; // missing = treat as done
       });
     }
-    case 'meeting': {
+    case STAGE_TYPE.MEETING: {
       const { getMeeting } = require('./meeting');
       const ids = artifacts.meetings || [];
       if (ids.length === 0) return false;
       return ids.every(id => {
         const m = getMeeting(id);
-        return m && (m.status === 'completed' || m.status === 'archived');
+        return m && (m.status === MEETING_STATUS.COMPLETED || m.status === MEETING_STATUS.ARCHIVED);
       });
     }
-    case 'plan': {
+    case STAGE_TYPE.PLAN: {
       // Plan stage completion: PRD conversion done + all materialized work items done
       const wiPath = path.join(__dirname, '..', 'work-items.json');
       const workItems = safeJson(wiPath) || [];
@@ -464,7 +464,7 @@ function isStageComplete(stage, stageState, run, config) {
         return !wi || wi.status === WI_STATUS.DONE || wi.status === WI_STATUS.FAILED; // missing = treat as done
       });
     }
-    case 'merge-prs': {
+    case STAGE_TYPE.MERGE_PRS: {
       const prIds = artifacts.prs || [];
       if (prIds.length === 0) return true; // nothing to merge
       const projects = shared.getProjects(config);
@@ -477,16 +477,16 @@ function isStageComplete(stage, stageState, run, config) {
       }
       return true;
     }
-    case 'api':
-    case 'schedule':
+    case STAGE_TYPE.API:
+    case STAGE_TYPE.SCHEDULE:
       return true; // fire-and-forget
-    case 'wait':
-      return stageState.status === 'completed';
-    case 'parallel': {
+    case STAGE_TYPE.WAIT:
+      return stageState.status === PIPELINE_STATUS.COMPLETED;
+    case STAGE_TYPE.PARALLEL: {
       const subIds = artifacts.subStages || [];
       return subIds.every(id => {
         const sub = run.stages[id];
-        return sub && (sub.status === 'completed' || sub.status === 'failed');
+        return sub && (sub.status === PIPELINE_STATUS.COMPLETED || sub.status === PIPELINE_STATUS.FAILED);
       });
     }
     default:
@@ -533,18 +533,18 @@ async function discoverPipelineWork(config) {
       if (!stageState) continue;
 
       // Check if running stage completed
-      if (stageState.status === 'running') {
+      if (stageState.status === PIPELINE_STATUS.RUNNING) {
         if (isStageComplete(stage, stageState, activeRun, config)) {
           // Collect output
           let output = '';
-          if (stage.type === 'task') {
+          if (stage.type === STAGE_TYPE.TASK) {
             const wiPath = path.join(__dirname, '..', 'work-items.json');
             const workItems = safeJson(wiPath) || [];
             output = (stageState.artifacts?.workItems || []).map(id => {
               const wi = workItems.find(w => w.id === id);
               return wi?.resultSummary || wi?.title || id;
             }).join('\n');
-          } else if (stage.type === 'meeting') {
+          } else if (stage.type === STAGE_TYPE.MEETING) {
             const { getMeeting } = require('./meeting');
             output = (stageState.artifacts?.meetings || []).map(id => {
               const m = getMeeting(id);
@@ -553,9 +553,9 @@ async function discoverPipelineWork(config) {
           }
 
           updateRunStage(pipeline.id, activeRun.runId, stage.id, {
-            status: 'completed', completedAt: ts(), output
+            status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), output
           });
-          stageState.status = 'completed';
+          stageState.status = PIPELINE_STATUS.COMPLETED;
           stageState.output = output;
           log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed`);
         } else {
@@ -564,42 +564,42 @@ async function discoverPipelineWork(config) {
         }
       }
 
-      if (stageState.status === 'waiting-human') { allComplete = false; continue; }
+      if (stageState.status === PIPELINE_STATUS.WAITING_HUMAN) { allComplete = false; continue; }
 
       // Check if pending stage is ready to start
-      if (stageState.status === 'pending') {
+      if (stageState.status === PIPELINE_STATUS.PENDING) {
         allComplete = false;
         const depsReady = (stage.dependsOn || []).every(depId => {
           const dep = activeRun.stages[depId];
-          return dep && dep.status === 'completed';
+          return dep && dep.status === PIPELINE_STATUS.COMPLETED;
         });
         const depsFailed = (stage.dependsOn || []).some(depId => {
           const dep = activeRun.stages[depId];
-          return dep && dep.status === 'failed';
+          return dep && dep.status === PIPELINE_STATUS.FAILED;
         });
 
         if (depsFailed) {
-          updateRunStage(pipeline.id, activeRun.runId, stage.id, { status: 'failed', error: 'dependency failed' });
-          stageState.status = 'failed';
+          updateRunStage(pipeline.id, activeRun.runId, stage.id, { status: PIPELINE_STATUS.FAILED, error: 'dependency failed' });
+          stageState.status = PIPELINE_STATUS.FAILED;
           anyFailed = true;
         } else if (depsReady) {
           const result = await executeStage(stage, activeRun, pipeline, config);
           updateRunStage(pipeline.id, activeRun.runId, stage.id, { ...result, startedAt: ts() });
           Object.assign(stageState, result, { startedAt: ts() });
-          if (result.status === 'running') anyRunning = true;
+          if (result.status === PIPELINE_STATUS.RUNNING) anyRunning = true;
           log('info', `Pipeline ${pipeline.id}: started stage ${stage.id} (${stage.type})`);
         }
       }
 
-      if (stageState.status === 'failed') anyFailed = true;
-      if (stageState.status !== 'completed') allComplete = false;
+      if (stageState.status === PIPELINE_STATUS.FAILED) anyFailed = true;
+      if (stageState.status !== PIPELINE_STATUS.COMPLETED) allComplete = false;
     }
 
     // Check if run is done
     if (allComplete) {
-      completeRun(pipeline.id, activeRun.runId, 'completed');
+      completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.COMPLETED);
     } else if (anyFailed && !anyRunning) {
-      completeRun(pipeline.id, activeRun.runId, 'failed');
+      completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.FAILED);
     }
   }
 }

package/engine/shared.js

@@ -417,6 +417,18 @@ const PLAN_STATUS = {
 };
 const PR_STATUS = { ACTIVE: 'active', MERGED: 'merged', ABANDONED: 'abandoned', CLOSED: 'closed' };
 const DISPATCH_RESULT = { SUCCESS: 'success', ERROR: 'error', TIMEOUT: 'timeout' };
+const PIPELINE_STATUS = {
+  PENDING: 'pending', RUNNING: 'running', COMPLETED: 'completed',
+  FAILED: 'failed', PAUSED: 'paused', WAITING_HUMAN: 'waiting-human',
+};
+const STAGE_TYPE = {
+  TASK: 'task', MEETING: 'meeting', PLAN: 'plan', API: 'api',
+  MERGE_PRS: 'merge-prs', SCHEDULE: 'schedule', WAIT: 'wait', PARALLEL: 'parallel',
+};
+const MEETING_STATUS = {
+  INVESTIGATING: 'investigating', DEBATING: 'debating', CONCLUDING: 'concluding',
+  COMPLETED: 'completed', ARCHIVED: 'archived',
+};
 
 const DEFAULT_AGENTS = {
   ripley:  { name: 'Ripley',  emoji: '\u{1F3D7}\uFE0F',  role: 'Lead / Explorer', skills: ['architecture', 'codebase-exploration', 'design-review'] },
@@ -648,6 +660,7 @@ module.exports = {
   classifyInboxItem,
   ENGINE_DEFAULTS,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PR_STATUS, DISPATCH_RESULT,
+  PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS,
   DEFAULT_AGENTS,
   DEFAULT_CLAUDE,
   getProjects,

package/package.json

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