@yemi33/minions 0.1.130 → 0.1.131

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.131 (2026-04-01)
+
+### Engine
+- engine.js
+- engine/ado.js
+- engine/pipeline.js
+
+### Dashboard
+- dashboard.js
+- dashboard/js/refresh.js
+- dashboard/js/render-pipelines.js
+- dashboard/layout.html
+- dashboard/pages/pipelines.html
+
 ## 0.1.130 (2026-04-01)
 
 ### Engine

package/dashboard/js/refresh.js

@@ -67,6 +67,7 @@ function _processStatusUpdate(data) {
   renderMcpServers(data.mcpServers || []);
   renderSchedules(data.schedules || []);
   renderMeetings(data.meetings || []);
+  if (typeof renderPipelines === 'function') renderPipelines(data.pipelines || []);
   renderPinned(data.pinned || []);
   // Update sidebar counts
   const swi = document.getElementById('sidebar-wi');

package/dashboard/js/render-pipelines.js

@@ -0,0 +1,182 @@
+// render-pipelines.js — Pipeline list, run detail, and create modal
+
+let _pipelinesData = [];
+
+function renderPipelines(pipelines) {
+  _pipelinesData = pipelines || [];
+  const el = document.getElementById('pipelines-content');
+  const countEl = document.getElementById('pipelines-count');
+  if (!el) return;
+  if (!pipelines || pipelines.length === 0) {
+    countEl.textContent = '0';
+    el.innerHTML = '<p class="empty">No pipelines yet. Create one to chain stages like audit \u2192 meeting \u2192 plan \u2192 merge.</p>';
+    return;
+  }
+  countEl.textContent = pipelines.length;
+
+  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 trigger = p.trigger?.cron ? 'Cron: ' + 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 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>';
+    }).join(' <span style="color:var(--border)">\u2192</span> ');
+
+    return '<div style="background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:12px 16px;margin-bottom:8px;cursor:pointer" onclick="openPipelineDetail(\'' + escHtml(p.id) + '\')">' +
+      '<div style="display:flex;justify-content:space-between;align-items:center">' +
+        '<strong style="font-size:13px">' + escHtml(p.title) + '</strong>' +
+        '<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>' : '') +
+        '</div>' +
+      '</div>' +
+      '<div style="margin-top:6px;display:flex;gap:4px;align-items:center;flex-wrap:wrap">' + stageFlow + '</div>' +
+    '</div>';
+  }).join('');
+}
+
+function openPipelineDetail(id) {
+  var p = _pipelinesData.find(function(x) { return x.id === id; });
+  if (!p) { alert('Pipeline not found'); return; }
+
+  var html = '<div style="display:flex;flex-direction:column;gap:12px">';
+
+  // Status + actions
+  var activeRun = (p.runs || []).find(function(r) { return r.status === 'running'; });
+  html += '<div style="display:flex;justify-content:space-between;align-items:center">' +
+    '<span style="font-size:10px;color:var(--muted)">' + (p.trigger?.cron ? 'Cron: ' + p.trigger.cron : 'Manual trigger') + '</span>' +
+    '<div style="display:flex;gap:6px">' +
+      (activeRun ? '' : '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);border-color:var(--green)" onclick="_triggerPipeline(\'' + escHtml(id) + '\',this)">Run Now</button>') +
+      '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px" onclick="_togglePipelineEnabled(\'' + escHtml(id) + '\',' + !p.enabled + ',this)">' + (p.enabled !== false ? 'Disable' : 'Enable') + '</button>' +
+      '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--red);border-color:var(--red)" onclick="_deletePipelineConfirm(\'' + escHtml(id) + '\')">Delete</button>' +
+    '</div>' +
+  '</div>';
+
+  // Stage detail
+  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] || {};
+    var stageStatus = stageRun.status || 'pending';
+    var statusColor = stageStatus === 'completed' ? 'var(--green)' : stageStatus === 'running' ? 'var(--blue)' : stageStatus === 'failed' ? 'var(--red)' : stageStatus === 'waiting-human' ? 'var(--yellow)' : 'var(--muted)';
+    var deps = (s.dependsOn || []).join(', ') || 'none';
+
+    html += '<div style="border:1px solid var(--border);border-radius:6px;padding:8px 12px;background:var(--surface2)">' +
+      '<div style="display:flex;justify-content:space-between;align-items:center">' +
+        '<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>' +
+      (stageRun.output ? '<div style="margin-top:6px;font-size:11px;max-height:150px;overflow-y:auto">' + renderMd(stageRun.output.slice(0, 500)) + '</div>' : '') +
+      (stageStatus === 'waiting-human' ? '<button class="pr-pager-btn" style="font-size:9px;padding:2px 8px;color:var(--green);border-color:var(--green);margin-top:6px" onclick="_continuePipeline(\'' + escHtml(id) + '\',\'' + escHtml(s.id) + '\',this)">Continue</button>' : '') +
+    '</div>';
+  });
+
+  // Run history
+  var runs = (p.runs || []).slice(-5).reverse();
+  if (runs.length > 0) {
+    html += '<h4 style="font-size:12px;color:var(--blue);margin:0">Recent Runs</h4>';
+    runs.forEach(function(r) {
+      var color = r.status === 'completed' ? 'var(--green)' : r.status === 'failed' ? 'var(--red)' : r.status === 'running' ? 'var(--blue)' : 'var(--muted)';
+      html += '<div style="font-size:10px;display:flex;gap:8px;align-items:center">' +
+        '<span style="color:' + color + ';font-weight:600">' + r.status + '</span>' +
+        '<span style="color:var(--muted)">' + (r.startedAt ? new Date(r.startedAt).toLocaleString() : '') + '</span>' +
+        (r.completedAt ? '<span style="color:var(--muted)">\u2192 ' + new Date(r.completedAt).toLocaleString() + '</span>' : '') +
+      '</div>';
+    });
+  }
+
+  html += '</div>';
+
+  document.getElementById('modal-title').textContent = 'Pipeline: ' + p.title;
+  document.getElementById('modal-body').innerHTML = html;
+  document.getElementById('modal').classList.add('open');
+}
+
+async function _triggerPipeline(id, btn) {
+  if (btn) { btn.textContent = 'Starting...'; btn.style.pointerEvents = 'none'; btn.style.opacity = '0.6'; }
+  try {
+    var res = await fetch('/api/pipelines/trigger', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: id }) });
+    var d = await res.json();
+    if (res.ok) { showToast('cmd-toast', 'Pipeline triggered: ' + (d.runId || ''), true); try { closeModal(); } catch {} refresh(); }
+    else { if (btn) { btn.textContent = 'Run Now'; btn.style.pointerEvents = ''; btn.style.opacity = ''; } alert('Failed: ' + (d.error || 'unknown')); }
+  } catch (e) { if (btn) { btn.textContent = 'Run Now'; btn.style.pointerEvents = ''; btn.style.opacity = ''; } alert('Error: ' + e.message); }
+}
+
+async function _togglePipelineEnabled(id, enabled, btn) {
+  if (btn) { btn.textContent = enabled ? 'Enabling...' : 'Disabling...'; btn.style.pointerEvents = 'none'; }
+  try {
+    var res = await fetch('/api/pipelines/update', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: id, enabled: enabled }) });
+    if (res.ok) { showToast('cmd-toast', enabled ? 'Pipeline enabled' : 'Pipeline disabled', true); refresh(); }
+    else { alert('Failed'); }
+  } catch (e) { alert('Error: ' + e.message); }
+  if (btn) { btn.textContent = enabled ? 'Disable' : 'Enable'; btn.style.pointerEvents = ''; }
+}
+
+async function _continuePipeline(id, stageId, btn) {
+  if (btn) { btn.textContent = 'Continuing...'; btn.style.pointerEvents = 'none'; }
+  try {
+    var res = await fetch('/api/pipelines/continue', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: id, stageId: stageId }) });
+    if (res.ok) { showToast('cmd-toast', 'Stage continued', true); openPipelineDetail(id); }
+    else { var d = await res.json().catch(function() { return {}; }); alert('Failed: ' + (d.error || 'unknown')); }
+  } catch (e) { alert('Error: ' + e.message); }
+  if (btn) { btn.textContent = 'Continue'; btn.style.pointerEvents = ''; }
+}
+
+async function _deletePipelineConfirm(id) {
+  if (!confirm('Delete pipeline "' + id + '"?')) return;
+  markDeleted('pipeline:' + id);
+  try { closeModal(); } catch {}
+  try {
+    var res = await fetch('/api/pipelines/delete', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ id: id }) });
+    if (!res.ok) { alert('Delete failed'); refresh(); }
+  } catch (e) { alert('Error: ' + e.message); refresh(); }
+}
+
+function openCreatePipelineModal() {
+  var inputStyle = 'display:block;width:100%;margin-top:4px;padding:6px 8px;background:var(--bg);border:1px solid var(--border);border-radius:var(--radius-sm);color:var(--text);font-size:var(--text-md);font-family:inherit';
+
+  document.getElementById('modal-title').textContent = 'New Pipeline';
+  document.getElementById('modal-body').innerHTML =
+    '<div style="display:flex;flex-direction:column;gap:10px">' +
+      '<label style="color:var(--text);font-size:var(--text-md)">ID<input id="pl-id" style="' + inputStyle + '" placeholder="e.g. daily-audit-cycle"></label>' +
+      '<label style="color:var(--text);font-size:var(--text-md)">Title<input id="pl-title" style="' + inputStyle + '" placeholder="e.g. Daily audit and improvement cycle"></label>' +
+      '<label style="color:var(--text);font-size:var(--text-md)">Trigger (cron, optional)<input id="pl-cron" style="' + inputStyle + '" placeholder="e.g. 0 9 * (9am daily) — leave empty for manual"></label>' +
+      '<label style="color:var(--text);font-size:var(--text-md)">Stages (JSON array)<textarea id="pl-stages" rows="10" style="' + inputStyle + ';resize:vertical;font-family:Consolas,monospace" placeholder=\'[{"id":"audit","type":"task","title":"Audit codebase","taskType":"explore"},{"id":"discuss","type":"meeting","title":"Discuss findings","dependsOn":["audit"],"participants":["all"]}]\'></textarea></label>' +
+      '<div style="display:flex;justify-content:flex-end;gap:8px;margin-top:4px">' +
+        '<button onclick="closeModal()" class="pr-pager-btn">Cancel</button>' +
+        '<button onclick="_submitCreatePipeline()" style="padding:6px 16px;background:var(--blue);color:#fff;border:none;border-radius:var(--radius-sm);cursor:pointer">Create Pipeline</button>' +
+      '</div>' +
+    '</div>';
+  document.getElementById('modal').classList.add('open');
+}
+
+async function _submitCreatePipeline() {
+  var id = document.getElementById('pl-id')?.value?.trim();
+  var title = document.getElementById('pl-title')?.value?.trim();
+  var cron = document.getElementById('pl-cron')?.value?.trim();
+  var stagesRaw = document.getElementById('pl-stages')?.value?.trim();
+  if (!id || !title) { alert('ID and title required'); return; }
+  var stages;
+  try { stages = JSON.parse(stagesRaw); } catch (e) { alert('Invalid JSON in stages: ' + e.message); return; }
+  if (!Array.isArray(stages) || stages.length === 0) { alert('Stages must be a non-empty array'); return; }
+
+  var body = { id: id, title: title, stages: stages };
+  if (cron) body.trigger = { cron: cron };
+
+  try { closeModal(); } catch {}
+  showToast('cmd-toast', 'Pipeline created', true);
+  try {
+    var res = await fetch('/api/pipelines', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+    if (res.ok) { refresh(); } else { var d = await res.json().catch(function() { return {}; }); alert('Failed: ' + (d.error || 'unknown')); openCreatePipelineModal(); }
+  } catch (e) { alert('Error: ' + e.message); openCreatePipelineModal(); }
+}
+
+window.MinionsPipelines = { renderPipelines, openPipelineDetail, openCreatePipelineModal };

package/dashboard/layout.html

@@ -64,6 +64,7 @@
     <a class="sidebar-link" data-page="inbox" href="/inbox">Notes & KB</a>
     <a class="sidebar-link" data-page="tools" href="/tools">Skills & MCP</a>
     <a class="sidebar-link" data-page="schedule" href="/schedule">Schedules</a>
+    <a class="sidebar-link" data-page="pipelines" href="/pipelines">Pipelines</a>
     <a class="sidebar-link" data-page="meetings" href="/meetings">Meetings</a>
     <a class="sidebar-link" data-page="engine" href="/engine">Engine</a>
   </nav>

package/dashboard/pages/pipelines.html

@@ -0,0 +1,6 @@
+<section>
+  <h2>Pipelines <span class="count" id="pipelines-count">0</span>
+    <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-left:8px" onclick="openCreatePipelineModal()">+ New Pipeline</button>
+  </h2>
+  <div id="pipelines-content"><p class="empty">No pipelines yet. Create one to chain stages like audit → meeting → plan → merge.</p></div>
+</section>

package/dashboard.js

@@ -68,7 +68,7 @@ function buildDashboardHtml() {
   const css = safeRead(path.join(dashDir, 'styles.css'));
 
   // Assemble page fragments
-  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'meetings', 'engine'];
+  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'pipelines', 'meetings', 'engine'];
   let pageHtml = '';
   for (const p of pages) {
     const content = safeRead(path.join(dashDir, 'pages', p + '.html'));
@@ -81,7 +81,7 @@ function buildDashboardHtml() {
     'utils', 'state', 'detail-panel', 'live-stream',
     'render-agents', 'render-dispatch', 'render-work-items', 'render-prd',
     'render-prs', 'render-plans', 'render-inbox', 'render-kb', 'render-skills',
-    'render-other', 'render-schedules', 'render-meetings', 'render-pinned',
+    'render-other', 'render-schedules', 'render-pipelines', 'render-meetings', 'render-pinned',
     'command-parser', 'command-input', 'command-center', 'command-history',
     'modal', 'modal-qa', 'settings', 'refresh'
   ];
@@ -237,6 +237,7 @@ function getStatus() {
       return scheds.map(s => ({ ...s, _lastRun: runs[s.id] || null }));
     })(),
     meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
+    pipelines: (() => { try { const pl = require('./engine/pipeline'); return pl.getPipelines().map(p => ({ ...p, runs: (pl.getPipelineRuns()[p.id] || []).slice(-5) })); } catch { return []; } })(),
     pinned: (() => { try { return parsePinnedEntries(safeRead(path.join(MINIONS_DIR, 'pinned.md'))); } catch { return []; } })(),
     projects: PROJECTS.map(p => ({ name: p.name, path: p.localPath, description: p.description || '' })),
     autoMode: {
@@ -3421,6 +3422,69 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/schedules/update', desc: 'Update an existing schedule', params: 'id, cron?, title?, type?, project?, agent?, description?, priority?, enabled?', handler: handleSchedulesUpdate },
     { method: 'POST', path: '/api/schedules/delete', desc: 'Delete a schedule', params: 'id', handler: handleSchedulesDelete },
 
+    // Pipelines
+    { method: 'GET', path: '/api/pipelines', desc: 'List all pipelines with runs', handler: async (req, res) => {
+      const { getPipelines, getPipelineRuns } = require('./engine/pipeline');
+      const pipelines = getPipelines();
+      const runs = getPipelineRuns();
+      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?', 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 };
+      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?', 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');
+      const pipeline = getPipeline(body.id);
+      if (!pipeline) return jsonReply(res, 404, { error: 'Pipeline not found' });
+      if (body.title !== undefined) pipeline.title = body.title;
+      if (body.stages !== undefined) pipeline.stages = body.stages;
+      if (body.trigger !== undefined) pipeline.trigger = body.trigger;
+      if (body.enabled !== undefined) pipeline.enabled = body.enabled;
+      savePipeline(pipeline);
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true });
+    }},
+    { method: 'POST', path: '/api/pipelines/delete', desc: 'Delete a pipeline', params: 'id', handler: async (req, res) => {
+      const body = await readBody(req);
+      if (!body.id) return jsonReply(res, 400, { error: 'id required' });
+      const { deletePipeline } = require('./engine/pipeline');
+      if (!deletePipeline(body.id)) return jsonReply(res, 404, { error: 'Pipeline not found' });
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true });
+    }},
+    { method: 'POST', path: '/api/pipelines/trigger', desc: 'Manually trigger a pipeline run', params: 'id', handler: async (req, res) => {
+      const body = await readBody(req);
+      if (!body.id) return jsonReply(res, 400, { error: 'id required' });
+      const { getPipeline, getActiveRun, startRun } = require('./engine/pipeline');
+      const pipeline = getPipeline(body.id);
+      if (!pipeline) return jsonReply(res, 404, { error: 'Pipeline not found' });
+      if (getActiveRun(body.id)) return jsonReply(res, 409, { error: 'Pipeline already has an active run' });
+      const run = startRun(body.id, pipeline);
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, runId: run.runId });
+    }},
+    { method: 'POST', path: '/api/pipelines/continue', desc: 'Continue a pipeline past a wait stage', params: 'id, stageId', handler: async (req, res) => {
+      const body = await readBody(req);
+      if (!body.id || !body.stageId) return jsonReply(res, 400, { error: 'id and stageId required' });
+      const { updateRunStage, getActiveRun } = require('./engine/pipeline');
+      const run = getActiveRun(body.id);
+      if (!run) return jsonReply(res, 404, { error: 'No active run' });
+      if (run.stages[body.stageId]?.status !== 'waiting-human') return jsonReply(res, 400, { error: 'Stage is not waiting for human' });
+      updateRunStage(body.id, run.runId, body.stageId, { status: 'completed', completedAt: new Date().toISOString() });
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true });
+    }},
+
     // Meetings
     { method: 'POST', path: '/api/meetings', desc: 'Create a team meeting', params: 'title, agenda, participants[]', handler: async (req, res) => {
       const body = await readBody(req);

package/engine/ado.js

@@ -29,7 +29,7 @@ function getAdoToken() {
   try {
     // azureauth supports multiple --mode flags as an ordered fallback chain:
     // tries IWA (Integrated Windows Auth) first, falls back to broker if unavailable.
-    const token = exec('azureauth ado token --mode iwa --mode broker --output token --timeout 1', {
+    const token = exec('azureauth ado token --mode broker --mode iwa --output token --timeout 5', {
       timeout: 15000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true    }).trim();
     if (token && token.startsWith('eyJ')) {
       _adoTokenCache = { token, expiresAt: Date.now() + 30 * 60 * 1000 };

package/engine/pipeline.js

@@ -0,0 +1,569 @@
+/**
+ * engine/pipeline.js — Multi-stage pipeline orchestration.
+ * Pipelines chain stages (task, meeting, plan, merge-prs, api, wait, parallel)
+ * with dependency tracking and artifact discovery.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const shared = require('./shared');
+const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked } = shared;
+const { parseCronExpr, shouldRunNow } = require('./scheduler');
+
+const PIPELINES_DIR = path.join(__dirname, '..', 'pipelines');
+const PIPELINE_RUNS_PATH = path.join(__dirname, 'pipeline-runs.json');
+
+// ── Pipeline CRUD ────────────────────────────────────────────────────────────
+
+function getPipelines() {
+  if (!fs.existsSync(PIPELINES_DIR)) return [];
+  return safeReadDir(PIPELINES_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => safeJson(path.join(PIPELINES_DIR, f)))
+    .filter(Boolean);
+}
+
+function getPipeline(id) {
+  const filePath = path.join(PIPELINES_DIR, id + '.json');
+  return safeJson(filePath);
+}
+
+function savePipeline(pipeline) {
+  if (!fs.existsSync(PIPELINES_DIR)) fs.mkdirSync(PIPELINES_DIR, { recursive: true });
+  safeWrite(path.join(PIPELINES_DIR, pipeline.id + '.json'), pipeline);
+}
+
+function deletePipeline(id) {
+  const filePath = path.join(PIPELINES_DIR, id + '.json');
+  if (!fs.existsSync(filePath)) return false;
+  fs.unlinkSync(filePath);
+  return true;
+}
+
+// ── Run State ────────────────────────────────────────────────────────────────
+
+function getPipelineRuns() {
+  return safeJson(PIPELINE_RUNS_PATH) || {};
+}
+
+function savePipelineRuns(runs) {
+  safeWrite(PIPELINE_RUNS_PATH, runs);
+}
+
+function getActiveRun(pipelineId) {
+  const runs = getPipelineRuns();
+  const pipelineRuns = runs[pipelineId] || [];
+  return pipelineRuns.find(r => r.status === 'running' || r.status === 'paused');
+}
+
+function startRun(pipelineId, pipeline) {
+  const runId = `run-${uid()}`;
+  const stages = {};
+  for (const stage of (pipeline.stages || [])) {
+    stages[stage.id] = { status: 'pending', artifacts: {} };
+  }
+  const run = { runId, pipelineId, startedAt: ts(), status: 'running', stages };
+
+  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+    if (!data[pipelineId]) data[pipelineId] = [];
+    // Keep last 10 runs per pipeline
+    if (data[pipelineId].length >= 10) data[pipelineId] = data[pipelineId].slice(-9);
+    data[pipelineId].push(run);
+    return data;
+  }, { defaultValue: {} });
+
+  log('info', `Pipeline ${pipelineId}: started run ${runId}`);
+  return run;
+}
+
+function updateRunStage(pipelineId, runId, stageId, updates) {
+  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+    const runs = data[pipelineId] || [];
+    const run = runs.find(r => r.runId === runId);
+    if (run && run.stages[stageId]) {
+      Object.assign(run.stages[stageId], updates);
+    }
+    return data;
+  }, { defaultValue: {} });
+}
+
+function completeRun(pipelineId, runId, status) {
+  mutateJsonFileLocked(PIPELINE_RUNS_PATH, (data) => {
+    const runs = data[pipelineId] || [];
+    const run = runs.find(r => r.runId === runId);
+    if (run) { run.status = status; run.completedAt = ts(); }
+    return data;
+  }, { defaultValue: {} });
+  log('info', `Pipeline ${pipelineId}: run ${runId} → ${status}`);
+}
+
+// ── Template Resolution ──────────────────────────────────────────────────────
+
+function resolveTemplate(str, run) {
+  if (!str || typeof str !== 'string') return str;
+  return str.replace(/\{\{stages\.(\w+)\.(\w+)\}\}/g, (_, stageId, field) => {
+    const stage = run?.stages?.[stageId];
+    if (!stage) return '';
+    if (field === 'output') return stage.output || '';
+    if (field === 'artifacts') return JSON.stringify(stage.artifacts || {});
+    return stage[field] || '';
+  });
+}
+
+function resolveStageConfig(stage, run) {
+  const resolved = { ...stage };
+  for (const key of ['title', 'description', 'agenda', 'body']) {
+    if (typeof resolved[key] === 'string') resolved[key] = resolveTemplate(resolved[key], run);
+    if (typeof resolved[key] === 'object' && resolved[key]) {
+      for (const k of Object.keys(resolved[key])) {
+        if (typeof resolved[key][k] === 'string') resolved[key][k] = resolveTemplate(resolved[key][k], run);
+      }
+    }
+  }
+  return resolved;
+}
+
+// ── Stage Execution ──────────────────────────────────────────────────────────
+
+function executeStage(stage, run, pipeline, config) {
+  const resolved = resolveStageConfig(stage, run);
+  const stageState = run.stages[stage.id];
+
+  switch (resolved.type) {
+    case 'task':
+      return executeTaskStage(resolved, stageState, run, config);
+    case 'meeting':
+      return executeMeetingStage(resolved, stageState, run, config);
+    case 'plan':
+      return executePlanStage(resolved, stageState, run, config);
+    case 'api':
+      return executeApiStage(resolved, stageState, run);
+    case 'merge-prs':
+      return executeMergePrsStage(resolved, stageState, run, config);
+    case 'schedule':
+      return executeScheduleStage(resolved, stageState, config);
+    case 'wait':
+      // wait stages just sit in waiting-human status until continued via API
+      return { status: 'waiting-human' };
+    case 'parallel':
+      return executeParallelStage(resolved, stageState, run, pipeline, config);
+    default:
+      log('warn', `Pipeline: unknown stage type '${resolved.type}' in stage ${stage.id}`);
+      return { status: 'failed', error: 'unknown stage type' };
+  }
+}
+
+function executeTaskStage(stage, stageState, run, config) {
+  // Create work item(s) for the task
+  const items = stage.items || [{ title: stage.title, description: stage.description || '', type: stage.taskType || 'explore', agent: stage.agent }];
+  const count = stage.count || items.length;
+  const wiPath = path.join(__dirname, '..', 'work-items.json');
+  const workItems = safeJson(wiPath) || [];
+  const createdIds = [];
+
+  for (let i = 0; i < count; i++) {
+    const item = items[i % items.length];
+    const id = `PL-${run.runId.slice(4, 12)}-${stage.id}-${i}`;
+    if (workItems.some(w => w.id === id)) { createdIds.push(id); continue; }
+    workItems.push({
+      id,
+      title: item.title || stage.title,
+      description: item.description || stage.description || '',
+      type: item.type || stage.taskType || 'implement',
+      priority: item.priority || stage.priority || 'medium',
+      agent: item.agent || stage.agent || '',
+      status: 'pending',
+      created: ts(),
+      createdBy: 'pipeline:' + run.pipelineId,
+      _pipelineRun: run.runId,
+      _pipelineStage: stage.id,
+    });
+    createdIds.push(id);
+  }
+
+  safeWrite(wiPath, workItems);
+  return { status: 'running', artifacts: { workItems: createdIds } };
+}
+
+function executeMeetingStage(stage, stageState, run, config) {
+  const { createMeeting } = require('./meeting');
+  const agents = config.agents || {};
+  const participants = stage.participants?.[0] === 'all'
+    ? Object.keys(agents)
+    : (stage.participants || Object.keys(agents));
+
+  const meetings = stage.meetings || [{ title: stage.title, agenda: stage.agenda || stage.title }];
+  const createdIds = [];
+
+  for (const mtg of meetings) {
+    const meeting = createMeeting({
+      title: resolveTemplate(mtg.title, run),
+      agenda: resolveTemplate(mtg.agenda || mtg.title, run),
+      participants,
+    });
+    createdIds.push(meeting.id);
+  }
+
+  return { status: 'running', artifacts: { meetings: createdIds } };
+}
+
+function executePlanStage(stage, stageState, run, config) {
+  // Create a plan .md file from the stage config + previous stage output
+  const plansDir = path.join(__dirname, '..', 'plans');
+  if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
+
+  const slug = (stage.title || 'pipeline-plan').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50);
+  const filename = `${slug}-${dateStamp()}.md`;
+  const filePath = shared.uniquePath(path.join(plansDir, filename));
+
+  let content = `# ${stage.title}\n\n`;
+  content += `**Created by:** Pipeline ${run.pipelineId}\n`;
+  content += `**Date:** ${dateStamp()}\n\n---\n\n`;
+
+  // Include output from dependency stages
+  if (stage.dependsOn) {
+    for (const depId of stage.dependsOn) {
+      const depStage = run.stages[depId];
+      if (depStage?.output) {
+        content += `## From: ${depId}\n\n${depStage.output}\n\n`;
+      }
+    }
+  }
+
+  if (stage.description) content += stage.description + '\n';
+
+  safeWrite(filePath, content);
+
+  // Create plan-to-prd work item
+  const wiPath = path.join(__dirname, '..', 'work-items.json');
+  const workItems = safeJson(wiPath) || [];
+  const wiId = `PL-${run.runId.slice(4, 12)}-${stage.id}-prd`;
+  if (!workItems.some(w => w.id === wiId)) {
+    workItems.push({
+      id: wiId,
+      title: `Convert plan to PRD: ${path.basename(filePath)}`,
+      type: 'plan-to-prd',
+      priority: 'high',
+      status: 'pending',
+      planFile: path.basename(filePath),
+      created: ts(),
+      createdBy: 'pipeline:' + run.pipelineId,
+      _pipelineRun: run.runId,
+      _pipelineStage: stage.id,
+    });
+    safeWrite(wiPath, workItems);
+  }
+
+  return {
+    status: 'running',
+    artifacts: {
+      plans: [path.basename(filePath)],
+      workItems: [wiId],
+      prds: [], // discovered later when PRD materializes
+      prs: [],  // discovered later when agents create PRs
+    }
+  };
+}
+
+function executeApiStage(stage, stageState, run) {
+  const calls = stage.calls || [{ endpoint: stage.endpoint, method: stage.method || 'POST', body: stage.body }];
+  for (const call of calls) {
+    const url = `http://localhost:${process.env.MINIONS_PORT || 7331}${call.endpoint}`;
+    const body = typeof call.body === 'string' ? call.body : JSON.stringify(call.body || {});
+    // Fire and forget — use Node's http module
+    try {
+      const http = require('http');
+      const parsed = new URL(url);
+      const req = http.request({
+        hostname: parsed.hostname, port: parsed.port, path: parsed.pathname,
+        method: call.method || 'POST',
+        headers: { 'Content-Type': 'application/json' },
+      });
+      req.write(body);
+      req.end();
+    } catch (e) { log('warn', `Pipeline API call failed: ${e.message}`); }
+  }
+  return { status: 'completed', completedAt: ts() };
+}
+
+function executeMergePrsStage(stage, stageState, run, config) {
+  // Collect all PR IDs from all previous stages in this run
+  const prIds = [];
+  for (const [, s] of Object.entries(run.stages)) {
+    if (s.artifacts?.prs) prIds.push(...s.artifacts.prs);
+  }
+  if (prIds.length === 0) {
+    return { status: 'completed', completedAt: ts(), output: 'No PRs to merge' };
+  }
+  // The actual merge will be handled by the PR polling/merge logic
+  // We just need to track which PRs to watch
+  return { status: 'running', artifacts: { prs: prIds } };
+}
+
+function executeScheduleStage(stage, stageState, config) {
+  // Create/update schedules in config
+  const schedules = stage.schedules || [{ id: stage.id + '-sched', cron: stage.cron, title: stage.title, type: stage.taskType || 'implement' }];
+  // Write to config via shared
+  for (const sched of schedules) {
+    const existing = (config.schedules || []).find(s => s.id === sched.id);
+    if (!existing) {
+      config.schedules = config.schedules || [];
+      config.schedules.push({ ...sched, enabled: true });
+    }
+  }
+  safeWrite(path.join(__dirname, '..', 'config.json'), config);
+  return { status: 'completed', completedAt: ts() };
+}
+
+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') {
+      const result = 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) } };
+}
+
+// ── 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;
+
+  const artifacts = stageState.artifacts || {};
+
+  switch (stage.type) {
+    case 'task': {
+      const wiPath = path.join(__dirname, '..', 'work-items.json');
+      const workItems = safeJson(wiPath) || [];
+      const ids = artifacts.workItems || [];
+      if (ids.length === 0) return false;
+      return ids.every(id => {
+        const wi = workItems.find(w => w.id === id);
+        return wi && (wi.status === 'done' || wi.status === 'failed');
+      });
+    }
+    case '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');
+      });
+    }
+    case 'plan': {
+      // Plan stage completion: PRD conversion done + all materialized work items done
+      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];
+
+      // Check if plan-to-prd work item is done
+      const prdWiIds = artifacts.workItems || [];
+      const prdDone = prdWiIds.every(id => {
+        const wi = all.find(w => w.id === id);
+        return wi && wi.status === 'done';
+      });
+      if (!prdDone) return false;
+
+      // Discover PRDs and their work items
+      const prdDir = path.join(__dirname, '..', 'prd');
+      const plans = artifacts.plans || [];
+      for (const planFile of plans) {
+        const prdFiles = fs.existsSync(prdDir) ? safeReadDir(prdDir).filter(f => f.endsWith('.json')) : [];
+        for (const pf of prdFiles) {
+          const prd = safeJson(path.join(prdDir, pf));
+          if (prd?.source_plan === planFile && !(artifacts.prds || []).includes(pf)) {
+            artifacts.prds = artifacts.prds || [];
+            artifacts.prds.push(pf);
+          }
+        }
+        // Find materialized work items for discovered PRDs
+        for (const prdFile of (artifacts.prds || [])) {
+          const prdItems = all.filter(w => w.sourcePlan === prdFile && w.type !== 'plan-to-prd');
+          for (const wi of prdItems) {
+            if (!(artifacts.workItems || []).includes(wi.id)) {
+              artifacts.workItems = artifacts.workItems || [];
+              artifacts.workItems.push(wi.id);
+            }
+          }
+        }
+      }
+
+      // Auto-approve if configured
+      if (stage.autoApprove && artifacts.prds?.length > 0) {
+        for (const prdFile of artifacts.prds) {
+          const prdPath = path.join(prdDir, prdFile);
+          const prd = safeJson(prdPath);
+          if (prd && prd.status === 'awaiting-approval') {
+            prd.status = 'approved';
+            prd.approvedAt = ts();
+            prd.approvedBy = 'pipeline:' + run.pipelineId;
+            safeWrite(prdPath, prd);
+            log('info', `Pipeline ${run.pipelineId}: auto-approved PRD ${prdFile}`);
+          }
+        }
+      }
+
+      // Check all materialized implement items are done
+      const implementIds = (artifacts.workItems || []).filter(id => !prdWiIds.includes(id));
+      if (implementIds.length === 0 && artifacts.prds?.length > 0) return false; // items not materialized yet
+      return implementIds.every(id => {
+        const wi = all.find(w => w.id === id);
+        return wi && (wi.status === 'done' || wi.status === 'failed');
+      });
+    }
+    case 'merge-prs': {
+      const prIds = artifacts.prs || [];
+      if (prIds.length === 0) return true; // nothing to merge
+      const projects = shared.getProjects(config);
+      for (const project of projects) {
+        const prs = safeJson(shared.projectPrPath(project)) || [];
+        for (const prId of prIds) {
+          const pr = prs.find(p => p.id === prId);
+          if (pr && pr.status !== 'merged' && pr.status !== 'abandoned') return false;
+        }
+      }
+      return true;
+    }
+    case 'api':
+    case 'schedule':
+      return true; // fire-and-forget
+    case 'wait':
+      return stageState.status === 'completed';
+    case 'parallel': {
+      const subIds = artifacts.subStages || [];
+      return subIds.every(id => {
+        const sub = run.stages[id];
+        return sub && (sub.status === 'completed' || sub.status === 'failed');
+      });
+    }
+    default:
+      return false;
+  }
+}
+
+// ── Discovery (called per tick) ──────────────────────────────────────────────
+
+function discoverPipelineWork(config) {
+  const pipelines = getPipelines();
+  if (pipelines.length === 0) return;
+
+  const now = new Date();
+
+  for (const pipeline of pipelines) {
+    if (pipeline.enabled === false) continue;
+
+    // Check for active run
+    let activeRun = getActiveRun(pipeline.id);
+
+    // Cron trigger: start new run if no active run
+    if (!activeRun && pipeline.trigger?.cron) {
+      try {
+        const lastRuns = (getPipelineRuns()[pipeline.id] || []);
+        const lastRun = lastRuns[lastRuns.length - 1];
+        const lastRunAt = lastRun?.startedAt ? new Date(lastRun.startedAt) : null;
+        if (shouldRunNow({ cron: pipeline.trigger.cron }, lastRunAt)) {
+          activeRun = startRun(pipeline.id, pipeline);
+        }
+      } catch (e) { log('warn', `Pipeline cron check failed for ${pipeline.id}: ${e.message}`); }
+    }
+
+    if (!activeRun) continue;
+
+    // Process active run — check stage completions and start ready stages
+    let anyRunning = false;
+    let anyFailed = false;
+    let allComplete = true;
+    const stages = pipeline.stages || [];
+
+    for (const stage of stages) {
+      const stageState = activeRun.stages[stage.id];
+      if (!stageState) continue;
+
+      // Check if running stage completed
+      if (stageState.status === 'running') {
+        if (isStageComplete(stage, stageState, activeRun, config)) {
+          // Collect output
+          let output = '';
+          if (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') {
+            const { getMeeting } = require('./meeting');
+            output = (stageState.artifacts?.meetings || []).map(id => {
+              const m = getMeeting(id);
+              return m?.conclusion?.content || '';
+            }).join('\n\n');
+          }
+
+          updateRunStage(pipeline.id, activeRun.runId, stage.id, {
+            status: 'completed', completedAt: ts(), output
+          });
+          stageState.status = 'completed';
+          stageState.output = output;
+          log('info', `Pipeline ${pipeline.id}: stage ${stage.id} completed`);
+        } else {
+          anyRunning = true;
+          allComplete = false;
+        }
+      }
+
+      if (stageState.status === 'waiting-human') { allComplete = false; continue; }
+
+      // Check if pending stage is ready to start
+      if (stageState.status === 'pending') {
+        allComplete = false;
+        const depsReady = (stage.dependsOn || []).every(depId => {
+          const dep = activeRun.stages[depId];
+          return dep && dep.status === 'completed';
+        });
+        const depsFailed = (stage.dependsOn || []).some(depId => {
+          const dep = activeRun.stages[depId];
+          return dep && dep.status === 'failed';
+        });
+
+        if (depsFailed) {
+          updateRunStage(pipeline.id, activeRun.runId, stage.id, { status: 'failed', error: 'dependency failed' });
+          stageState.status = 'failed';
+          anyFailed = true;
+        } else if (depsReady) {
+          const result = 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;
+          log('info', `Pipeline ${pipeline.id}: started stage ${stage.id} (${stage.type})`);
+        }
+      }
+
+      if (stageState.status === 'failed') anyFailed = true;
+      if (stageState.status !== 'completed') allComplete = false;
+    }
+
+    // Check if run is done
+    if (allComplete) {
+      completeRun(pipeline.id, activeRun.runId, 'completed');
+    } else if (anyFailed && !anyRunning) {
+      completeRun(pipeline.id, activeRun.runId, 'failed');
+    }
+  }
+}
+
+module.exports = {
+  PIPELINES_DIR,
+  getPipelines, getPipeline, savePipeline, deletePipeline,
+  getPipelineRuns, getActiveRun, startRun, updateRunStage, completeRun,
+  discoverPipelineWork,
+};

package/engine.js

@@ -1985,6 +1985,12 @@ function discoverWork(config) {
     allWorkItems.push(...meetingWork);
   } catch (e) { log('warn', 'discover meeting work: ' + e.message); }
 
+  // Pipeline orchestration — check stage completions and start ready stages
+  try {
+    const { discoverPipelineWork } = require('./engine/pipeline');
+    discoverPipelineWork(config);
+  } catch (e) { log('warn', 'discover pipeline work: ' + e.message); }
+
   // Periodic plan completion sweep — catch PRDs that completed while engine was down
   // or where checkPlanCompletion missed the completion event
   // Throttled to every 10 ticks (~5 min) to reduce call volume (P3 decision)

package/package.json

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