@yemi33/minions 0.1.600 → 0.1.602

package/CHANGELOG.md

@@ -1,8 +1,12 @@
 # Changelog
 
-## 0.1.600 (2026-04-08)
+## 0.1.602 (2026-04-08)
+
+### Features
+- add conditional stage and stop-when support to pipelines (#553)
 
 ### Fixes
+-  rotate live-output.log on spawn to preserve previous session (closes #543) (#551)
 - restore pendingFix on failed human-feedback dispatch (closes #540) (#550)
 
 ## 0.1.599 (2026-04-08)

package/dashboard/js/render-pipelines.js

@@ -191,13 +191,13 @@ function renderPipelines(pipelines) {
   el.innerHTML = pipelines.map(function(p) {
     const activeRun = (p.runs || []).find(function(r) { return r.status === 'running'; });
     const lastRun = (p.runs || []).slice(-1)[0];
-    const statusColor = activeRun ? 'var(--blue)' : lastRun?.status === 'completed' ? 'var(--green)' : lastRun?.status === 'failed' ? 'var(--red)' : 'var(--muted)';
-    const statusLabel = activeRun ? 'Running' : lastRun ? (lastRun.status === 'completed' ? 'Completed' : lastRun.status === 'failed' ? 'Failed' : lastRun.status) : 'Never run';
+    const statusColor = activeRun ? 'var(--blue)' : lastRun?.status === 'completed' ? 'var(--green)' : lastRun?.status === 'failed' ? 'var(--red)' : lastRun?.status === 'stopped' ? 'var(--yellow)' : 'var(--muted)';
+    const statusLabel = activeRun ? 'Running' : lastRun ? (lastRun.status === 'completed' ? 'Completed' : lastRun.status === 'failed' ? 'Failed' : lastRun.status === 'stopped' ? 'Stopped' : lastRun.status) : 'Never run';
     const trigger = p.trigger?.cron ? _cronToHuman(p.trigger.cron) : 'Manual';
 
     // Stage flow visualization
     var stageFlow = (p.stages || []).map(function(s) {
-      var icon = { task: '\u2699', meeting: '\uD83D\uDCAC', plan: '\uD83D\uDCCB', 'merge-prs': '\uD83D\uDD00', api: '\uD83C\uDF10', wait: '\u23F8', parallel: '\u2693', schedule: '\u23F0' }[s.type] || '\u2022';
+      var icon = { task: '\u2699', meeting: '\uD83D\uDCAC', plan: '\uD83D\uDCCB', 'merge-prs': '\uD83D\uDD00', api: '\uD83C\uDF10', wait: '\u23F8', parallel: '\u2693', schedule: '\u23F0', condition: '\u2753' }[s.type] || '\u2022';
       var stageStatus = activeRun?.stages?.[s.id]?.status || 'pending';
       var color = stageStatus === 'completed' ? 'var(--green)' : stageStatus === 'running' ? 'var(--blue)' : stageStatus === 'failed' ? 'var(--red)' : stageStatus === 'waiting-human' ? 'var(--yellow)' : 'var(--muted)';
       return '<span style="color:' + color + ';font-size:11px" title="' + escHtml(s.id) + ': ' + escHtml(s.title || s.type) + ' (' + stageStatus + ')">' + icon + ' ' + escHtml(s.id) + '</span>';
@@ -220,7 +220,8 @@ function renderPipelines(pipelines) {
         '<div style="display:flex;align-items:center;gap:8px">' +
           '<span style="color:' + statusColor + ';font-size:11px;font-weight:600">' + statusLabel + '</span>' +
           '<span style="font-size:10px;color:var(--muted)">' + escHtml(trigger) + '</span>' +
-          (p.enabled === false ? '<span style="font-size:9px;color:var(--red)">DISABLED</span>' : '') +
+          (p.stopWhen ? '<span style="font-size:9px;color:var(--yellow)" title="Auto-stops when condition met: ' + escHtml(typeof p.stopWhen === 'string' ? p.stopWhen : (p.stopWhen.check || 'condition')) + '">STOP-WHEN</span>' : '') +
+          (p.enabled === false ? '<span style="font-size:9px;color:var(--red)"' + (p._stopReason ? ' title="' + escHtml(p._stopReason) + '"' : '') + '>' + (p._stoppedBy ? 'AUTO-STOPPED' : 'DISABLED') + '</span>' : '') +
         '</div>' +
       '</div>' +
       '<div style="margin-top:6px;display:flex;gap:4px;align-items:center;flex-wrap:wrap">' + stageFlow + '</div>' +
@@ -266,6 +267,20 @@ function openPipelineDetail(id) {
     '</div>';
   }
 
+  // stopWhen info
+  if (p.stopWhen) {
+    var swLabel = typeof p.stopWhen === 'string' ? p.stopWhen : (p.stopWhen.check || JSON.stringify(p.stopWhen));
+    html += '<div style="border:1px solid color-mix(in srgb, var(--yellow) 30%, transparent);border-radius:6px;padding:4px 10px;background:color-mix(in srgb, var(--yellow) 6%, transparent);font-size:11px">' +
+      '<span style="color:var(--yellow);font-weight:600">Stop When:</span> <span style="color:var(--text)">' + escHtml(swLabel) + '</span>' +
+      (p._stoppedBy ? ' <span style="color:var(--green);font-size:10px">\u2714 triggered' + (p._stoppedAt ? ' at ' + escHtml(p._stoppedAt.slice(0, 16).replace('T', ' ')) : '') + '</span>' : '') +
+    '</div>';
+  }
+  if (p._stopReason && p.enabled === false) {
+    html += '<div style="border:1px solid color-mix(in srgb, var(--red) 30%, transparent);border-radius:6px;padding:4px 10px;background:color-mix(in srgb, var(--red) 6%, transparent);font-size:11px">' +
+      '<span style="color:var(--red);font-weight:600">Auto-stopped:</span> <span style="color:var(--text)">' + escHtml(p._stopReason) + '</span>' +
+    '</div>';
+  }
+
   html += '<h4 style="font-size:12px;color:var(--blue);margin:0">Stages</h4>';
   (p.stages || []).forEach(function(s, i) {
     var stageRun = activeRun?.stages?.[s.id] || {};
@@ -278,7 +293,9 @@ function openPipelineDetail(id) {
         '<span style="font-weight:600;font-size:12px">' + (i + 1) + '. ' + escHtml(s.title || s.id) + '</span>' +
         '<span style="color:' + statusColor + ';font-size:10px;font-weight:600">' + stageStatus.toUpperCase() + '</span>' +
       '</div>' +
-      '<div style="font-size:10px;color:var(--muted);margin-top:4px">Type: ' + escHtml(s.type) + ' | Depends on: ' + escHtml(deps) + (s.agent ? ' | Agent: ' + escHtml(s.agent) : '') + '</div>' +
+      '<div style="font-size:10px;color:var(--muted);margin-top:4px">Type: ' + escHtml(s.type) + ' | Depends on: ' + escHtml(deps) + (s.agent ? ' | Agent: ' + escHtml(s.agent) : '') +
+        (s.type === 'condition' ? ' | Check: ' + escHtml(typeof (s.check || s.condition) === 'string' ? (s.check || s.condition) : ((s.check || s.condition || {}).check || '?')) + (s.onMet ? ' | onMet: ' + escHtml(s.onMet) : '') + (s.onUnmet ? ' | onUnmet: ' + escHtml(s.onUnmet) : '') : '') +
+      '</div>' +
       _renderMonitoredResources(s.monitoredResources || []) +
       _renderArtifactLinks(stageRun.artifacts) +
       (stageRun.output ? '<div style="margin-top:6px;font-size:11px;max-height:150px;overflow-y:auto">' + renderMd(stageRun.output.slice(0, 500)) + '</div>' : '') +
@@ -291,7 +308,7 @@ function openPipelineDetail(id) {
   if (runs.length > 0) {
     html += '<h4 style="font-size:12px;color:var(--blue);margin:0">Recent Runs</h4>';
     runs.forEach(function(r, ri) {
-      var color = r.status === 'completed' ? 'var(--green)' : r.status === 'failed' ? 'var(--red)' : r.status === 'running' ? 'var(--blue)' : 'var(--muted)';
+      var color = r.status === 'completed' ? 'var(--green)' : r.status === 'failed' ? 'var(--red)' : r.status === 'running' ? 'var(--blue)' : r.status === 'stopped' ? 'var(--yellow)' : 'var(--muted)';
       // Collect all artifacts across stages for this run
       var runArtifacts = _collectRunArtifacts(r);
       var artifactCount = runArtifacts.total;

package/dashboard.js

@@ -1499,6 +1499,26 @@ const server = http.createServer(async (req, res) => {
     try {
       const stat = fs.statSync(liveLogPath);
       const fileSize = stat.size;
+
+      // Fall back to previous session log when current is sparse (fixes #543)
+      const SPARSE_THRESHOLD = 500;
+      if (fileSize < SPARSE_THRESHOLD) {
+        const prevPath = path.join(agentDir, 'live-output-prev.log');
+        try {
+          const prevStat = fs.statSync(prevPath);
+          if (prevStat.size > SPARSE_THRESHOLD) {
+            const prevTailBytes = Math.min(tailBytes, prevStat.size);
+            const prevStart = Math.max(0, prevStat.size - prevTailBytes);
+            const prevFd = fs.openSync(prevPath, 'r');
+            const prevBuf = Buffer.alloc(prevStat.size - prevStart);
+            fs.readSync(prevFd, prevBuf, 0, prevBuf.length, prevStart);
+            fs.closeSync(prevFd);
+            const prevContent = prevBuf.toString('utf8');
+            if (prevContent) safeWrite(`data: ${JSON.stringify(prevContent + '\n\n--- previous session (new session starting) ---\n\n')}\n\n`);
+          }
+        } catch { /* prev file may not exist — that's fine */ }
+      }
+
       if (fileSize > 0) {
         const readStart = Math.max(0, fileSize - tailBytes);
         const readLen = fileSize - readStart;
@@ -1565,7 +1585,9 @@ const server = http.createServer(async (req, res) => {
 
   async function handleAgentLive(req, res, match) {
     const agentId = match[1];
-    const livePath = path.join(MINIONS_DIR, 'agents', agentId, 'live-output.log');
+    const agentDir = path.join(MINIONS_DIR, 'agents', agentId);
+    const livePath = path.join(agentDir, 'live-output.log');
+    const prevPath = path.join(agentDir, 'live-output-prev.log');
     res.setHeader('Content-Type', 'text/plain; charset=utf-8');
     res.setHeader('Access-Control-Allow-Origin', '*');
     const params = new URL(req.url, 'http://localhost').searchParams;
@@ -1576,6 +1598,28 @@ const server = http.createServer(async (req, res) => {
     try {
       const stat = fs.statSync(livePath);
       if (stat.size === 0) { res.end('No live output. Agent may not be running.'); return; }
+
+      // Fall back to previous session log when current is sparse (fixes #543)
+      // Sparse = only header + init JSON, typically < 500 bytes
+      const SPARSE_THRESHOLD = 500;
+      if (stat.size < SPARSE_THRESHOLD && fs.existsSync(prevPath)) {
+        try {
+          const prevStat = fs.statSync(prevPath);
+          if (prevStat.size > SPARSE_THRESHOLD) {
+            // Prepend separator + previous session tail, then append current sparse content
+            const prevTailBytes = Math.max(1, Math.min(tailBytes - stat.size - 100, prevStat.size));
+            const prevStart = Math.max(0, prevStat.size - prevTailBytes);
+            const prevBuf = Buffer.alloc(Math.min(prevTailBytes, prevStat.size));
+            const prevFd = fs.openSync(prevPath, 'r');
+            fs.readSync(prevFd, prevBuf, 0, prevBuf.length, prevStart);
+            fs.closeSync(prevFd);
+            const currentBuf = fs.readFileSync(livePath, 'utf8');
+            res.end(prevBuf.toString('utf8') + '\n\n--- previous session (new session starting) ---\n\n' + currentBuf);
+            return;
+          }
+        } catch { /* fall through to normal read */ }
+      }
+
       const start = Math.max(0, stat.size - tailBytes);
       const buf = Buffer.alloc(Math.min(tailBytes, stat.size));
       const fd = fs.openSync(livePath, 'r');
@@ -1583,6 +1627,21 @@ const server = http.createServer(async (req, res) => {
       fs.closeSync(fd);
       res.end(buf.toString('utf8'));
     } catch {
+      // If live-output.log doesn't exist but prev does, serve that
+      try {
+        if (fs.existsSync(prevPath)) {
+          const prevStat = fs.statSync(prevPath);
+          if (prevStat.size > 0) {
+            const start = Math.max(0, prevStat.size - tailBytes);
+            const buf = Buffer.alloc(Math.min(tailBytes, prevStat.size));
+            const fd = fs.openSync(prevPath, 'r');
+            fs.readSync(fd, buf, 0, buf.length, start);
+            fs.closeSync(fd);
+            res.end(buf.toString('utf8') + '\n\n--- previous session (current session output unavailable) ---\n');
+            return;
+          }
+        }
+      } catch { /* fall through */ }
       res.end('No live output. Agent may not be running.');
     }
     return;
@@ -3961,18 +4020,19 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const result = pipelines.map(p => ({ ...p, runs: (runs[p.id] || []).slice(-5) }));
       return jsonReply(res, 200, result);
     }},
-    { method: 'POST', path: '/api/pipelines', desc: 'Create a pipeline', params: 'id, title, stages[], trigger?, monitoredResources?', handler: async (req, res) => {
+    { method: 'POST', path: '/api/pipelines', desc: 'Create a pipeline', params: 'id, title, stages[], trigger?, stopWhen?, monitoredResources?', handler: async (req, res) => {
       const body = await readBody(req);
       if (!body.id || !body.title || !body.stages) return jsonReply(res, 400, { error: 'id, title, and stages required' });
       const { savePipeline, getPipeline } = require('./engine/pipeline');
       if (getPipeline(body.id)) return jsonReply(res, 409, { error: 'Pipeline already exists' });
       const pipeline = { id: body.id, title: body.title, stages: body.stages, trigger: body.trigger || {}, enabled: body.enabled !== false };
+      if (body.stopWhen) pipeline.stopWhen = body.stopWhen;
       if (Array.isArray(body.monitoredResources) && body.monitoredResources.length > 0) pipeline.monitoredResources = body.monitoredResources;
       savePipeline(pipeline);
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, id: pipeline.id });
     }},
-    { method: 'POST', path: '/api/pipelines/update', desc: 'Update a pipeline', params: 'id, title?, stages?, trigger?, enabled?, monitoredResources?', handler: async (req, res) => {
+    { method: 'POST', path: '/api/pipelines/update', desc: 'Update a pipeline', params: 'id, title?, stages?, trigger?, enabled?, stopWhen?, monitoredResources?', handler: async (req, res) => {
       const body = await readBody(req);
       if (!body.id) return jsonReply(res, 400, { error: 'id required' });
       const { getPipeline, savePipeline } = require('./engine/pipeline');
@@ -3983,6 +4043,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (body.trigger !== undefined) pipeline.trigger = body.trigger;
       if (body.enabled !== undefined) pipeline.enabled = body.enabled;
       if (body.monitoredResources !== undefined) pipeline.monitoredResources = body.monitoredResources;
+      if (body.stopWhen !== undefined) pipeline.stopWhen = body.stopWhen;
       savePipeline(pipeline);
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true });

package/engine/cleanup.js

@@ -76,7 +76,7 @@ function runCleanup(config, verbose = false) {
     }
   }
 
-  // 2. Clean live-output.log for idle agents (not currently working)
+  // 2. Clean live-output.log and live-output-prev.log for idle agents (not currently working)
   for (const [agentId] of Object.entries(config.agents || {})) {
     const status = getAgentStatus(agentId);
     if (status.status !== 'working') {
@@ -90,6 +90,17 @@ function runCleanup(config, verbose = false) {
           }
         } catch { /* cleanup */ }
       }
+      // Also clean rotated previous session log
+      const prevPath = path.join(AGENTS_DIR, agentId, 'live-output-prev.log');
+      if (fs.existsSync(prevPath)) {
+        try {
+          const stat = fs.statSync(prevPath);
+          if (stat.mtimeMs < oneHourAgo) {
+            fs.unlinkSync(prevPath);
+            cleaned.liveOutputs++;
+          }
+        } catch { /* cleanup */ }
+      }
     }
   }
 

package/engine/pipeline.js

@@ -1,7 +1,7 @@
 /**
  * engine/pipeline.js — Multi-stage pipeline orchestration.
- * Pipelines chain stages (task, meeting, plan, merge-prs, api, wait, parallel)
- * with dependency tracking and artifact discovery.
+ * Pipelines chain stages (task, meeting, plan, merge-prs, api, wait, parallel, condition)
+ * with dependency tracking, artifact discovery, and conditional stop/termination.
  */
 
 const fs = require('fs');
@@ -124,6 +124,79 @@ function resolveStageConfig(stage, run) {
   return resolved;
 }
 
+// ── Condition Evaluation ─────────────────────────────────────────────────────
+
+/**
+ * Evaluate a pipeline condition. Used by both `stopWhen` and `condition` stages.
+ * @param {string|object} condition — condition name (string shorthand) or { check, ... } object
+ * @param {{ run, pipeline, config }} ctx — evaluation context
+ * @returns {boolean} whether the condition is met
+ */
+function evaluateCondition(condition, ctx) {
+  const { run, pipeline, config } = ctx;
+  // Normalize: string shorthand → { check: string }
+  const cond = typeof condition === 'string' ? { check: condition } : (condition || {});
+
+  switch (cond.check) {
+    case 'runSucceeded': {
+      // True when the current/last run completed with all stages succeeded (none failed)
+      if (!run) return false;
+      return Object.values(run.stages || {}).every(
+        s => s.status === PIPELINE_STATUS.COMPLETED || s.status === PIPELINE_STATUS.PENDING
+      );
+    }
+    case 'noFailedItems': {
+      // True when all work items created by the pipeline are done (not failed)
+      if (!run) return false;
+      const wiPath = path.join(__dirname, '..', 'work-items.json');
+      const workItems = safeJson(wiPath) || [];
+      const allProjectWi = shared.getProjects(config).reduce((acc, p) => {
+        return acc.concat(safeJson(shared.projectWorkItemsPath(p)) || []);
+      }, []);
+      const all = [...workItems, ...allProjectWi];
+      const pipelineWis = all.filter(w => w._pipelineRun === run.runId);
+      if (pipelineWis.length === 0) return true; // no items = nothing failed
+      return pipelineWis.every(w => w.status !== WI_STATUS.FAILED);
+    }
+    case 'maxRuns': {
+      // True when total run count for this pipeline >= threshold
+      const threshold = cond.value || 1;
+      const runs = getPipelineRuns();
+      const pipelineRuns = runs[pipeline?.id] || [];
+      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);
+        if (!pr || pr.buildStatus !== 'passing') return false;
+      }
+      return true;
+    }
+    default:
+      log('warn', `Pipeline condition: unknown check '${cond.check}'`);
+      return false;
+  }
+}
+
 // ── Stage Execution ──────────────────────────────────────────────────────────
 
 async function executeStage(stage, run, pipeline, config) {
@@ -143,6 +216,8 @@ async function executeStage(stage, run, pipeline, config) {
       return executeMergePrsStage(resolved, stageState, run, config);
     case STAGE_TYPE.SCHEDULE:
       return executeScheduleStage(resolved, stageState, config);
+    case STAGE_TYPE.CONDITION:
+      return executeConditionStage(resolved, stageState, run, pipeline, config);
     case STAGE_TYPE.WAIT:
       // wait stages just sit in waiting-human status until continued via API
       return { status: PIPELINE_STATUS.WAITING_HUMAN };
@@ -375,6 +450,38 @@ function executeScheduleStage(stage, stageState, config) {
   return { status: PIPELINE_STATUS.COMPLETED, completedAt: ts() };
 }
 
+function executeConditionStage(stage, stageState, run, pipeline, config) {
+  const check = stage.check || stage.condition;
+  if (!check) {
+    log('warn', `Pipeline ${pipeline.id}: condition stage ${stage.id} has no check defined`);
+    return { status: PIPELINE_STATUS.FAILED, error: 'no check defined' };
+  }
+
+  const met = evaluateCondition(check, { run, pipeline, config });
+  const action = met ? (stage.onMet || 'complete') : (stage.onUnmet || 'fail');
+  log('info', `Pipeline ${pipeline.id}: condition '${typeof check === 'string' ? check : check.check}' → ${met ? 'met' : 'unmet'}, action: ${action}`);
+
+  switch (action) {
+    case 'complete':
+    case 'continue':
+      return { status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), output: `Condition ${met ? 'met' : 'unmet'}` };
+    case 'fail':
+      return { status: PIPELINE_STATUS.FAILED, error: `Condition ${met ? 'met' : 'unmet'}` };
+    case 'stop-pipeline':
+      // Disable the pipeline and complete the run
+      pipeline.enabled = false;
+      pipeline._stoppedBy = stage.id;
+      pipeline._stoppedAt = ts();
+      pipeline._stopReason = `Condition '${typeof check === 'string' ? check : check.check}' ${met ? 'met' : 'unmet'}`;
+      savePipeline(pipeline);
+      log('info', `Pipeline ${pipeline.id}: auto-disabled by condition stage ${stage.id}`);
+      return { status: PIPELINE_STATUS.COMPLETED, completedAt: ts(), output: `Pipeline stopped: condition ${met ? 'met' : 'unmet'}`, _stopPipeline: true };
+    default:
+      log('warn', `Pipeline ${pipeline.id}: unknown condition action '${action}'`);
+      return { status: PIPELINE_STATUS.FAILED, error: `unknown action '${action}'` };
+  }
+}
+
 async function executeParallelStage(stage, stageState, run, pipeline, config) {
   const subStages = stage.stages || [];
   const subResults = {};
@@ -496,7 +603,8 @@ function isStageComplete(stage, stageState, run, config) {
     }
     case STAGE_TYPE.API:
     case STAGE_TYPE.SCHEDULE:
-      return true; // fire-and-forget
+    case STAGE_TYPE.CONDITION:
+      return true; // immediate — resolved synchronously on execute
     case STAGE_TYPE.WAIT:
       return stageState.status === PIPELINE_STATUS.COMPLETED;
     case STAGE_TYPE.PARALLEL: {
@@ -626,6 +734,12 @@ async function discoverPipelineWork(config) {
           updateRunStage(pipeline.id, activeRun.runId, stage.id, { ...result, startedAt: ts() });
           Object.assign(stageState, result, { startedAt: ts() });
           if (result.status === PIPELINE_STATUS.RUNNING) anyRunning = true;
+          // Condition stage signaled pipeline stop — complete the run immediately
+          if (result._stopPipeline) {
+            completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.STOPPED);
+            allComplete = true;
+            break;
+          }
           log('info', `Pipeline ${pipeline.id}: started stage ${stage.id} (${stage.type})`);
         }
       }
@@ -636,7 +750,25 @@ async function discoverPipelineWork(config) {
 
     // Check if run is done
     if (allComplete) {
-      completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.COMPLETED);
+      // Only complete if not already stopped by a condition stage
+      if (activeRun.status !== PIPELINE_STATUS.STOPPED) {
+        completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.COMPLETED);
+      }
+
+      // Evaluate top-level stopWhen after successful run completion
+      if (pipeline.stopWhen && pipeline.enabled !== false) {
+        try {
+          const stopMet = evaluateCondition(pipeline.stopWhen, { run: activeRun, pipeline, config });
+          if (stopMet) {
+            pipeline.enabled = false;
+            pipeline._stoppedBy = 'stopWhen';
+            pipeline._stoppedAt = ts();
+            pipeline._stopReason = `stopWhen condition '${typeof pipeline.stopWhen === 'string' ? pipeline.stopWhen : (pipeline.stopWhen.check || 'unknown')}' met`;
+            savePipeline(pipeline);
+            log('info', `Pipeline ${pipeline.id}: auto-disabled by stopWhen condition`);
+          }
+        } catch (e) { log('warn', `Pipeline ${pipeline.id}: stopWhen evaluation failed: ${e.message}`); }
+      }
     } else if (anyFailed && !anyRunning) {
       completeRun(pipeline.id, activeRun.runId, PIPELINE_STATUS.FAILED);
     }
@@ -648,4 +780,5 @@ module.exports = {
   getPipelines, getPipeline, savePipeline, deletePipeline,
   getPipelineRuns, getActiveRun, startRun, updateRunStage, completeRun,
   discoverPipelineWork,
+  evaluateCondition, // exported for testing
 };

package/engine/shared.js

@@ -558,10 +558,12 @@ 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',
+  STOPPED: 'stopped', // pipeline auto-disabled by stopWhen or condition stage
 };
 const STAGE_TYPE = {
   TASK: 'task', MEETING: 'meeting', PLAN: 'plan', API: 'api',
   MERGE_PRS: 'merge-prs', SCHEDULE: 'schedule', WAIT: 'wait', PARALLEL: 'parallel',
+  CONDITION: 'condition',
 };
 const MEETING_STATUS = {
   INVESTIGATING: 'investigating', DEBATING: 'debating', CONCLUDING: 'concluding',

package/engine.js

@@ -560,6 +560,20 @@ async function spawnAgent(dispatchItem, config) {
 
   // Live output file — written as data arrives so dashboard can tail it
   const liveOutputPath = path.join(AGENTS_DIR, agentId, 'live-output.log');
+
+  // Rotate previous live output to preserve session history (fixes #543: orphan recovery overwrites)
+  // Only rotate if the existing file has meaningful content (beyond just the header)
+  const LIVE_OUTPUT_SPARSE_THRESHOLD = 500; // bytes — header + init JSON is typically < 500
+  try {
+    if (fs.existsSync(liveOutputPath)) {
+      const prevStat = fs.statSync(liveOutputPath);
+      if (prevStat.size > LIVE_OUTPUT_SPARSE_THRESHOLD) {
+        const prevPath = path.join(AGENTS_DIR, agentId, 'live-output-prev.log');
+        fs.renameSync(liveOutputPath, prevPath);
+      }
+    }
+  } catch { /* rotation is best-effort — overwrite still happens below */ }
+
   safeWrite(liveOutputPath, `# Live output for ${agentId} — ${id}\n# Started: ${startedAt}\n# Task: ${dispatchItem.task}\n\n`);
 
   // Keep live log active even when the agent produces no stdout/stderr for long stretches.

package/package.json

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