@yemi33/minions 0.1.2136 → 0.1.2138

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)
@@ -7429,6 +7470,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
       safeWrite(notesPath, notes);
 
+      // W-mq1j85cj00055a8f — rewrite WI references that pointed at the
+      // now-archived inbox note to the persisted destination (notes.md).
+      try { shared.rewriteInboxRefsAcrossProjects(name, 'notes.md'); }
+      catch (e) { console.error('inbox-ref rewrite (persist):', e.message); }
+
       // Move to archive
       const archiveDir = path.join(MINIONS_DIR, 'notes', 'archive');
       if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
@@ -7468,6 +7514,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       safeWrite(kbFile, kbContent);
       queries.invalidateKnowledgeBaseCache();
 
+      // W-mq1j85cj00055a8f — rewrite WI references that pointed at the
+      // now-archived inbox note to the KB destination.
+      try { shared.rewriteInboxRefsAcrossProjects(name, `knowledge/${category}/${name}`); }
+      catch (e) { console.error('inbox-ref rewrite (promote-kb):', e.message); }
+
       // Move inbox item to archive
       const archiveDir = path.join(MINIONS_DIR, 'notes', 'archive');
       if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });

package/engine/consolidation.js

@@ -1155,7 +1155,22 @@ function archiveInboxFiles(files) {
 
   if (!fs.existsSync(ARCHIVE_DIR)) fs.mkdirSync(ARCHIVE_DIR, { recursive: true });
   for (const f of files) {
-    try { fs.renameSync(path.join(INBOX_DIR, f), shared.uniquePath(path.join(ARCHIVE_DIR, `${dateStamp()}-${f}`))); } catch (err) { log('warn', `Inbox archive: ${err.message}`); }
+    try {
+      // Resolve the final destination path BEFORE rename so the WI-ref
+      // rewrite can point at the actual on-disk location (uniquePath may
+      // suffix `-2`, `-3` … if a same-day collision exists).
+      const dest = shared.uniquePath(path.join(ARCHIVE_DIR, `${dateStamp()}-${f}`));
+      // W-mq1j85cj00055a8f — rewrite WI references that pointed at the
+      // now-archived inbox note to the archive destination. Computed
+      // relative to MINIONS_DIR so it matches the dashboard's relative-URL
+      // render convention. Wrapped so a rewrite failure can't break the
+      // archive step itself (which is the load-bearing operation here).
+      try {
+        const rel = path.relative(shared.MINIONS_DIR, dest).replace(/\\/g, '/');
+        shared.rewriteInboxRefsAcrossProjects(f, rel);
+      } catch (e) { log('warn', `Inbox-ref rewrite (${f}): ${e.message}`); }
+      fs.renameSync(path.join(INBOX_DIR, f), dest);
+    } catch (err) { log('warn', `Inbox archive: ${err.message}`); }
   }
 }
 

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/shared.js

@@ -5090,6 +5090,87 @@ function extractStructuredWorkItemPrRef(item) {
   return null;
 }
 
+// W-mq1j85cj00055a8f — when an inbox note (notes/inbox/<name>) leaves the
+// inbox (persisted to notes.md, promoted to knowledge/, or auto-archived by
+// consolidation), any work-item reference pointing at the old inbox path
+// turns into a broken link. Rewrite those references across every project's
+// work-items.json + the central one to the new canonical location.
+//
+// Match semantics (intentionally narrow per the WI scope):
+//   - Scope is strictly item.references[]; description prose is NOT scanned.
+//   - String entries: 'notes/inbox/<inboxName>' (anchored on start or '/').
+//   - Object entries: { url | path | href }. Other keys (label, kind, …) are
+//     preserved.
+//   - Trailing `?query` or `#fragment` is tolerated; substring overlaps in
+//     unrelated path segments (e.g. .../notes/inbox/foobar for foo.md) are
+//     NOT rewritten.
+//   - Archived work-items files are skipped — only live work-items.json paths
+//     surfaced by getProjects() + the central path are touched.
+//
+// Idempotent: re-running with the same inboxName after the rewrite is a
+// no-op (the references already read newLocation, which won't match the
+// notes/inbox/<inboxName> regex).
+//
+// Returns the count of references rewritten across all files (for logging).
+// Each file's mutate is wrapped in try/catch so one corrupt project can't
+// block the others.
+//
+// `opts._mutate` is an undocumented test seam — production callers always
+// take the default (the in-file `mutateWorkItems` closure reference). Tests
+// inject a wrapper to exercise the per-file try/catch boundary without
+// having to manufacture a real SQL-store failure.
+function rewriteInboxRefsAcrossProjects(inboxName, newLocation, opts = {}) {
+  if (!inboxName || typeof newLocation !== 'string' || !newLocation) return 0;
+  const baseName = String(inboxName).replace(/^.*[/\\]/, '').trim();
+  if (!baseName) return 0;
+  const escaped = baseName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const inboxRefRe = new RegExp(`(?:^|/)notes/inbox/${escaped}(?=$|[?#])`);
+  const _mutate = (opts && typeof opts._mutate === 'function') ? opts._mutate : mutateWorkItems;
+
+  let rewritten = 0;
+  const config = safeJson(path.join(MINIONS_DIR, 'config.json')) || {};
+  const candidates = [];
+  try {
+    for (const project of getProjects(config)) {
+      try { candidates.push(projectWorkItemsPath(project)); } catch { /* skip bad project entry */ }
+    }
+  } catch { /* getProjects failed — fall back to central only */ }
+  candidates.push(centralWorkItemsPath());
+
+  for (const wiPath of candidates) {
+    try {
+      _mutate(wiPath, items => {
+        if (!Array.isArray(items)) return items;
+        for (const item of items) {
+          if (!item || !Array.isArray(item.references)) continue;
+          for (let i = 0; i < item.references.length; i++) {
+            const ref = item.references[i];
+            if (typeof ref === 'string') {
+              if (inboxRefRe.test(ref)) {
+                item.references[i] = newLocation;
+                rewritten++;
+              }
+            } else if (ref && typeof ref === 'object') {
+              for (const key of ['url', 'path', 'href']) {
+                const v = ref[key];
+                if (typeof v === 'string' && inboxRefRe.test(v)) {
+                  ref[key] = newLocation;
+                  rewritten++;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        return items;
+      });
+    } catch (e) {
+      try { console.warn(`rewriteInboxRefsAcrossProjects(${wiPath}): ${e.message}`); } catch { /* logging best-effort */ }
+    }
+  }
+  return rewritten;
+}
+
 function extractWorkItemPrRef(item) {
   if (!item || typeof item !== 'object') return null;
   const fromStructured = extractStructuredWorkItemPrRef(item);
@@ -6500,6 +6581,7 @@ module.exports = {
   extractPrRefFromText,
   extractWorkItemPrRef,
   extractStructuredWorkItemPrRef,
+  rewriteInboxRefsAcrossProjects,
   getProjectPrScope,
   getPrNumber,
   getPrDisplayId,

package/engine/watches.js

@@ -320,7 +320,10 @@ function evaluateWatch(watch, state) {
   if (!tt.conditions.includes(condition)) return { triggered: false, message: `Unknown condition: ${condition}` };
 
   const entity = tt.fetchEntity(target, state || {});
-  if (!entity) return { triggered: false, message: `${tt.label} ${target} not found` };
+  if (!entity) {
+    const targetStr = typeof target === 'string' ? target : JSON.stringify(target);
+    return { triggered: false, message: `${tt.label} ${targetStr} not found` };
+  }
 
   const prevState = watch._lastState || {};
   let primary;
@@ -645,21 +648,35 @@ async function _runActionTask(task) {
 /**
  * Internal: capture state snapshot for a watch target.
  * Dispatches to the registered target type's captureState.
+ *
+ * W-mq1n83pw000844b8 — Preserve prior state on transient fetchEntity null
+ * (and on captureState exceptions / unknown target types). The old behavior
+ * wiped to {} whenever the entity could not be resolved, which then made
+ * line 431 re-initialize via captureState on the next tick, losing
+ * type-specific dedup keys (gh-author-prs `numbers`, work-item
+ * `_unchangedTicks`, pipeline `_stuckStageTicks`). The result was watches
+ * re-firing for already-seen entities after every engine restart while a
+ * plugin's background fetch cache warmed up. Preserving prevState is
+ * harmless for types where fetchEntity-null means "entity deleted" because
+ * evaluate already gates on entity being non-null, and is the bug-free
+ * behavior for plugins with transient nulls (cache miss, network hiccup).
  */
 function _captureState(watch, state) {
+  const prevState = watch._lastState || {};
   const tt = TARGET_TYPES[watch.targetType];
-  if (!tt) return {};
+  if (!tt) return prevState;
   const entity = tt.fetchEntity(watch.target, state || {});
-  if (!entity) return {};
+  if (!entity) return prevState;
   try {
     // P-w5b8d2c9 — Phase 2.2: pass prevState so captureState can carry
     // forward unchanged-tick counters (e.g. _unchangedTicks for work-item
     // stalled, _stuckStageTicks for pipeline stuck-in-stage). Existing
     // captureState fns that take only 1 arg ignore this — backward-compat.
-    return tt.captureState(entity, watch._lastState || {}) || {};
+    const out = tt.captureState(entity, prevState);
+    return (out && typeof out === 'object') ? out : prevState;
   } catch (err) {
     log('warn', `_captureState ${watch.targetType}: ${err.message}`);
-    return {};
+    return prevState;
   }
 }
 

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.2138",
   "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"