@yemi33/minions 0.1.2050 → 0.1.2052

package/dashboard/js/detail-panel.js

@@ -97,6 +97,7 @@ function renderDetailContent(detail, tab) {
     // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal server timestamp and static live-chat controls (no user data flows in)
     el.innerHTML =
       '<div id="live-chat" style="display:flex;flex-direction:column;height:60vh">' +
+        '<div id="live-terminal-banner"></div>' +
         '<div id="live-messages" style="flex:1;overflow-y:auto;padding:8px;font-size:11px;line-height:1.6;display:flex;flex-direction:column"></div>' +
         '<div id="live-status-bar" style="padding:4px 8px;display:flex;align-items:center;gap:8px;border-top:1px solid var(--border)">' +
           '<span class="pulse"></span><span id="live-status-label" style="font-size:11px;color:var(--green)">Streaming live</span>' +

package/dashboard/js/live-stream.js

@@ -2,6 +2,7 @@
 
 let livePollingInterval = null;
 let liveEventSource = null;
+let liveTerminalSource = null;
 let _steerInFlight = false;
 let _lastRenderedText = '';
 let _runtimeTimer = null;
@@ -45,13 +46,54 @@ function startLiveStream(agentId) {
   if (msgEl) msgEl.innerHTML = '';
   _lastRenderedText = '';
 
+  // W-mpob4nyk0006580e — clear any stale banner from a previous agent.
+  const bannerEl = document.getElementById('live-terminal-banner');
+  if (bannerEl) bannerEl.innerHTML = '';
+
   // Start runtime counter
   _updateRuntimeCounter();
   _runtimeTimer = setInterval(_updateRuntimeCounter, 1000);
 
-  // Use polling instead of SSE to avoid HTTP/1.1 connection exhaustion
-  // (SSE holds a persistent connection, blocking CC and other API calls)
+  // Use polling for log content (avoids HTTP/1.1 connection exhaustion that
+  // a full SSE log stream would cause — see W-mpob4nyk0006580e note below).
   startLivePolling();
+
+  // W-mpob4nyk0006580e — terminal banner is driven by the engine's
+  // `dispatch.terminal` SSE event, NOT by parsing the JSONL log tail.
+  // The /live-stream endpoint multiplexes log frames (default `data:`
+  // messages) and terminal events (named `event: dispatch.terminal`); we
+  // open the SSE connection but only consume the terminal event. The
+  // stream stays mostly idle (one event per dispatch lifecycle), so this
+  // does not regress the connection-exhaustion fix that switched log
+  // tailing to polling.
+  startTerminalEventSource(agentId);
+}
+
+function startTerminalEventSource(agentId) {
+  if (typeof window.EventSource !== 'function') return;
+  try {
+    liveTerminalSource = new EventSource('/api/agent/' + encodeURIComponent(agentId) + '/live-stream?tail=0');
+  } catch (e) { console.error('terminal-event source open:', e.message); return; }
+  liveTerminalSource.addEventListener('dispatch.terminal', function(ev) {
+    let payload;
+    try { payload = JSON.parse(ev.data); } catch { return; }
+    renderTerminalBannerForAgent(agentId, payload);
+  });
+  // Ignore default `data:` log frames — log content arrives via polling.
+  liveTerminalSource.onerror = function() {
+    // EventSource auto-reconnects; nothing to do.
+  };
+}
+
+function renderTerminalBannerForAgent(agentId, payload) {
+  // Guard against late-arriving events for a previous agent (tab switch race).
+  if (typeof currentAgentId !== 'undefined' && currentAgentId !== agentId) return;
+  if (typeof currentTab !== 'undefined' && currentTab !== 'live') return;
+  const bannerEl = document.getElementById('live-terminal-banner');
+  if (!bannerEl) return;
+  const html = renderTerminalBanner(payload);
+  // eslint-disable-next-line no-unsanitized/property -- reason: renderTerminalBanner() escapes all user-controlled fields (summary, reason, prUrl) before assembling HTML (see dashboard/js/render-utils.js)
+  bannerEl.innerHTML = html;
 }
 
 function stopLiveStream() {
@@ -59,6 +101,10 @@ function stopLiveStream() {
     liveEventSource.close();
     liveEventSource = null;
   }
+  if (liveTerminalSource) {
+    try { liveTerminalSource.close(); } catch { /* optional */ }
+    liveTerminalSource = null;
+  }
   if (_runtimeTimer) { clearInterval(_runtimeTimer); _runtimeTimer = null; }
   stopLivePolling();
 }
@@ -169,4 +215,4 @@ async function sendSteering() {
   }
 }
 
-window.MinionsLive = { renderLiveChatMessage, startLiveStream, stopLiveStream, startLivePolling, stopLivePolling, refreshLiveOutput, sendSteering };
+window.MinionsLive = { renderLiveChatMessage, renderTerminalBannerForAgent, startLiveStream, stopLiveStream, startLivePolling, stopLivePolling, refreshLiveOutput, sendSteering };

package/dashboard/js/refresh.js

@@ -73,7 +73,7 @@ const RENDER_VERSIONS = {
   prd: 1,
   prs: 2,
   archivedPrds: 1,
-  engine: 2,
+  engine: 3,
   version: 1,
   adoThrottle: 1,
   ghThrottle: 1,
@@ -147,6 +147,47 @@ function _formatCcDrawerLabel(autoMode) {
   return runtimeLabel + (model ? ' (' + model + ')' : '') + '-powered. Full minions context. Enter to send, Shift+Enter for newline.';
 }
 
+// W-mpnc4u8c001d9d6c — #engine-quick-stats "Next tick in Xs" countdown.
+//
+// Origin is engine.lastTickAt (stamped by tickInner at the start of every
+// tick, see engine.js) plus engine.tickInterval (server-side config, surfaced
+// via _buildStatusFastState). The chip updates every 1s without re-rendering
+// the surrounding row — mirrors the _tickAgentRuntimes pattern in
+// dashboard/js/render-agents.js. The countdown clamps at 0 and shows "due"
+// when the engine is mid-tick (PR polls etc. can push tick-to-tick wall time
+// past the nominal interval). When the engine isn't running, show "—" so a
+// stale lastTickAt doesn't render a ticking countdown the engine can't honor.
+var _engineCountdown = { lastTickAt: 0, tickInterval: 0, engineState: 'stopped' };
+var _engineNextTickTimer = null;
+
+function _formatNextTickText() {
+  var state = _engineCountdown.engineState;
+  if (state !== 'running' && state !== 'stopping') return '—';
+  var last = _engineCountdown.lastTickAt;
+  var interval = _engineCountdown.tickInterval;
+  if (!last || !interval) return '—';
+  var remainingMs = last + interval - Date.now();
+  if (remainingMs <= 0) return 'due';
+  return Math.ceil(remainingMs / 1000) + 's';
+}
+
+function _updateNextTickChip() {
+  var el = document.getElementById('engine-next-tick');
+  if (!el) {
+    if (_engineNextTickTimer) { clearInterval(_engineNextTickTimer); _engineNextTickTimer = null; }
+    return;
+  }
+  var next = _formatNextTickText();
+  if (el.textContent !== next) el.textContent = next;
+}
+
+function _startNextTickTicker() {
+  // Idempotent — refresh.js re-runs every 4s and reseats the data on the
+  // shared _engineCountdown; we don't want compounding intervals.
+  if (_engineNextTickTimer) return;
+  _engineNextTickTimer = setInterval(_updateNextTickChip, 1000);
+}
+
 function _processStatusUpdate(data) {
   // Detect fresh install — clear stale browser state AND reload so module-scoped
   // JS caches (_sectionCache, _prevCounts, _managedProcessesLastItems,
@@ -246,10 +287,21 @@ function _processStatusUpdate(data) {
     var qs = document.getElementById('engine-quick-stats');
     if (qs && data.engine) {
       var wt = data.engine.worktreeCount != null ? data.engine.worktreeCount : '-';
-      var tick = data.engine.tick || '-';
       var pid = data.engine.pid || '-';
-      // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal engine metrics (pid, tick, worktreeCount; no user data flows in)
-      qs.innerHTML = '<span>PID: <b>' + pid + '</b></span><span>Tick: <b>' + tick + '</b></span><span>Worktrees: <b>' + wt + '</b></span>';
+      // W-mpnc4u8c001d9d6c — replace the dead "Tick: -" chip (control.json
+      // never carried a `tick` field) with a live "Next tick in Xs" countdown
+      // driven by engine.lastTickAt (stamped at the start of every tickInner)
+      // and engine.tickInterval (config, surfaced in the status payload).
+      // _updateNextTickChip below ticks the inner span every 1s without
+      // re-rendering this whole row.
+      _engineCountdown.lastTickAt = Number(data.engine.lastTickAt) || 0;
+      _engineCountdown.tickInterval = Number(data.engine.tickInterval) || 0;
+      _engineCountdown.engineState = data.engine.state || 'stopped';
+      // eslint-disable-next-line no-unsanitized/property -- reason: composed from internal engine metrics (pid, lastTickAt/tickInterval, worktreeCount) and a literal id; no user data flows in
+      qs.innerHTML = '<span>PID: <b>' + pid + '</b></span>' +
+        '<span>Next tick in: <b id="engine-next-tick">' + _formatNextTickText() + '</b></span>' +
+        '<span>Worktrees: <b>' + wt + '</b></span>';
+      _startNextTickTicker();
     }
   }
   if (_changed('version', data.version)) renderVersionBanner(data.version);

package/dashboard/js/render-utils.js

@@ -189,19 +189,15 @@ function _renderJsonObj(obj, state) {
   }
 
   if (obj.type === 'result') {
-    // Banner is gated on TWO conditions: (a) this is the LAST result line in the output,
-    // and (b) the [process-exit] sentinel has been seen. Intermediate result lines from
-    // ScheduleWakeup resume cycles fall through and render nothing.
-    if (state.isFinalResult) {
-      var subtype = typeof obj.subtype === 'string' ? obj.subtype : '';
-      var resultIsError = obj.is_error === true || subtype.startsWith('error');
-      var exitFailed = state.exitInfo && state.exitInfo.success === false;
-      if (resultIsError || exitFailed) {
-        parts.push('<div style="background:rgba(248,81,73,0.1);border:1px solid var(--red);padding:8px 12px;border-radius:8px;margin:8px 0;font-size:12px;color:var(--red)">\u2717 Task ended with error</div>');
-      } else {
-        parts.push('<div style="background:rgba(63,185,80,0.1);border:1px solid var(--green);padding:8px 12px;border-radius:8px;margin:8px 0;font-size:12px;color:var(--green)">\u2713 Task complete</div>');
-      }
-    }
+    // W-mpob4nyk0006580e — the terminal banner is no longer derived here.
+    // The engine's dispatch.result is the single source of truth and is
+    // pushed to the live view via the SSE `dispatch.terminal` channel
+    // (engine/dispatch-events.js → dashboard.js handleAgentLiveStream).
+    // `result` JSONL lines and the `[process-exit]` sentinel are still
+    // parsed for other purposes (e.g. tool deltas above), but they must
+    // NOT trigger any banner here — log heuristics can disagree with the
+    // engine verdict (CLI crash AFTER successful completion report, exit-0
+    // with no result line, timeout kill, …). See renderTerminalBanner().
   }
 
   return parts.join('');
@@ -237,46 +233,12 @@ function renderAgentOutput(text) {
     }
   }
 
-  // ── Pre-scan ──────────────────────────────────────────────────────────────
-  // ScheduleWakeup-based polling agents emit one `"type":"result"` JSONL line
-  // per resume cycle, followed by another resume — only the LAST result line
-  // before spawn-agent.js writes its `[process-exit]` sentinel is the true
-  // final result. Intermediate result lines must NOT trigger the banner.
-  //
-  // spawn-agent.js writes:
-  //   "\n[process-exit] code=N\n"        on normal close (engine/spawn-agent.js:202)
-  //   "\n[process-exit] spawn-failed\n"  on synchronous spawn() throw
-  //
-  // We pre-scan to find: (1) whether [process-exit] was emitted at all, (2) its
-  // exit code (success vs failure), and (3) the line index of the last result
-  // strictly before that sentinel.
-  var exitInfo = null; // null = process still running (no banner ever fires)
-  var exitLineIdx = -1;
-  var lastResultLineIdx = -1;
-  var exitRe = /^\[process-exit\]\s+(?:code=)?(-?\d+|spawn-failed)\s*$/;
-  for (var k = 0; k < lines.length; k++) {
-    var t = lines[k].trim();
-    if (!t) continue;
-    var em = exitRe.exec(t);
-    if (em) {
-      var token = em[1];
-      var code = token === 'spawn-failed' ? -1 : parseInt(token, 10);
-      exitInfo = { code: code, success: code === 0 };
-      exitLineIdx = k;
-    }
-  }
-
-  if (exitLineIdx !== -1) {
-    for (var r = 0; r < exitLineIdx; r++) {
-      var rt = lines[r].trim();
-      if (!rt || rt.charCodeAt(0) !== 123 /* '{' */) continue;
-      try {
-        var probe = JSON.parse(rt);
-        if (probe && probe.type === 'result') lastResultLineIdx = r;
-      } catch (e) { /* ignore parse errors during scan */ }
-    }
-  }
-  state.exitInfo = exitInfo;
+  // W-mpob4nyk0006580e — pre-scan removed. Previously we found the final
+  // `"type":"result"` line + `[process-exit]` sentinel to gate a terminal
+  // banner here, but the terminal banner is now pushed from the engine via
+  // the `dispatch.terminal` SSE channel (see renderTerminalBanner()). The
+  // log lines below are still parsed for tool calls / assistant text /
+  // reasoning deltas — only the banner-gating heuristic is gone.
 
   for (var i = 0; i < lines.length; i++) {
     var trimmed = lines[i].trim();
@@ -304,26 +266,24 @@ function renderAgentOutput(text) {
       continue;
     }
 
-    // JSON array line — never holds the canonical result, banner never fires here
+    // JSON array line
     if (trimmed.startsWith('[')) {
       try {
         var arr = JSON.parse(trimmed);
         if (Array.isArray(arr)) {
-          state.isFinalResult = false;
           for (var j = 0; j < arr.length; j++) fragments.push(_renderJsonObj(arr[j], state));
           continue;
         }
       } catch (e) { /* fall through */ }
     }
 
-    // JSON object line — banner fires only when this is the final result AND process exited
+    // JSON object line
     if (trimmed.startsWith('{')) {
       try {
         var obj = JSON.parse(trimmed);
         if (obj.type !== 'assistant.message_delta' && obj.type !== 'assistant.reasoning' && obj.type !== 'assistant.reasoning_delta' && obj.type !== 'assistant.message') {
           flushCopilotPending();
         }
-        state.isFinalResult = (i === lastResultLineIdx) && (exitInfo !== null);
         fragments.push(_renderJsonObj(obj, state));
         continue;
       } catch (e) { /* fall through */ }
@@ -342,16 +302,57 @@ function renderAgentOutput(text) {
 
   flushCopilotPending();
 
-  // Fallback error banner: process exited with non-zero code but never emitted
-  // a `"type":"result"` line (CLI crashed before producing one). Without this,
-  // the user would see only stderr noise with no terminal-state indicator.
-  if (exitInfo && !exitInfo.success && lastResultLineIdx === -1) {
-    fragments.push('<div style="background:rgba(248,81,73,0.1);border:1px solid var(--red);padding:8px 12px;border-radius:8px;margin:8px 0;font-size:12px;color:var(--red)">✗ Task ended with error</div>');
-  }
-
+  // W-mpob4nyk0006580e — no log-derived banner here either. The fallback
+  // "exit non-zero with no result line" branch used to render a red banner
+  // for crashes mid-write; that case is now covered by the engine's
+  // `dispatch.result` (set by completeDispatch and pushed via the SSE
+  // `dispatch.terminal` channel — see renderTerminalBanner()). Removing
+  // this branch is what makes the live view banner agree with the agent
+  // row's status in cases like exit-1 AFTER a success completion report.
   return fragments.join('');
 }
 
+/**
+ * W-mpob4nyk0006580e — render the terminal banner from an authoritative
+ * `dispatch.terminal` SSE event. The shape mirrors
+ * engine/dispatch-events.js buildTerminalEvent():
+ *   { type, ts, dispatchId, agentId, result, reason, failureClass, prUrl, summary }
+ *
+ * The banner state mirrors `dispatch.result` exactly — green for SUCCESS,
+ * red otherwise. Optional reason / failure class / PR link / summary first
+ * line are surfaced as secondary context.
+ *
+ * Returns HTML for a single banner div. Callers replace the banner
+ * container's innerHTML on each event.
+ */
+function renderTerminalBanner(event) {
+  if (!event || !event.result) return '';
+  var isSuccess = event.result === 'success';
+  var color = isSuccess ? 'var(--green)' : 'var(--red)';
+  var bg = isSuccess ? 'rgba(63,185,80,0.1)' : 'rgba(248,81,73,0.1)';
+  var glyph = isSuccess ? '\u2713' : '\u2717';
+  var headline;
+  if (isSuccess) {
+    headline = glyph + ' Task complete';
+  } else {
+    // 'error' / 'timeout' / anything-else → use reason word from the engine
+    var reasonWord = event.result === 'timeout' ? 'timeout' : (event.failureClass || 'error');
+    headline = glyph + ' Task ended with ' + escHtml(String(reasonWord));
+  }
+  var extra = '';
+  if (event.summary) extra += '<div style="font-size:11px;margin-top:4px;opacity:0.9">' + escHtml(event.summary) + '</div>';
+  if (event.reason && event.reason !== event.summary) {
+    extra += '<div style="font-size:10px;margin-top:2px;opacity:0.75">' + escHtml(event.reason) + '</div>';
+  }
+  if (event.prUrl) {
+    var safeUrl = encodeURI(String(event.prUrl));
+    extra += '<div style="font-size:11px;margin-top:4px"><a href="' + escHtml(safeUrl) + '" target="_blank" rel="noopener" style="color:' + color + '">' + escHtml(event.prUrl) + '</a></div>';
+  }
+  return '<div style="background:' + bg + ';border:1px solid ' + color + ';padding:8px 12px;border-radius:8px;margin:8px 0;font-size:12px;color:' + color + '">' +
+    headline + extra +
+    '</div>';
+}
+
 /**
  * Standard "Prev / Next" pager HTML for a paginated list. Used by inbox, KB,
  * completed dispatches, and engine log. The caller is responsible for the
@@ -404,4 +405,4 @@ function pinButton(pinKey, pinned, source, opts) {
     (pinned ? 'Unpin' : 'Pin') + '</button>';
 }
 
-window.MinionsRenderUtils = { formatToolSummary, renderAgentOutput, renderPager, pinButton };
+window.MinionsRenderUtils = { formatToolSummary, renderAgentOutput, renderTerminalBanner, renderPager, pinButton };

package/dashboard.js

@@ -31,6 +31,7 @@ const qaRunsMod = require('./engine/qa-runs');
 const routing = require('./engine/routing');
 const playbook = require('./engine/playbook');
 const dispatchMod = require('./engine/dispatch');
+const dispatchEvents = require('./engine/dispatch-events');
 const { wrapUntrusted, buildSource } = require('./engine/untrusted-fence');
 const steering = require('./engine/steering');
 const projectDiscovery = require('./engine/project-discovery');
@@ -1729,6 +1730,11 @@ function _buildStatusFastState() {
       // possibly-cached payload (false-positive banner regression #2754).
       heartbeatAgeMs: engineState.heartbeat ? hbAge : null,
       heartbeatStale: !!(engineState.heartbeat && hbAge > ENGINE_HEARTBEAT_STALE_MS),
+      // W-mpnc4u8c001d9d6c — Surface the tick cadence so the client's
+      // #engine-quick-stats "Next tick in Xs" countdown reads the SAME value
+      // the engine actually uses (Settings parity rule). Paired with
+      // control.lastTickAt (above) stamped at the start of every tickInner.
+      tickInterval: Number(CONFIG?.engine?.tickInterval) || shared.ENGINE_DEFAULTS.tickInterval,
     },
     adoThrottle: ado.getAdoThrottleState(),
     ghThrottle: gh.getGhThrottleState(),
@@ -5740,7 +5746,13 @@ const server = http.createServer(async (req, res) => {
 
     // Send initial content — tail only (last 64KB by default) to avoid memory spikes
     const params = new URL(req.url, 'http://localhost').searchParams;
-    const tailBytes = Math.max(0, parseInt(params.get('tail') || '65536', 10) || 65536);
+    // W-mpob4nyk0006580e — accept tail=0 verbatim so terminal-only subscribers
+    // (live-stream.js opens this endpoint just for `event: dispatch.terminal`)
+    // don't pay 64KB of unused log payload on connect.
+    const _tailParam = params.get('tail');
+    const tailBytes = _tailParam !== null
+      ? Math.max(0, parseInt(_tailParam, 10) || 0)
+      : 65536;
     let offset = 0;
     try {
       const stat = fs.statSync(liveLogPath);
@@ -5748,7 +5760,7 @@ const server = http.createServer(async (req, res) => {
 
       // Fall back to previous session log when current is sparse (fixes #543)
       const SPARSE_THRESHOLD = 500;
-      if (fileSize < SPARSE_THRESHOLD) {
+      if (tailBytes > 0 && fileSize < SPARSE_THRESHOLD) {
         const prevPath = path.join(agentDir, 'live-output-prev.log');
         try {
           const prevStat = fs.statSync(prevPath);
@@ -5765,7 +5777,7 @@ const server = http.createServer(async (req, res) => {
         } catch { /* prev file may not exist — that's fine */ }
       }
 
-      if (fileSize > 0) {
+      if (tailBytes > 0 && fileSize > 0) {
         const readStart = Math.max(0, fileSize - tailBytes);
         const readLen = fileSize - readStart;
         const fd = fs.openSync(liveLogPath, 'r');
@@ -5775,6 +5787,10 @@ const server = http.createServer(async (req, res) => {
         const content = buf.toString('utf8');
         if (content) safeWrite(`data: ${JSON.stringify(content)}\n\n`);
         offset = fileSize;
+      } else {
+        // Skipped log replay (tail=0 subscribers); still pin the watcher
+        // offset to current EOF so we only stream future appends.
+        offset = fileSize;
       }
     } catch { /* optional — file may not exist yet */ }
 
@@ -5797,12 +5813,65 @@ const server = http.createServer(async (req, res) => {
 
     fs.watchFile(liveLogPath, { interval: 500 }, watcher);
 
+    // W-mpob4nyk0006580e — single source of truth for the live-view banner.
+    // Instead of the client deriving terminal state from log heuristics
+    // ([process-exit] + "result" line), the engine pushes a terminal event
+    // through engine/dispatch-events.js (JSONL ring at
+    // engine/dispatch-terminal-events.jsonl, written by completeDispatch()
+    // immediately after `result` is committed). The dashboard tails that
+    // ring and re-broadcasts each new entry as an SSE `dispatch.terminal`
+    // frame so the banner mirrors `dispatch.result` exactly.
+    const _sentTerminalDispatchIds = new Set();
+    const sendTerminalEvent = (event) => {
+      if (!event || !event.dispatchId) return;
+      if (_sentTerminalDispatchIds.has(event.dispatchId)) return;
+      _sentTerminalDispatchIds.add(event.dispatchId);
+      safeWrite(`event: dispatch.terminal\ndata: ${JSON.stringify(event)}\n\n`);
+    };
+
+    // Replay-on-connect: if a terminal event for this agent landed within
+    // the ring's TTL, push it immediately so a viewer who opens the live
+    // view AFTER completion still sees the verdict.
+    try {
+      const recent = dispatchEvents.getLastTerminalForAgent(agentId);
+      if (recent) sendTerminalEvent(recent);
+    } catch { /* best-effort replay */ }
+
+    const eventsFile = dispatchEvents._eventsFile();
+    let _terminalEventsOffset = 0;
+    try { _terminalEventsOffset = fs.statSync(eventsFile).size; }
+    catch { _terminalEventsOffset = 0; }
+
+    const terminalWatcher = () => {
+      if (_cleanedUp) return;
+      let stat;
+      try { stat = fs.statSync(eventsFile); } catch { return; }
+      if (stat.size === _terminalEventsOffset) return;
+      // File rotation/truncation — rewind to start so we don't miss entries.
+      if (stat.size < _terminalEventsOffset) _terminalEventsOffset = 0;
+      try {
+        const fd = fs.openSync(eventsFile, 'r');
+        const buf = Buffer.alloc(stat.size - _terminalEventsOffset);
+        fs.readSync(fd, buf, 0, buf.length, _terminalEventsOffset);
+        fs.closeSync(fd);
+        _terminalEventsOffset = stat.size;
+        const lines = buf.toString('utf8').split('\n').filter(Boolean);
+        for (const line of lines) {
+          let evt;
+          try { evt = JSON.parse(line); } catch { continue; }
+          if (evt && evt.agentId === agentId) sendTerminalEvent(evt);
+        }
+      } catch { /* read race; next watcher tick retries */ }
+    };
+    fs.watchFile(eventsFile, { interval: 500 }, terminalWatcher);
+
     // Idempotent cleanup helper to prevent handle leaks
     const cleanup = () => {
       if (_cleanedUp) return;
       _cleanedUp = true;
       try { clearInterval(doneCheck); } catch { /* optional */ }
       try { fs.unwatchFile(liveLogPath, watcher); } catch { /* optional */ }
+      try { fs.unwatchFile(eventsFile, terminalWatcher); } catch { /* optional */ }
     };
 
     // Check if agent is still active (poll every 5s)

package/engine/dispatch-events.js

@@ -0,0 +1,177 @@
+/**
+ * engine/dispatch-events.js — Single source of truth for dispatch terminal events.
+ *
+ * W-mpob4nyk0006580e: The live view banner ("✓ Task complete" / "✗ Task ended
+ * with …") must mirror `dispatch.result` exactly. Previously the banner was
+ * derived in the browser from the JSONL `result` line + the `[process-exit]`
+ * sentinel, which disagrees with the engine's terminal state in real-world
+ * cases (CLI crash AFTER writing a successful completion report, exit-0 with
+ * no result line, hard-kill by timeout sweep, …). This module replaces that
+ * heuristic with a push channel rooted in `completeDispatch()`:
+ *
+ *   completeDispatch() → mutateDispatch writes `result` → emitDispatchTerminal()
+ *
+ * Subscribers are notified two ways so the channel works in both the
+ * in-process test harness and the engine↔dashboard cross-process runtime:
+ *
+ *   1. EventEmitter — same-process consumers (unit tests, future co-located
+ *      callers) subscribe via onDispatchTerminal().
+ *   2. JSONL ring at `<engine>/dispatch-terminal-events.jsonl` — the dashboard
+ *      process tails this file via fs.watchFile (see dashboard.js
+ *      handleAgentLiveStream) and re-broadcasts each new entry as an SSE
+ *      `dispatch.terminal` frame to live-view clients.
+ *
+ * The ring is capped (MAX_RING_ENTRIES, REPLAY_TTL_MS) so a viewer that
+ * connects AFTER a dispatch completes still receives the most recent terminal
+ * verdict on connect (replay-on-connect).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { EventEmitter } = require('events');
+const shared = require('./shared');
+
+const MAX_RING_ENTRIES = 50;          // bound file size + memory; dev tool
+const REPLAY_TTL_MS = 5 * 60 * 1000;  // 5 min — long enough for tab refresh
+
+const _emitter = new EventEmitter();
+// Live view streams subscribe per-connection; cap is generous to avoid
+// MaxListenersExceeded warnings in dashboards with many open live tabs.
+_emitter.setMaxListeners(500);
+
+function _eventsFile() {
+  // Re-read shared.MINIONS_DIR at call time so test-isolated minions dirs
+  // (createTestMinionsDir) get a tmp-scoped events file rather than the live
+  // engine/ directory.
+  return path.join(shared.MINIONS_DIR, 'engine', 'dispatch-terminal-events.jsonl');
+}
+
+function _now() { return Date.now(); }
+
+function _readLines() {
+  try {
+    const raw = fs.readFileSync(_eventsFile(), 'utf8');
+    return raw.split('\n').filter(Boolean);
+  } catch { return []; }
+}
+
+function _appendEventLine(event) {
+  const file = _eventsFile();
+  const dir = path.dirname(file);
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    let lines = _readLines();
+    lines.push(JSON.stringify(event));
+    // Drop entries older than REPLAY_TTL_MS, then cap by entry count.
+    const cutoff = _now() - REPLAY_TTL_MS;
+    lines = lines.filter(line => {
+      try { return (JSON.parse(line).ts || 0) >= cutoff; }
+      catch { return false; }
+    });
+    if (lines.length > MAX_RING_ENTRIES) {
+      lines = lines.slice(lines.length - MAX_RING_ENTRIES);
+    }
+    fs.writeFileSync(file, lines.join('\n') + '\n');
+  } catch {
+    // Best-effort observability channel — engine progress must never block
+    // on a failed disk write here.
+  }
+}
+
+/**
+ * Build + broadcast a dispatch terminal event. Called from completeDispatch()
+ * after the dispatch record's `result` is committed. The event payload is the
+ * authoritative shape consumed by the live-view banner renderer.
+ *
+ * Shape:
+ *   {
+ *     type: 'dispatch.terminal',
+ *     ts: <epoch-ms>,
+ *     dispatchId: <string>,
+ *     agentId: <string>,
+ *     result: 'success' | 'error' | 'timeout',
+ *     reason: <string>,            // human-readable
+ *     failureClass: <string|null>, // FAILURE_CLASS enum or null
+ *     prUrl: <string|null>,        // PR URL/id from completion report, or null
+ *     summary: <string>            // first line of completion summary (240ch max)
+ *   }
+ */
+function emitDispatchTerminal(event) {
+  if (!event || typeof event !== 'object') return;
+  if (!event.type) event.type = 'dispatch.terminal';
+  if (!event.ts) event.ts = _now();
+  _appendEventLine(event);
+  try { _emitter.emit('dispatch.terminal', event); } catch { /* never throw */ }
+}
+
+function onDispatchTerminal(listener) {
+  _emitter.on('dispatch.terminal', listener);
+  return () => _emitter.off('dispatch.terminal', listener);
+}
+
+function readRecentEvents() {
+  const cutoff = _now() - REPLAY_TTL_MS;
+  return _readLines()
+    .map(line => { try { return JSON.parse(line); } catch { return null; } })
+    .filter(e => e && (e.ts || 0) >= cutoff);
+}
+
+function getLastTerminalForAgent(agentId) {
+  if (!agentId) return null;
+  const events = readRecentEvents();
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].agentId === agentId) return events[i];
+  }
+  return null;
+}
+
+function getLastTerminalForDispatch(dispatchId) {
+  if (!dispatchId) return null;
+  const events = readRecentEvents();
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i].dispatchId === dispatchId) return events[i];
+  }
+  return null;
+}
+
+/**
+ * Build the terminal event payload from a freshly-completed dispatch entry +
+ * the inputs to completeDispatch(). Extracted so both the engine emitter and
+ * the dashboard's JSONL tailer reach the same shape.
+ */
+function buildTerminalEvent({ dispatchId, agentId, result, reason, failureClass, structuredCompletion, resultSummary }) {
+  let prUrl = null;
+  let summary = '';
+  if (structuredCompletion && typeof structuredCompletion === 'object') {
+    const sc = structuredCompletion;
+    if (sc.pr && typeof sc.pr === 'string' && sc.pr !== 'N/A') prUrl = sc.pr;
+    const rawSummary = typeof sc.summary === 'string' ? sc.summary : '';
+    if (rawSummary) summary = rawSummary.split('\n')[0].slice(0, 240);
+  }
+  if (!summary && typeof resultSummary === 'string' && resultSummary) {
+    summary = resultSummary.split('\n')[0].slice(0, 240);
+  }
+  return {
+    type: 'dispatch.terminal',
+    dispatchId,
+    agentId: agentId || null,
+    result,
+    reason: reason || '',
+    failureClass: failureClass || null,
+    prUrl,
+    summary,
+  };
+}
+
+module.exports = {
+  emitDispatchTerminal,
+  onDispatchTerminal,
+  readRecentEvents,
+  getLastTerminalForAgent,
+  getLastTerminalForDispatch,
+  buildTerminalEvent,
+  // exposed for testing / dashboard tailer
+  _eventsFile,
+  MAX_RING_ENTRIES,
+  REPLAY_TTL_MS,
+};

package/engine/dispatch.js

@@ -8,6 +8,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 const { setCooldown, setCooldownFailure } = require('./cooldown');
+const dispatchEvents = require('./dispatch-events');
 
 const { safeJsonArr, mutateJsonFileLocked, mutateWorkItems,
   mutatePullRequests, getProjects, projectPrPath, log, ts, dateStamp,
@@ -583,6 +584,24 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
 
   if (item) {
     log('info', `Completed dispatch: ${id} (${result}${reason ? ': ' + reason : ''})`);
+    // W-mpob4nyk0006580e — broadcast terminal state immediately after the
+    // `result` field is committed to dispatch.json. This is the single
+    // source of truth for the live-view banner; subscribers (dashboard SSE
+    // handler at handleAgentLiveStream) push it to clients so the banner
+    // mirrors `dispatch.result` exactly — no log-parsing heuristics that can
+    // disagree with the engine's verdict.
+    try {
+      dispatchEvents.emitDispatchTerminal(dispatchEvents.buildTerminalEvent({
+        dispatchId: id,
+        agentId: item.agent,
+        result,
+        reason,
+        failureClass,
+        structuredCompletion: opts.structuredCompletion || item.structuredCompletion || null,
+        resultSummary,
+      }));
+    } catch (e) { log('warn', 'emit dispatch.terminal: ' + e.message); }
+
     if (result === DISPATCH_RESULT.ERROR) {
       writeFailedAgentReport(item, reason, resultSummary, failureClass);
     }

package/engine.js

@@ -6522,6 +6522,17 @@ async function tickInner() {
   // Per-phase guards inside the rest of tickInner are sub-task -b's scope.
   if (_isTickStale(myGeneration)) return;
 
+  // W-mpnc4u8c001d9d6c — Stamp `lastTickAt` on every tickInner entry so the
+  // dashboard's #engine-quick-stats "Next tick in Xs" countdown has a reliable
+  // anchor (control.json carries no separate tick-counter field). Synchronous
+  // mutator, no awaits inside the lock — mirrors the writer contract used by
+  // engine/cli.js#writeHeartbeatNow. Distinct from control.heartbeat: this
+  // advances once per tick cadence, not on the 15s heartbeat cadence, so the
+  // client can render an accurate "next tick" countdown without coupling to
+  // the staleness signal.
+  try { shared.mutateControl(c => { c.lastTickAt = Date.now(); return c; }); }
+  catch (e) { log('warn', `lastTickAt write: ${e.message}`); }
+
   const config = getConfig();
   tickCount++;
   const now = Date.now();

package/package.json

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