@yemi33/minions 0.1.2152 → 0.1.2154

package/dashboard/js/refresh.js

@@ -214,6 +214,30 @@ function _changed(key, value, version) {
   return true;
 }
 
+// Conditional JSON fetch for the heavy per-page endpoints (browser-OOM fix).
+// /api/knowledge (~4.5MB) and /api/work-items (~4.2MB) were re-fetched AND
+// re-parsed on every 4s refresh tick — ~11MB of allocation churn per tick that
+// OOM-crashed the tab during active foreground use. These endpoints emit an
+// input-mtime ETag server-side (serveFreshJson + handleKnowledgeList), so send
+// If-None-Match off the last-seen ETag and resolve { notModified:true } on a
+// 304. Callers skip the parse + render entirely and keep their last-rendered
+// state, so an idle dashboard drops from ~11MB/tick to ~0. Routes through
+// safeFetch (like the /api/status poll it mirrors) for the 15s abort timeout +
+// X-Minions-Dashboard-* tab/visibility correlation headers. Per-URL ETag cache;
+// a non-304 error rejects so each call site's existing .catch arm still fires.
+var _condFetchEtags = {};
+function _condFetchJson(url) {
+  var headers = {};
+  if (_condFetchEtags[url]) headers['If-None-Match'] = _condFetchEtags[url];
+  return safeFetch(url, { headers }).then(function (r) {
+    if (r.status === 304) return { notModified: true, data: null };
+    if (!r.ok) return Promise.reject(new Error('HTTP ' + r.status));
+    var etag = r.headers && r.headers.get ? r.headers.get('etag') : null;
+    if (etag) _condFetchEtags[url] = etag;
+    return r.json().then(function (data) { return { notModified: false, data: data }; });
+  });
+}
+
 function _formatCcPowerLabel(autoMode) {
   var runtime = autoMode && autoMode.ccCli ? String(autoMode.ccCli) : 'claude';
   var runtimeLabel = runtime.charAt(0).toUpperCase() + runtime.slice(1);
@@ -518,7 +542,11 @@ function _processStatusUpdate(data, opts) {
     window._lastRequestedSeq = window._lastRequestedSeq || {};
     window._lastRequestedSeq.prd = seq;
     Promise.all([
-      fetch('/api/prd').then(function (r) { return r.ok ? r.json() : null; }),
+      // Conditional fetch (browser-OOM fix): flatten to null on a 304 or error,
+      // which the cached status/progress fallback below already handles. The
+      // .catch keeps a prd failure from rejecting the whole Promise.all and
+      // starving the verify-guides slice (matches the old `r.ok ? … : null`).
+      _condFetchJson('/api/prd').then(function (resp) { return resp.notModified ? null : resp.data; }).catch(function () { return null; }),
       fetch('/api/verify-guides').then(function (r) { return r.ok ? r.json() : null; }),
     ])
       .then(function (results) {
@@ -616,10 +644,12 @@ function _processStatusUpdate(data, opts) {
     const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
     window._lastRequestedSeq = window._lastRequestedSeq || {};
     window._lastRequestedSeq.prs = seq;
-    fetch('/api/pull-requests')
-      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
-      .then(function (fresh) {
+    _condFetchJson('/api/pull-requests')
+      .then(function (resp) {
         if (seq < (window._lastRequestedSeq.prs || 0)) return;
+        // 304 → PR list unchanged; keep last-rendered state + cross-slice sigs.
+        if (resp.notModified) return;
+        const fresh = resp.data;
         const list = Array.isArray(fresh) ? fresh : (window._lastPullRequests || []);
         const wasFirstNonEmpty = !Array.isArray(window._lastPullRequests);
         window._lastPullRequests = list;
@@ -695,11 +725,12 @@ function _processStatusUpdate(data, opts) {
     const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
     window._lastRequestedSeq = window._lastRequestedSeq || {};
     window._lastRequestedSeq.dispatch = seq;
-    fetch('/api/dispatch')
-      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
-      .then(function (fresh) {
+    _condFetchJson('/api/dispatch')
+      .then(function (resp) {
         if (seq < (window._lastRequestedSeq.dispatch || 0)) return;
-        const d = fresh || window._lastDispatch;
+        // 304 → dispatch queue unchanged; keep last-rendered panes + scroll.
+        if (resp.notModified) return;
+        const d = resp.data || window._lastDispatch;
         if (d) window._lastDispatch = d;
         _safeRender('dispatch', function() { renderDispatch(d, dispatchOpts); });
         // Dispatch is the third cross-slice edge: derivePlanStatus reads
@@ -785,10 +816,12 @@ function _processStatusUpdate(data, opts) {
     const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
     window._lastRequestedSeq = window._lastRequestedSeq || {};
     window._lastRequestedSeq.workItems = seq;
-    fetch('/api/work-items')
-      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
-      .then(function (fresh) {
+    _condFetchJson('/api/work-items')
+      .then(function (resp) {
         if (seq < (window._lastRequestedSeq.workItems || 0)) return;
+        // 304 → list unchanged; keep the last-rendered rows + DOM untouched.
+        if (resp.notModified) return;
+        const fresh = resp.data;
         const list = Array.isArray(fresh) ? fresh : (window._lastWorkItems || []);
         window._lastWorkItems = list;
         _safeRender('workItems', function() { renderWorkItems(list); });

package/dashboard/js/render-kb.js

@@ -32,13 +32,18 @@ function _formatSweepElapsed(startedAt) {
 
 async function refreshKnowledgeBase() {
   try {
-    // Always update _kbData — cross-slice readers (e.g. command-center.js
-    // suggestion lookup) depend on it staying fresh even when the renderer is
-    // skipped (S1).
-    _kbData = await fetch('/api/knowledge').then(r => r.json());
-    // Skip the full kb-list/kb-tabs rewrite when /api/knowledge returned the
-    // same payload as last tick. Dedicated cache key 'kbPayload' avoids
-    // colliding with any other tracked slice (S1).
+    // Conditional fetch (browser-OOM fix): /api/knowledge is ~4.5MB and was
+    // re-fetched + re-parsed every 4s tick, the single biggest contributor to
+    // the heap churn that crashed the tab. On a 304 the payload is unchanged,
+    // so _kbData (which cross-slice readers like command-center.js depend on)
+    // is already current — skip the parse and the render entirely.
+    const resp = await _condFetchJson('/api/knowledge');
+    if (resp.notModified) return;
+    _kbData = resp.data;
+    // Second-level guard: an mtime-only ETag bust (e.g. a sweep touched a file)
+    // can arrive with byte-identical content — skip the full kb-list/kb-tabs
+    // rewrite when the payload matches last tick. Dedicated cache key
+    // 'kbPayload' avoids colliding with any other tracked slice (S1).
     if (typeof _changed !== 'function' || _changed('kbPayload', _kbData)) {
       renderKnowledgeBase();
     }

package/dashboard.js

@@ -6425,6 +6425,33 @@ const server = http.createServer(async (req, res) => {
 
   async function handleKnowledgeList(req, res) {
     const entries = await getKnowledgeBaseEntries();
+    // Content ETag (browser-OOM fix). /api/knowledge is ~4.5MB and the dashboard
+    // polls it every 4s per foregrounded tab; without a 304 path the browser
+    // re-downloaded + re-parsed the whole payload every tick, churning enough
+    // heap to OOM-crash the tab. Derive the signature from the already-cached
+    // entry metadata (count + per-file mtime/size) instead of stat-walking the
+    // knowledge tree — that tree is ~9k files and the walk measured ~185ms,
+    // which would block the event loop on every poll. getKnowledgeBaseEntries
+    // is O(1) on a cache hit (30s TTL + explicit invalidation on KB writes and
+    // sweeps), so this adds ~nothing on the hot path. Two small stats fold in
+    // the sweep-badge files so the in-flight indicator still busts the tag.
+    let h = 2166136261;
+    for (const e of entries) {
+      h = Math.imul(h ^ ((e.size || 0) >>> 0), 16777619);
+      h = Math.imul(h ^ Math.floor(e.sortTs || 0), 16777619);
+    }
+    const sweepMtime = _maxInputMtimeMs([
+      path.join(ENGINE_DIR, 'kb-swept.json'),
+      path.join(ENGINE_DIR, 'kb-sweep-state.json'),
+    ]);
+    const kbEtag = '"knowledge-' + entries.length + '-' + (h >>> 0).toString(36) + '-' + sweepMtime + '"';
+    res.setHeader('ETag', kbEtag);
+    res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
+    if (req && req.headers && req.headers['if-none-match'] === kbEtag) {
+      res.statusCode = 304;
+      res.end();
+      return;
+    }
     const result = {};
     for (const cat of shared.KB_CATEGORIES) result[cat] = [];
     for (const e of entries) {

package/engine/consolidation.js

@@ -802,13 +802,11 @@ function consolidateWithLLM(items, existingNotes, files, config) {
   const dupCheck = checkDuplicateHash(items);
   if (dupCheck.isDuplicate) {
     log('info', `Skipped LLM consolidation: ${dupCheck.count}/${dupCheck.total} items are duplicates (hash: ${dupCheck.hash.slice(0, 8)})`);
-    // Archive duplicate files directly
-    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 (dup skip): ${err.message}`); }
-    }
+    // Archive duplicate files through the shared helper so WI references +
+    // completion-report artifact links get repointed to the archive path too
+    // (W-mq1j85cj00055a8f) — the inline rename here used to skip that rewrite,
+    // leaving dup-note links dangling.
+    archiveInboxFiles(files);
     for (const f of files) _processingFiles.delete(f);
     _consolidationInFlight = false;
     _consolidationStartedAt = 0;

package/engine/shared.js

@@ -5297,10 +5297,18 @@ function extractStructuredWorkItemPrRef(item) {
 // 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.
+//   - item.references[]: string 'notes/inbox/<inboxName>' (anchored on start
+//     or '/') or object { url | path | href }. Other keys (label, kind, …)
+//     are preserved. Description prose is NOT scanned.
+//   - item._artifacts.notes[] (completion-report note links, written by
+//     lifecycle.promoteCompletionArtifacts): the work-item renderer resolves
+//     the clickable pill from note.file — a prefixed basename ('archive:<base>'
+//     / 'kb:<cat>/<file>' / bare inbox base) — so we re-encode `file` for the
+//     destination via _artifactNoteFileToken AND rewrite the `path` field.
+//     This is the link shape agent completions actually populate, so it's the
+//     one that must survive auto-archive.
+//   - item.artifacts[] (raw completion artifacts): the `path` field is
+//     rewritten the same way as references.
 //   - Trailing `?query` or `#fragment` is tolerated; substring overlaps in
 //     unrelated path segments (e.g. .../notes/inbox/foobar for foo.md) are
 //     NOT rewritten.
@@ -5319,12 +5327,29 @@ function extractStructuredWorkItemPrRef(item) {
 // 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.
+
+// Map a consolidation destination to the prefixed `file` token the work-item
+// artifact renderer (dashboard/js/render-work-items.js) uses for note pills:
+//   notes/archive/<base>     → 'archive:<base>'  (openInboxNote resolves in archive)
+//   knowledge/<cat>/<file>   → 'kb:<cat>/<file>' (kbOpenItem)
+//   notes.md / anything else → null  (no per-note anchor — leave file as-is)
+function _artifactNoteFileToken(newLocation) {
+  const nl = String(newLocation).replace(/\\/g, '/');
+  if (/(?:^|\/)notes\/archive\//.test(nl)) return 'archive:' + nl.replace(/^.*\//, '');
+  const kb = nl.match(/(?:^|\/)knowledge\/([^/]+)\/(.+)$/);
+  if (kb) return 'kb:' + kb[1] + '/' + kb[2];
+  return null;
+}
+
 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}(?=$|[?#])`);
+  // The note-pill `file` token for the destination (archive:/kb:/…). Computed
+  // once — it depends only on newLocation, not the item being scanned.
+  const fileToken = _artifactNoteFileToken(newLocation);
   const _mutate = (opts && typeof opts._mutate === 'function') ? opts._mutate : mutateWorkItems;
 
   let rewritten = 0;
@@ -5342,22 +5367,53 @@ function rewriteInboxRefsAcrossProjects(inboxName, newLocation, opts = {}) {
       _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;
+          if (!item) continue;
+          // references[] — string | { url | path | href }.
+          if (Array.isArray(item.references)) {
+            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++;
-                  break;
                 }
+              } 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;
+                  }
+                }
+              }
+            }
+          }
+          // _artifacts.notes[] — completion-report note links. Match on the
+          // inbox `path` (object form) or the bare basename `file` (the inbox
+          // pill token), then re-encode `file` for the destination and fix
+          // `path`. The renderer keys the clickable pill off `file`, so the
+          // re-encode is what actually un-dangles the link.
+          const notes = item._artifacts && item._artifacts.notes;
+          if (Array.isArray(notes)) {
+            for (let i = 0; i < notes.length; i++) {
+              const n = notes[i];
+              if (typeof n === 'string') {
+                if (n === baseName && fileToken) { notes[i] = fileToken; rewritten++; }
+              } else if (n && typeof n === 'object') {
+                let hit = false;
+                if (typeof n.path === 'string' && inboxRefRe.test(n.path)) { n.path = newLocation; hit = true; }
+                if (n.file === baseName && fileToken) { n.file = fileToken; hit = true; }
+                if (hit) rewritten++;
+              }
+            }
+          }
+          // artifacts[] — raw completion artifacts ({ type, path, … }).
+          if (Array.isArray(item.artifacts)) {
+            for (const a of item.artifacts) {
+              if (a && typeof a === 'object' && typeof a.path === 'string' && inboxRefRe.test(a.path)) {
+                a.path = newLocation;
+                rewritten++;
               }
             }
           }

package/package.json

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