@yemi33/minions 0.1.1965 → 0.1.1967

package/bin/minions.js

@@ -169,13 +169,13 @@ function killMinionsProcesses(patterns) {
 }
 
 /** Open append-mode FDs under engine/ for detached-process stdio. If the file
- *  can't be opened we fall back to 'ignore' rather than blocking the restart. */
+ *  can't be opened we fall back to 'ignore' rather than blocking the restart.
+ *  Delegates to shared.openAppendLogFd (P-8a4d6f29) so the rotation behavior
+ *  (rename to .1 when current file exceeds the managed-spawn log cap) is
+ *  uniform across every long-running log Minions writes. */
 function _openStdioLog(name) {
-  try {
-    const dir = path.join(MINIONS_HOME, 'engine');
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    return fs.openSync(path.join(dir, name), 'a');
-  } catch { return 'ignore'; }
+  const dir = path.join(MINIONS_HOME, 'engine');
+  return shared.openAppendLogFd(name, dir, { fallback: 'ignore' }).fd;
 }
 
 /** Spawn a detached dashboard with self-open suppressed — the CLI decides

package/dashboard/js/refresh.js

@@ -107,6 +107,11 @@ function _processStatusUpdate(data) {
   if (typeof renderKeepProcesses === 'function') {
     try { renderKeepProcesses(); } catch {}
   }
+  // managed-processes panel — same engine-page-only pattern, ETag-gated so
+  // unchanged ticks return 304 with no body (P-6e2a8b13).
+  if (typeof renderManagedProcesses === 'function') {
+    try { renderManagedProcesses(); } catch {}
+  }
   if (_changed('workItems', data.workItems)) renderWorkItems(data.workItems || []);
   if (_changed('skills', data.skills)) renderSkills(data.skills || []);
   if (_changed('mcpServers', data.mcpServers)) renderMcpServers(data.mcpServers || []);

package/dashboard/js/render-managed.js

@@ -0,0 +1,261 @@
+// dashboard/js/render-managed.js — Live managed-processes panel + log viewer modal.
+// P-6e2a8b13 (plan W-mp7k1r760003b5dd item 5).
+//
+// Polls /api/managed-processes with If-None-Match every refresh tick on the
+// engine page (cheap: server returns 304 when nothing changed). Renders one
+// project-grouped table per owner_project with name/pid/healthy/ports/attrs/
+// uptime/TTL + per-row kill, restart, log buttons.
+//
+// Log button opens a self-contained modal overlay that streams the spec's
+// log_path via SSE EventSource (`/api/managed-processes/log-stream/<name>`).
+// One stream at a time — closing the modal aborts the EventSource so we
+// don't blow through HTTP/1.1 connection slots (cf. live-stream.js note
+// about why the agent live tab moved off SSE).
+
+let _managedProcessesEtag = null;
+let _managedLogES = null;
+
+function _fmtAgo(ms) {
+  if (!ms || ms < 0) return '0s';
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return s + 's';
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + 'm';
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + 'h ' + (m % 60) + 'm';
+  const d = Math.floor(h / 24);
+  return d + 'd ' + (h % 24) + 'h';
+}
+
+function _fmtAttrs(attrs) {
+  if (!attrs || typeof attrs !== 'object') return '';
+  const parts = [];
+  for (const k of Object.keys(attrs)) {
+    const v = attrs[k];
+    if (v == null) continue;
+    const s = (typeof v === 'object') ? JSON.stringify(v) : String(v);
+    // Compact: clip individual values, keep the panel scannable.
+    parts.push(escHtml(k) + '=' + escHtml(s.length > 40 ? s.slice(0, 37) + '...' : s));
+  }
+  return parts.join(' ');
+}
+
+function _renderManagedTable(items) {
+  const rows = items.map(function (s) {
+    const healthBadge = s.healthy
+      ? '<span style="color:var(--green)">●</span> healthy'
+      : (s.alive ? '<span style="color:var(--yellow)">●</span> starting' : '<span style="color:var(--muted)">○</span> down');
+    const ports = (s.ports && s.ports.length) ? s.ports.join(',') : '';
+    const uptime = s.started_at ? _fmtAgo(Date.now() - s.started_at) : '';
+    const ttl = s.ttl_expires_at ? _fmtAgo(s.ttl_expires_at - Date.now()) : '';
+    const ttlColor = (s.ttl_expires_at && s.ttl_expires_at - Date.now() < 5 * 60 * 1000) ? 'var(--yellow)' : 'var(--muted)';
+    const nameAttr = encodeURIComponent(s.name || '');
+    return '<tr>' +
+      '<td style="padding:4px 8px;font-family:monospace;font-size:11px">' + escHtml(s.name || '') + '</td>' +
+      '<td style="padding:4px 8px;font-family:monospace;font-size:11px">' + (s.pid || '') + '</td>' +
+      '<td style="padding:4px 8px;font-size:11px">' + healthBadge + '</td>' +
+      '<td style="padding:4px 8px;font-size:11px;font-family:monospace">' + escHtml(ports) + '</td>' +
+      '<td style="padding:4px 8px;font-size:10px;color:var(--muted);max-width:280px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="' + escHtml(_fmtAttrs(s.attrs).replace(/<[^>]+>/g, '')) + '">' + _fmtAttrs(s.attrs) + '</td>' +
+      '<td style="padding:4px 8px;font-size:11px;color:var(--muted)">' + escHtml(uptime) + '</td>' +
+      '<td style="padding:4px 8px;font-size:11px;color:' + ttlColor + '">' + escHtml(ttl) + '</td>' +
+      '<td style="padding:4px 8px;text-align:right;white-space:nowrap">' +
+        '<button onclick="openManagedLog(decodeURIComponent(\'' + nameAttr + '\'))" style="font-size:10px;padding:2px 6px;margin-right:4px;border:1px solid var(--border);background:var(--surface);color:var(--fg);border-radius:3px;cursor:pointer">Log</button>' +
+        '<button onclick="restartManagedSpec(decodeURIComponent(\'' + nameAttr + '\'))" style="font-size:10px;padding:2px 6px;margin-right:4px;border:1px solid var(--blue);background:transparent;color:var(--blue);border-radius:3px;cursor:pointer">Restart</button>' +
+        '<button onclick="killManagedSpec(decodeURIComponent(\'' + nameAttr + '\'))" style="font-size:10px;padding:2px 6px;border:1px solid var(--red);background:transparent;color:var(--red);border-radius:3px;cursor:pointer">Kill</button>' +
+      '</td>' +
+      '</tr>';
+  }).join('');
+  return '<table style="width:100%;border-collapse:collapse;margin-bottom:8px">' +
+    '<thead><tr style="text-align:left;font-size:10px;color:var(--muted);text-transform:uppercase">' +
+      '<th style="padding:4px 8px">name</th>' +
+      '<th style="padding:4px 8px">pid</th>' +
+      '<th style="padding:4px 8px">health</th>' +
+      '<th style="padding:4px 8px">ports</th>' +
+      '<th style="padding:4px 8px">attrs</th>' +
+      '<th style="padding:4px 8px">uptime</th>' +
+      '<th style="padding:4px 8px">ttl</th>' +
+      '<th style="padding:4px 8px;text-align:right">actions</th>' +
+    '</tr></thead><tbody>' + rows + '</tbody></table>';
+}
+
+async function renderManagedProcesses() {
+  const root = document.getElementById('managed-processes-content');
+  const countEl = document.getElementById('managed-processes-count');
+  if (!root) return;
+  let items;
+  let fetchErr = null;
+  let notModified = false;
+  try {
+    const headers = {};
+    if (_managedProcessesEtag) headers['If-None-Match'] = _managedProcessesEtag;
+    const res = await fetch('/api/managed-processes', { headers });
+    if (res.status === 304) {
+      notModified = true;
+    } else {
+      const et = res.headers.get('ETag');
+      if (et) _managedProcessesEtag = et;
+      const data = await res.json();
+      items = (data && Array.isArray(data.items)) ? data.items : [];
+    }
+  } catch (e) {
+    fetchErr = e;
+  }
+  if (notModified) return; // nothing changed since last render
+  let html;
+  if (fetchErr) {
+    if (countEl) countEl.textContent = '?';
+    html = '<span style="color:var(--red)">Failed to load: ' + escHtml(fetchErr.message) + '</span>';
+  } else if (!items || !items.length) {
+    if (countEl) countEl.textContent = '0';
+    html = '<p class="empty">No managed processes. Agents declare them via <code>agents/&lt;id&gt;/managed-spawn.json</code>.</p>';
+  } else {
+    if (countEl) countEl.textContent = String(items.length);
+    // Group by owner_project (empty/missing groups under "(unassigned)").
+    const groups = {};
+    for (const s of items) {
+      const key = s.owner_project || '(unassigned)';
+      (groups[key] = groups[key] || []).push(s);
+    }
+    const names = Object.keys(groups).sort();
+    html = names.map(function (proj) {
+      const group = groups[proj];
+      group.sort(function (a, b) { return (a.name || '').localeCompare(b.name || ''); });
+      return '<div style="border:1px solid var(--border);border-radius:4px;padding:8px;margin-bottom:8px;background:var(--surface2)">' +
+        '<div style="font-weight:600;font-size:11px;margin-bottom:6px">' + escHtml(proj) +
+          ' <span style="color:var(--muted);font-weight:400">(' + group.length + ')</span>' +
+        '</div>' +
+        _renderManagedTable(group) +
+      '</div>';
+    }).join('');
+  }
+  // DocumentFragment instead of innerHTML — keeps the file out of the
+  // dynamic-innerHTML regression gate (cf. render-other.js renderKeepProcesses).
+  const range = document.createRange();
+  const frag = range.createContextualFragment(html);
+  root.replaceChildren(frag);
+}
+
+async function killManagedSpec(name) {
+  if (!confirm('Kill managed process "' + name + '"? PID will be terminated and the spec removed from engine state.')) return;
+  try {
+    const res = await fetch('/api/managed-processes/kill', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name }),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      alert('Failed: ' + (data.error || res.status));
+      return;
+    }
+    if (typeof showToast === 'function') showToast('cmd-toast', 'Killed ' + name + (data.killed_pid ? ' (PID ' + data.killed_pid + ')' : ''), true);
+  } catch (e) {
+    alert('Network error: ' + e.message);
+  }
+  _managedProcessesEtag = null; // force re-render
+  renderManagedProcesses();
+}
+
+async function restartManagedSpec(name) {
+  if (!confirm('Restart managed process "' + name + '"? The current PID will be killed and a new one spawned from saved state.')) return;
+  try {
+    const res = await fetch('/api/managed-processes/restart', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name }),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      alert('Failed: ' + (data.error || res.status));
+      return;
+    }
+    if (typeof showToast === 'function') showToast('cmd-toast', 'Restarted ' + name + (data.pid ? ' (new PID ' + data.pid + ')' : ''), true);
+  } catch (e) {
+    alert('Network error: ' + e.message);
+  }
+  _managedProcessesEtag = null;
+  renderManagedProcesses();
+}
+
+function _ensureManagedLogModal() {
+  let overlay = document.getElementById('managed-log-modal');
+  if (overlay) return overlay;
+  overlay = document.createElement('div');
+  overlay.id = 'managed-log-modal';
+  overlay.style.cssText = 'display:none;position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.6);z-index:1000;align-items:center;justify-content:center;padding:24px';
+  // Static markup, no user data — use createContextualFragment so we stay
+  // out of the dynamic-innerHTML regression gate (test/unit.test.js DYNAMIC_INNERHTML_BASELINE).
+  const tpl = '' +
+    '<div style="background:var(--bg);border:1px solid var(--border);border-radius:6px;width:100%;max-width:1100px;height:80vh;display:flex;flex-direction:column">' +
+      '<div style="display:flex;align-items:center;padding:8px 12px;border-bottom:1px solid var(--border)">' +
+        '<div id="managed-log-title" style="flex:1;font-weight:600;font-size:12px;font-family:monospace">Managed log</div>' +
+        '<div id="managed-log-status" style="font-size:10px;color:var(--muted);margin-right:12px">connecting...</div>' +
+        '<button id="managed-log-close-btn" style="font-size:10px;padding:4px 10px;border:1px solid var(--border);background:transparent;color:var(--fg);border-radius:3px;cursor:pointer">Close</button>' +
+      '</div>' +
+      '<pre id="managed-log-body" style="flex:1;overflow:auto;margin:0;padding:8px 12px;font-family:monospace;font-size:11px;white-space:pre-wrap;word-break:break-all;background:var(--surface2)"></pre>' +
+    '</div>';
+  const frag = document.createRange().createContextualFragment(tpl);
+  overlay.appendChild(frag);
+  document.body.appendChild(overlay);
+  overlay.addEventListener('click', function (e) {
+    if (e.target === overlay) closeManagedLog();
+  });
+  const closeBtn = overlay.querySelector('#managed-log-close-btn');
+  if (closeBtn) closeBtn.addEventListener('click', closeManagedLog);
+  return overlay;
+}
+
+function openManagedLog(name) {
+  closeManagedLog(); // single-stream invariant
+  const overlay = _ensureManagedLogModal();
+  const title = overlay.querySelector('#managed-log-title');
+  const status = overlay.querySelector('#managed-log-status');
+  const body = overlay.querySelector('#managed-log-body');
+  if (title) title.textContent = 'Log: ' + name;
+  if (body) body.textContent = '';
+  if (status) status.textContent = 'connecting...';
+  overlay.style.display = 'flex';
+
+  try {
+    const es = new EventSource('/api/managed-processes/log-stream/' + encodeURIComponent(name));
+    _managedLogES = es;
+    es.onopen = function () { if (status) status.textContent = 'streaming'; };
+    es.onmessage = function (ev) {
+      let chunk;
+      try { chunk = JSON.parse(ev.data); }
+      catch { chunk = ev.data; }
+      if (typeof chunk !== 'string') chunk = String(chunk);
+      if (!body) return;
+      const wasAtBottom = (body.scrollHeight - body.scrollTop - body.clientHeight) < 40;
+      body.appendChild(document.createTextNode(chunk));
+      if (wasAtBottom) body.scrollTop = body.scrollHeight;
+    };
+    es.addEventListener('done', function (ev) {
+      if (status) status.textContent = 'closed (' + (ev.data || 'done') + ')';
+      try { es.close(); } catch { /* optional */ }
+      if (_managedLogES === es) _managedLogES = null;
+    });
+    es.onerror = function () {
+      if (status) status.textContent = 'disconnected';
+      // EventSource auto-reconnects; if the spec is gone the server will emit
+      // a 'done' event on the next attempt.
+    };
+  } catch (e) {
+    if (status) status.textContent = 'failed: ' + e.message;
+  }
+}
+
+function closeManagedLog() {
+  if (_managedLogES) {
+    try { _managedLogES.close(); } catch { /* optional */ }
+    _managedLogES = null;
+  }
+  const overlay = document.getElementById('managed-log-modal');
+  if (overlay) overlay.style.display = 'none';
+}
+
+window.MinionsManagedProcesses = {
+  renderManagedProcesses,
+  killManagedSpec,
+  restartManagedSpec,
+  openManagedLog,
+  closeManagedLog,
+};

package/dashboard/js/render-other.js

@@ -23,17 +23,20 @@ function renderProjects(projects) {
 
 // Renders the per-project current-branch indicator. Driven by the gitState
 // classifier emitted by getProjectGitStatus() in engine/queries.js.
+// Adds a title attribute carrying the full branch name so users can still
+// read it on hover after the CSS ellipsis-truncate (W-mpayac6d000b7d33).
 function _renderProjectBranch(p) {
   if (!p) return '';
   if (p.gitState === 'missing') return '<span class="project-warn" title="Project localPath does not exist on disk">(path not found)</span>';
   if (p.gitState === 'non-git') return '<span class="project-muted" title="Project path exists but is not a git repository">(not a git repo)</span>';
   if (p.gitState !== 'ok' || !p.gitBranch) return '';
   const branch = escHtml(p.gitBranch);
+  const titleAttr = ' title="on: ' + branch + (p.gitDetached ? ' (detached)' : '') + (p.gitDirty ? ' (dirty)' : '') + '"';
   const dirty = p.gitDirty ? ' <span class="dot-dirty" title="Working tree has uncommitted changes">●</span>' : '';
   if (p.gitDetached) {
-    return '<span class="project-branch">on: ' + branch + ' <span class="muted">(detached)</span>' + dirty + '</span>';
+    return '<span class="project-branch"' + titleAttr + '>on: ' + branch + ' <span class="muted">(detached)</span>' + dirty + '</span>';
   }
-  return '<span class="project-branch">on: ' + branch + dirty + '</span>';
+  return '<span class="project-branch"' + titleAttr + '>on: ' + branch + dirty + '</span>';
 }
 
 function _projectCachePath(project) {

package/dashboard/pages/engine.html

@@ -25,3 +25,9 @@
         </h2>
         <div id="keep-processes-content"><p class="empty">No agents have left processes running. Set <code>meta.keep_processes: true</code> on a work item to enable.</p></div>
       </section>
+      <section id="managed-processes-section">
+        <h2>Managed Processes <span class="count" id="managed-processes-count">0</span>
+          <span style="font-size:10px;color:var(--muted);font-weight:400;text-transform:none;letter-spacing:0">engine-managed long-running services (P-6e2a8b13 — managed-spawn primitive)</span>
+        </h2>
+        <div id="managed-processes-content"><p class="empty">No managed processes. Agents declare them via <code>agents/&lt;id&gt;/managed-spawn.json</code>.</p></div>
+      </section>

package/dashboard/styles.css

@@ -709,9 +709,26 @@
   /* Ensure all tables scroll horizontally on narrow screens */
   .pr-table-wrap, #pr-content, #completed-content, #work-items-content { overflow-x: auto; min-width: 0; }
 
-  /* Project chip — current git branch indicator */
-  .project-branch { font-size: 10px; color: var(--muted); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-weight: 400; }
+  /* Project chip — current git branch indicator.
+   * max-width + ellipsis truncation prevents pathological branch names
+   * (e.g. `pipeline/daily-issue-fix/...`) from widening the inline-flex chip
+   * past the viewport. Full text remains available via the title attribute
+   * added in render-other.js _renderProjectBranch. (W-mpayac6d000b7d33) */
+  .project-branch {
+    font-size: 10px; color: var(--muted); font-weight: 400;
+    font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+    display: inline-block; max-width: 240px; overflow: hidden;
+    text-overflow: ellipsis; white-space: nowrap; vertical-align: bottom;
+  }
   .project-branch .muted { color: var(--muted); }
   .project-branch .dot-dirty { color: var(--yellow); margin-left: 2px; }
-  .project-warn { font-size: 10px; color: var(--yellow); font-style: italic; font-weight: 400; }
-  .project-muted { font-size: 10px; color: var(--muted); font-style: italic; font-weight: 400; }
+  .project-warn {
+    font-size: 10px; color: var(--yellow); font-style: italic; font-weight: 400;
+    display: inline-block; max-width: 240px; overflow: hidden;
+    text-overflow: ellipsis; white-space: nowrap; vertical-align: bottom;
+  }
+  .project-muted {
+    font-size: 10px; color: var(--muted); font-style: italic; font-weight: 400;
+    display: inline-block; max-width: 240px; overflow: hidden;
+    text-overflow: ellipsis; white-space: nowrap; vertical-align: bottom;
+  }

package/dashboard-build.js

@@ -32,7 +32,7 @@ function buildDashboardHtml() {
     'utils', 'state', 'features-client', '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-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
+    'render-other', 'render-managed', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
     'command-parser', 'command-input', 'command-center', 'command-history',
     'modal', 'modal-qa', 'settings', 'refresh'
   ];

package/dashboard.js

@@ -874,7 +874,7 @@ function buildDashboardHtml() {
     'utils', 'state', 'features-client', 'render-utils', '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-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
+    'render-other', 'render-managed', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
     'command-parser', 'command-input', 'command-center', 'command-history',
     'modal', 'modal-qa', 'settings', 'refresh'
   ];
@@ -7901,6 +7901,242 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     }
   }
 
+  // ── Managed processes API (P-4b8d2e57, plan W-mp7k1r760003b5dd item 4) ──
+  // List + by-name + kill + restart for the engine-owned managed-spawn
+  // services (engine/managed-processes.json). Mirrors the keep-processes
+  // pattern above but lives a layer deeper because the state is engine-side
+  // (not per-agent sidecars).
+
+  function _managedSpecToApiShape(rec) {
+    if (!rec || typeof rec !== 'object') return rec;
+    return {
+      name: rec.name,
+      pid: rec.pid,
+      alive: !!rec.alive,
+      healthy: !!rec.healthy,
+      owner_agent: rec.owner_agent || '',
+      owner_wi: rec.owner_wi || '',
+      owner_project: rec.owner_project || '',
+      attrs: rec.attrs || {},
+      ports: Array.isArray(rec.ports) ? rec.ports : [],
+      started_at: rec.started_at,
+      ttl_expires_at: rec.ttl_expires_at,
+      last_health_at: rec.last_health_at,
+      log_path: rec.log_path || '',
+      // Spec body so the dashboard can show what was spawned without an extra
+      // round-trip. attrs is already exposed above.
+      cmd: rec.cmd,
+      args: Array.isArray(rec.args) ? rec.args : [],
+      cwd: rec.cwd || '',
+      healthcheck: rec.healthcheck || null,
+    };
+  }
+
+  function handleManagedProcessesList(req, res) {
+    try {
+      const managedSpawn = require('./engine/managed-spawn');
+      const u = new URL(req.url, 'http://x');
+      const project = (u.searchParams.get('project') || '').trim();
+      const opts = project ? { project } : {};
+      const etag = managedSpawn.computeManagedSpecsEtag(opts);
+      if (req.headers['if-none-match'] === etag) {
+        res.statusCode = 304;
+        res.setHeader('ETag', etag);
+        return res.end();
+      }
+      const items = managedSpawn.listManagedSpecs(opts).map(_managedSpecToApiShape);
+      res.setHeader('ETag', etag);
+      return jsonReply(res, 200, { items, generatedAt: new Date().toISOString() }, req);
+    } catch (e) {
+      return jsonReply(res, 500, { error: e.message }, req);
+    }
+  }
+
+  function handleManagedProcessesByName(req, res) {
+    try {
+      const managedSpawn = require('./engine/managed-spawn');
+      const u = new URL(req.url, 'http://x');
+      const prefix = '/api/managed-processes/by-name/';
+      const name = decodeURIComponent(u.pathname.slice(prefix.length));
+      if (!name) return jsonReply(res, 400, { error: 'name required' }, req);
+      const rec = managedSpawn.listManagedSpecs().find(s => s && s.name === name);
+      if (!rec) return jsonReply(res, 404, { error: `managed spec not found: ${name}` }, req);
+      return jsonReply(res, 200, _managedSpecToApiShape(rec), req);
+    } catch (e) {
+      return jsonReply(res, 500, { error: e.message }, req);
+    }
+  }
+
+  async function handleManagedProcessesKill(req, res) {
+    try {
+      const body = await readBody(req);
+      const name = String(body.name || '').trim();
+      if (!name) return jsonReply(res, 400, { error: 'name required' }, req);
+      const managedSpawn = require('./engine/managed-spawn');
+      const before = managedSpawn.listManagedSpecs().find(s => s && s.name === name);
+      if (!before) return jsonReply(res, 404, { error: `managed spec not found: ${name}` }, req);
+      managedSpawn.removeManagedSpec(name);
+      shared.log('info', `managed-processes manual kill: name=${name} pid=${before.pid}`);
+      return jsonReply(res, 200, { ok: true, name, killed_pid: before.pid }, req);
+    } catch (e) {
+      return jsonReply(res, 500, { error: e.message }, req);
+    }
+  }
+
+  async function handleManagedProcessesRestart(req, res) {
+    try {
+      const body = await readBody(req);
+      const name = String(body.name || '').trim();
+      if (!name) return jsonReply(res, 400, { error: 'name required' }, req);
+      const managedSpawn = require('./engine/managed-spawn');
+      let runtime;
+      try { runtime = managedSpawn.restartManagedSpec(name); }
+      catch (e) {
+        // Distinguish unknown-name (404) from other errors (500).
+        if (/not found/i.test(e.message)) {
+          return jsonReply(res, 404, { error: e.message }, req);
+        }
+        return jsonReply(res, 500, { error: e.message }, req);
+      }
+      // Kick off the healthcheck loop in the background — same shape the
+      // engine close-handler uses (item 3). We DON'T await it here: the
+      // dashboard endpoint returns immediately so the caller isn't blocked
+      // by a potentially-60s timeout_s. The loop self-flips state.healthy.
+      const newSpec = managedSpawn.listManagedSpecs().find(s => s && s.name === name);
+      if (newSpec && newSpec.healthcheck) {
+        managedSpawn.waitForFirstHealth(newSpec).catch((err) => {
+          shared.log('warn', `managed-processes restart: waitForFirstHealth failed for ${name}: ${err.message}`);
+        });
+      }
+      return jsonReply(res, 200, { ok: true, name, pid: runtime.pid, started_at: runtime.started_at, log_path: runtime.log_path }, req);
+    } catch (e) {
+      return jsonReply(res, 500, { error: e.message }, req);
+    }
+  }
+
+  // ── Managed-process log SSE (P-6e2a8b13, plan W-mp7k1r760003b5dd item 5) ──
+  // Tail-and-stream `<log_path>` for a named managed spec. Mirrors
+  // handleAgentLiveStream (line ~4590) — same Origin gate, same fs.watchFile
+  // poll, same safeWrite + idempotent cleanup. Spec lookup goes through
+  // managedSpawn.listManagedSpecs so the log path travels through the same
+  // sanitization layer the API/state-file use (no client-supplied paths).
+  function handleManagedProcessesLogStream(req, res, match) {
+    const _origin = req.headers['origin'];
+    if (_origin && !shared.isAllowedOrigin(_origin)) {
+      console.warn(`[sse-origin-gate] reject GET ${req.url} origin=${_origin}`);
+      res.statusCode = 403;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({ error: 'Origin not allowed' }));
+      return;
+    }
+
+    const name = decodeURIComponent(match[1] || '');
+    let spec = null;
+    try {
+      const managedSpawn = require('./engine/managed-spawn');
+      spec = managedSpawn.listManagedSpecs().find(s => s && s.name === name);
+    } catch { /* missing module or unreadable state — handled below */ }
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    });
+
+    if (!spec) {
+      res.write(`data: ${JSON.stringify('Managed spec not found: ' + name)}\n\n`);
+      res.write(`event: done\ndata: not-found\n\n`);
+      res.end();
+      return;
+    }
+
+    const logPath = spec.log_path || '';
+    if (!logPath || !fs.existsSync(logPath)) {
+      res.write(`data: ${JSON.stringify('Log file not available for ' + name + (logPath ? ' (' + logPath + ')' : ''))}\n\n`);
+      res.write(`event: done\ndata: no-log\n\n`);
+      res.end();
+      return;
+    }
+
+    let _cleanedUp = false;
+    const safeWrite = (data) => {
+      if (_cleanedUp) return;
+      try { res.write(data); } catch { /* EPIPE — client gone */ }
+    };
+
+    // Initial tail (default 64KB, capped by client via ?tail=).
+    const params = new URL(req.url, 'http://localhost').searchParams;
+    const tailBytes = Math.max(0, parseInt(params.get('tail') || '65536', 10) || 65536);
+    let offset = 0;
+    try {
+      const stat = fs.statSync(logPath);
+      if (stat.size > 0) {
+        const readStart = Math.max(0, stat.size - tailBytes);
+        const readLen = stat.size - readStart;
+        const fd = fs.openSync(logPath, 'r');
+        const buf = Buffer.alloc(readLen);
+        fs.readSync(fd, buf, 0, readLen, readStart);
+        fs.closeSync(fd);
+        const content = buf.toString('utf8');
+        if (content) safeWrite(`data: ${JSON.stringify(content)}\n\n`);
+        offset = stat.size;
+      }
+    } catch { /* file may have been rotated/removed between exists and stat */ }
+
+    // Tail-watch for appends. Mirrors handleAgentLiveStream's watchFile loop.
+    const watcher = () => {
+      if (_cleanedUp) return;
+      try {
+        const stat = fs.statSync(logPath);
+        if (stat.size < offset) {
+          // Log was rotated — restart from 0 so the operator sees the new tail.
+          offset = 0;
+        }
+        if (stat.size > offset) {
+          const fd = fs.openSync(logPath, 'r');
+          const buf = Buffer.alloc(stat.size - offset);
+          fs.readSync(fd, buf, 0, buf.length, offset);
+          fs.closeSync(fd);
+          offset = stat.size;
+          const chunk = buf.toString('utf8');
+          if (chunk) safeWrite(`data: ${JSON.stringify(chunk)}\n\n`);
+        }
+      } catch { /* file may have been removed (kill); next doneCheck closes the stream */ }
+    };
+
+    fs.watchFile(logPath, { interval: 500 }, watcher);
+
+    const cleanup = () => {
+      if (_cleanedUp) return;
+      _cleanedUp = true;
+      try { clearInterval(doneCheck); } catch { /* optional */ }
+      try { fs.unwatchFile(logPath, watcher); } catch { /* optional */ }
+    };
+
+    // Close the stream when the spec is removed (killed via API or swept).
+    // Polls every 5s — same cadence handleAgentLiveStream uses for its
+    // "is agent still active?" check.
+    const doneCheck = setInterval(() => {
+      if (_cleanedUp) return;
+      try {
+        const managedSpawn = require('./engine/managed-spawn');
+        const still = managedSpawn.listManagedSpecs().some(s => s && s.name === name);
+        if (!still) {
+          watcher(); // flush final content
+          safeWrite(`event: done\ndata: removed\n\n`);
+          cleanup();
+          try { res.end(); } catch { /* optional */ }
+        }
+      } catch (_e) {
+        cleanup();
+        try { res.end(); } catch { /* optional */ }
+      }
+    }, 5000);
+
+    req.on('close', cleanup);
+    return;
+  }
+
   // ── Route Registry ──────────────────────────────────────────────────────────
   // Order matters: specific routes before general ones (e.g., /api/plans/approve before /api/plans/:file)
 
@@ -7958,6 +8194,19 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: '/api/health', desc: 'Lightweight health check for monitoring', handler: handleHealth },
     { method: 'GET', path: '/api/keep-processes', desc: 'List all active agents/<id>/keep-pids.json entries (W-mp68q6ke0010de68)', handler: handleKeepProcessesList },
     { method: 'POST', path: '/api/keep-processes/kill', desc: 'Kill a single kept PID and remove it from the agent\'s keep-pids.json', params: 'agentId, pid', handler: handleKeepProcessesKill },
+    // P-4b8d2e57 (managed-spawn item 4): engine-managed long-running services.
+    // List/by-name return ETag + honor If-None-Match → 304. Kill removes from
+    // state + kills PID. Restart respawns from saved state and kicks off the
+    // first healthcheck async.
+    { method: 'GET',  path: '/api/managed-processes', desc: 'List engine-managed long-running services (managed-spawn). Optional ?project filter. Sends ETag + honors If-None-Match.', handler: handleManagedProcessesList },
+    { method: 'GET',  path: /^\/api\/managed-processes\/by-name\/([^?]+)$/, template: '/api/managed-processes/by-name/<name>', desc: 'Get a single managed spec by name (managed-spawn).', handler: handleManagedProcessesByName },
+    { method: 'POST', path: '/api/managed-processes/kill', desc: 'Kill a managed spec by name (removes it from state).', params: 'name', handler: handleManagedProcessesKill },
+    { method: 'POST', path: '/api/managed-processes/restart', desc: 'Respawn a managed spec from its saved state and kick off the healthcheck loop. Returns the new PID.', params: 'name', handler: handleManagedProcessesRestart },
+    // P-6e2a8b13 (managed-spawn item 5): SSE tail-and-stream of <log_path>
+    // for the named spec. Mirrors handleAgentLiveStream — Origin gate,
+    // 64KB initial tail, fs.watchFile poll for appends, auto-close when
+    // the spec is removed from state.
+    { method: 'GET', path: /^\/api\/managed-processes\/log-stream\/([^?]+)$/, template: '/api/managed-processes/log-stream/<name>', desc: 'SSE tail-and-stream of <log_path> for a managed spec (managed-spawn). Optional ?tail=N initial-tail-bytes (default 65536).', handler: handleManagedProcessesLogStream },
     { method: 'GET', path: '/api/hot-reload', desc: 'SSE stream for dashboard hot-reload notifications', handler: (req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       res.write('data: connected\n\n');