@yemi33/minions 0.1.2153 → 0.1.2154

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.2153",
+  "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"