@yemi33/minions 0.1.2136 → 0.1.2137

package/dashboard/js/live-stream.js

@@ -124,6 +124,24 @@ function startTerminalEventSource(agentId) {
     try { payload = JSON.parse(ev.data); } catch { return; }
     renderTerminalBannerForAgent(agentId, payload);
   });
+  // W-mq1m1wo5000nd78d — when the same agent starts a new dispatch, clear
+  // the prior dispatch's terminal banner. Without this, the stale banner
+  // from the previous dispatch lingers across same-agent re-dispatch
+  // because startLiveStream() only clears on tab switch / agent change.
+  liveTerminalSource.addEventListener('dispatch.started', function(ev) {
+    let payload;
+    try { payload = JSON.parse(ev.data); } catch { return; }
+    // Mirror the same guards used by renderTerminalBannerForAgent —
+    // a late-arriving started event for a stale agent / non-live tab
+    // must not wipe the current banner.
+    if (typeof currentAgentId !== 'undefined' && currentAgentId !== agentId) return;
+    if (typeof currentTab !== 'undefined' && currentTab !== 'live') return;
+    // Server-side guard already filters by agentId, but defend in depth
+    // for replay paths or future per-stream routing changes.
+    if (payload && payload.agentId && payload.agentId !== agentId) return;
+    const bannerEl = document.getElementById('live-terminal-banner');
+    if (bannerEl) bannerEl.innerHTML = '';
+  });
   // Ignore default `data:` log frames — log content arrives via polling.
   liveTerminalSource.onerror = function() {
     // EventSource auto-reconnects; nothing to do.

package/dashboard.js

@@ -6092,6 +6092,46 @@ const server = http.createServer(async (req, res) => {
     };
     fs.watchFile(eventsFile, { interval: 500 }, terminalWatcher);
 
+    // W-mq1m1wo5000nd78d — parallel watcher for `dispatch.started` events.
+    // Symmetric with the terminal watcher above; the dashboard re-broadcasts
+    // each new entry as an SSE `dispatch.started` frame. The live-view
+    // client uses this to clear a stale terminal banner when the same agent
+    // immediately starts a new dispatch. NO replay-on-connect: the
+    // banner-clear is the only consumer and replaying a stale started event
+    // after a viewer connects post-terminal would wipe the terminal banner.
+    const _sentStartedDispatchIds = new Set();
+    const sendStartedEvent = (event) => {
+      if (!event || !event.dispatchId) return;
+      if (_sentStartedDispatchIds.has(event.dispatchId)) return;
+      _sentStartedDispatchIds.add(event.dispatchId);
+      safeWrite(`event: dispatch.started\ndata: ${JSON.stringify(event)}\n\n`);
+    };
+    const startedEventsFile = dispatchEvents._startedEventsFile();
+    let _startedEventsOffset = 0;
+    try { _startedEventsOffset = fs.statSync(startedEventsFile).size; }
+    catch { _startedEventsOffset = 0; }
+    const startedWatcher = () => {
+      if (_cleanedUp) return;
+      let stat;
+      try { stat = fs.statSync(startedEventsFile); } catch { return; }
+      if (stat.size === _startedEventsOffset) return;
+      if (stat.size < _startedEventsOffset) _startedEventsOffset = 0;
+      try {
+        const fd = fs.openSync(startedEventsFile, 'r');
+        const buf = Buffer.alloc(stat.size - _startedEventsOffset);
+        fs.readSync(fd, buf, 0, buf.length, _startedEventsOffset);
+        fs.closeSync(fd);
+        _startedEventsOffset = 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) sendStartedEvent(evt);
+        }
+      } catch { /* read race; next watcher tick retries */ }
+    };
+    fs.watchFile(startedEventsFile, { interval: 500 }, startedWatcher);
+
     // Idempotent cleanup helper to prevent handle leaks
     const cleanup = () => {
       if (_cleanedUp) return;
@@ -6099,6 +6139,7 @@ const server = http.createServer(async (req, res) => {
       try { clearInterval(doneCheck); } catch { /* optional */ }
       try { fs.unwatchFile(liveLogPath, watcher); } catch { /* optional */ }
       try { fs.unwatchFile(eventsFile, terminalWatcher); } catch { /* optional */ }
+      try { fs.unwatchFile(startedEventsFile, startedWatcher); } catch { /* optional */ }
     };
 
     // Check if agent is still active (poll every 5s)

package/engine/dispatch-events.js

@@ -46,21 +46,33 @@ function _eventsFile() {
   return path.join(shared.MINIONS_DIR, 'engine', 'dispatch-terminal-events.jsonl');
 }
 
+function _startedEventsFile() {
+  // W-mq1m1wo5000nd78d — parallel ring for `dispatch.started` events. Kept
+  // separate from the terminal ring so a same-agent re-dispatch can clear
+  // the prior terminal banner without us having to peek/merge two event
+  // types in the dashboard tailer or worry about per-dispatch ordering
+  // when one ring rolls over before the other.
+  return path.join(shared.MINIONS_DIR, 'engine', 'dispatch-started-events.jsonl');
+}
+
 function _now() { return Date.now(); }
 
-function _readLines() {
+function _readLinesFrom(file) {
   try {
-    const raw = fs.readFileSync(_eventsFile(), 'utf8');
+    const raw = fs.readFileSync(file, 'utf8');
     return raw.split('\n').filter(Boolean);
   } catch { return []; }
 }
 
-function _appendEventLine(event) {
-  const file = _eventsFile();
+function _readLines() {
+  return _readLinesFrom(_eventsFile());
+}
+
+function _appendEventLineTo(file, event) {
   const dir = path.dirname(file);
   try {
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    let lines = _readLines();
+    let lines = _readLinesFrom(file);
     lines.push(JSON.stringify(event));
     // Drop entries older than REPLAY_TTL_MS, then cap by entry count.
     const cutoff = _now() - REPLAY_TTL_MS;
@@ -78,6 +90,10 @@ function _appendEventLine(event) {
   }
 }
 
+function _appendEventLine(event) {
+  _appendEventLineTo(_eventsFile(), event);
+}
+
 /**
  * Build + broadcast a dispatch terminal event. Called from completeDispatch()
  * after the dispatch record's `result` is committed. The event payload is the
@@ -163,6 +179,67 @@ function buildTerminalEvent({ dispatchId, agentId, result, reason, failureClass,
   };
 }
 
+/**
+ * W-mq1m1wo5000nd78d — symmetric counterpart to `dispatch.terminal`. Called
+ * exactly once per FRESH spawn from engine.js#spawnAgent (NOT from cli.js
+ * re-attach paths, which inherit a still-live previous-dispatch banner that
+ * must not be clobbered by a synthetic restart-time started event).
+ *
+ * Sole consumer today: dashboard/js/live-stream.js — clears
+ * `#live-terminal-banner` so a stale "✓ Task complete" / "✗ Task ended"
+ * banner from the agent's prior dispatch doesn't linger across same-agent
+ * re-dispatch (e.g. Ripley finishing one scheduled run and immediately
+ * starting another).
+ *
+ * Shape:
+ *   {
+ *     type: 'dispatch.started',
+ *     ts: <epoch-ms>,
+ *     dispatchId: <string>,
+ *     agentId: <string>,
+ *     taskTitle: <string>,
+ *     startedAt: <ISO string>,
+ *   }
+ *
+ * No `replay-on-connect`: the banner-clear is the only consumer, and
+ * replaying a stale started event when a viewer opens AFTER terminal has
+ * already rendered would silently wipe the terminal banner. Live broadcast
+ * only — there's no stale banner to clear when the page just loaded.
+ */
+function emitDispatchStarted(event) {
+  if (!event || typeof event !== 'object') return;
+  if (!event.type) event.type = 'dispatch.started';
+  if (!event.ts) event.ts = _now();
+  _appendEventLineTo(_startedEventsFile(), event);
+  try { _emitter.emit('dispatch.started', event); } catch { /* never throw */ }
+}
+
+function onDispatchStarted(listener) {
+  _emitter.on('dispatch.started', listener);
+  return () => _emitter.off('dispatch.started', listener);
+}
+
+function readRecentStartedEvents() {
+  const cutoff = _now() - REPLAY_TTL_MS;
+  return _readLinesFrom(_startedEventsFile())
+    .map(line => { try { return JSON.parse(line); } catch { return null; } })
+    .filter(e => e && (e.ts || 0) >= cutoff);
+}
+
+function buildStartedEvent({ dispatchId, agentId, taskTitle, startedAt }) {
+  let safeTitle = '';
+  if (typeof taskTitle === 'string' && taskTitle) {
+    safeTitle = taskTitle.split('\n')[0].slice(0, 240);
+  }
+  return {
+    type: 'dispatch.started',
+    dispatchId,
+    agentId: agentId || null,
+    taskTitle: safeTitle,
+    startedAt: startedAt || null,
+  };
+}
+
 module.exports = {
   emitDispatchTerminal,
   onDispatchTerminal,
@@ -170,8 +247,14 @@ module.exports = {
   getLastTerminalForAgent,
   getLastTerminalForDispatch,
   buildTerminalEvent,
+  // dispatch.started (W-mq1m1wo5000nd78d)
+  emitDispatchStarted,
+  onDispatchStarted,
+  readRecentStartedEvents,
+  buildStartedEvent,
   // exposed for testing / dashboard tailer
   _eventsFile,
+  _startedEventsFile,
   MAX_RING_ENTRIES,
   REPLAY_TTL_MS,
 };

package/engine.js

@@ -37,6 +37,7 @@ const { resolveRuntime } = require('./engine/runtimes');
 const { assertStaleHeadOk } = require('./engine/spawn-agent');
 const adoGitAuth = require('./engine/ado-git-auth');
 const queries = require('./engine/queries');
+const dispatchEvents = require('./engine/dispatch-events');
 
 // ─── Paths ──────────────────────────────────────────────────────────────────
 
@@ -2684,6 +2685,28 @@ async function spawnAgent(dispatchItem, config) {
     };
     activeProcesses.set(id, initialProcInfo);
     registeredInActiveProcesses = true;
+
+    // W-mq1m1wo5000nd78d — emit dispatch.started symmetric with the
+    // dispatch.terminal event emitted from dispatch.js#completeDispatch. The
+    // dashboard's live-view client uses this to clear the prior dispatch's
+    // terminal banner when the same agent immediately starts a new run
+    // (otherwise the "✓ Task complete" / "✗ Task ended" banner from the
+    // previous dispatch lingers because startLiveStream only clears the
+    // banner on tab switch / agent change).
+    //
+    // ONLY emitted on fresh spawns — re-attach after engine restart goes
+    // through engine/cli.js and does NOT pass through here, so a re-attached
+    // dispatch (procInfo.reattached === true) won't synthesise a spurious
+    // started event that could clobber a still-live previous-dispatch
+    // banner that the user is mid-read on.
+    try {
+      dispatchEvents.emitDispatchStarted(dispatchEvents.buildStartedEvent({
+        dispatchId: id,
+        agentId,
+        taskTitle: dispatchItem.task,
+        startedAt,
+      }));
+    } catch (e) { log('warn', `emit dispatch.started: ${e.message}`); }
   } catch (spawnErr) {
     // Partial-setup cleanup (P-f4d2e8a1): tear down every artifact in the
     // reverse order it was created. Each step is conditional + best-effort

package/package.json

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