@yemi33/minions 0.1.2137 → 0.1.2138

package/dashboard.js

@@ -7470,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 });
@@ -7509,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/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/package.json

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