@yemi33/minions 0.1.2153 → 0.1.2155

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/db/migrations/013-backfill-broken-note-links.js

@@ -0,0 +1,31 @@
+// engine/db/migrations/013-backfill-broken-note-links.js
+//
+// One-time data repair (not a schema change). Before the work-item rewriter
+// covered completion-report artifact links (W-mq1j85cj00055a8f, extended to
+// _artifacts.notes[] / artifacts[]), any inbox note the engine auto-archived
+// left the work item's note link pointing at the gone `notes/inbox/<name>` path
+// — a dangling pill. This migration runs the backfill exactly once on the next
+// engine start: it scans existing work_items, finds links whose inbox file is
+// missing, discovers where the note went (notes/archive/ or knowledge/<cat>/),
+// and repoints them. Best-effort and self-isolating — wrapped so a failure can
+// never wedge boot or roll back the migration batch.
+
+module.exports = {
+  version: 13,
+  description: 'one-time backfill: repoint broken inbox note links in existing work items',
+  up(db) {
+    try {
+      const { backfillBrokenNoteLinks } = require('../../note-link-backfill');
+      const res = backfillBrokenNoteLinks(db);
+      if (res && res.fixedLinks > 0) {
+        // eslint-disable-next-line no-console -- migrate.js logs progress to stdout
+        console.log(`[db-migrate] v13: repointed ${res.fixedLinks} broken note link(s) across ${res.fixedItems} work item(s) (${res.scanned} scanned)`);
+      }
+    } catch (e) {
+      // One-time cosmetic repair — never block boot. Record the version anyway
+      // so it doesn't retry forever against the same un-repairable state.
+      // eslint-disable-next-line no-console -- surface the skip without throwing
+      console.warn(`[db-migrate] v13: note-link backfill skipped: ${e && e.message ? e.message : e}`);
+    }
+  },
+};

package/engine/note-link-backfill.js

@@ -0,0 +1,202 @@
+// engine/note-link-backfill.js
+//
+// One-time repair for work-item note links that broke BEFORE the live
+// rewrite landed (W-mq1j85cj00055a8f extended to _artifacts.notes / artifacts).
+//
+// Before the rewriter covered completion-report artifact links, any inbox note
+// that the engine auto-archived (or that was promoted to KB) left the work
+// item's link pointing at the now-gone `notes/inbox/<name>` path — a dangling
+// pill in the dashboard. This module scans existing work items, finds links
+// whose inbox file is GONE, discovers where the note actually went (the flat
+// `notes/archive/` dir or a `knowledge/<cat>/` dir), and repoints the link —
+// re-encoding the `_artifacts.notes[].file` token to the renderer's
+// `archive:<base>` / `kb:<cat>/<file>` form so the pill resolves again.
+//
+// It only ever touches links that are PROVABLY broken (inbox file missing) AND
+// resolvable (a matching archive/KB file exists). Valid links, already-relocated
+// tokens, and notes with no discoverable destination (e.g. merged into the flat
+// notes.md) are left untouched. Idempotent: a second pass finds nothing because
+// the repaired links no longer reference `notes/inbox/`.
+//
+// Wired as a one-time SQL migration (db/migrations/013-*) so it runs exactly
+// once on the next engine start after an update. Updates the canonical SQL
+// `work_items` rows only; the JSON mirror self-heals on the next mutateWorkItems
+// write and SQL is what readers serve (work-items-store), so rewriting the
+// passive mirror here would only risk dropping rows for no benefit.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const INBOX_REF_RE = /(?:^|\/)notes\/inbox\/([^/?#]+)/;
+
+// Extract the inbox basename from a `…/notes/inbox/<name>` string (tolerating a
+// trailing ?query / #fragment), or null if the string isn't an inbox ref.
+function inboxNameFromRef(str) {
+  if (typeof str !== 'string') return null;
+  const m = str.match(INBOX_REF_RE);
+  return m ? m[1] : null;
+}
+
+// Build a resolver: inbox basename → { newLocation, fileToken } | null.
+//   - null when the note is STILL in the inbox (link isn't broken), or when no
+//     destination can be discovered (note merged into notes.md, or deleted).
+//   - newLocation is the MINIONS_DIR-relative path; fileToken is the prefixed
+//     basename the work-item renderer resolves for note pills.
+// The archive dir is flat: consolidation writes `${YYYY-MM-DD}-${name}` (with an
+// optional uniquePath `-N` collision suffix). We index each archived file by the
+// basename it derived from (date prefix stripped) and by its literal name.
+function buildNoteResolver(dirs) {
+  const inboxDir = dirs.inboxDir;
+  const archiveDir = dirs.archiveDir;
+  const knowledgeDir = dirs.knowledgeDir;
+  const kbCategories = Array.isArray(dirs.kbCategories) ? dirs.kbCategories : [];
+  // Reuse the live rewriter's encoder so the backfill and the live path emit
+  // byte-identical pill tokens (one source for the archive:/kb: grammar).
+  const tokenFor = require('./shared')._artifactNoteFileToken;
+
+  const archiveByBase = new Map();
+  let archiveFiles = [];
+  try { archiveFiles = fs.readdirSync(archiveDir); } catch { archiveFiles = []; }
+  for (const f of archiveFiles) {
+    const origin = f.replace(/^\d{4}-\d{2}-\d{2}-/, '');
+    for (const key of new Set([origin, f])) {
+      const prev = archiveByBase.get(key);
+      // Lexicographic max keeps the newest date-prefixed file for a given note.
+      if (!prev || f > prev) archiveByBase.set(key, f);
+    }
+  }
+
+  const kbByBase = new Map();
+  for (const cat of kbCategories) {
+    let files = [];
+    try { files = fs.readdirSync(path.join(knowledgeDir, cat)); } catch { files = []; }
+    for (const f of files) if (!kbByBase.has(f)) kbByBase.set(f, cat + '/' + f);
+  }
+
+  return function resolve(baseName) {
+    if (!baseName) return null;
+    try { if (fs.existsSync(path.join(inboxDir, baseName))) return null; } catch { /* treat as gone */ }
+    const arch = archiveByBase.get(baseName);
+    if (arch) { const nl = 'notes/archive/' + arch; return { newLocation: nl, fileToken: tokenFor(nl) }; }
+    const kb = kbByBase.get(baseName);
+    if (kb) { const nl = 'knowledge/' + kb; return { newLocation: nl, fileToken: tokenFor(nl) }; }
+    return null;
+  };
+}
+
+// Repoint every broken inbox note link on one work item in place. `resolve` is a
+// buildNoteResolver() result (returns null for non-broken / unresolvable). Mirrors
+// the link shapes shared.rewriteInboxRefsAcrossProjects handles: references[],
+// _artifacts.notes[] (string + object), and artifacts[].path. Returns the count
+// of links repointed.
+function repointItemNoteLinks(item, resolve) {
+  if (!item || typeof item !== 'object') return 0;
+  let fixed = 0;
+
+  if (Array.isArray(item.references)) {
+    for (let i = 0; i < item.references.length; i++) {
+      const ref = item.references[i];
+      if (typeof ref === 'string') {
+        const name = inboxNameFromRef(ref);
+        if (name) { const d = resolve(name); if (d) { item.references[i] = d.newLocation; fixed++; } }
+      } else if (ref && typeof ref === 'object') {
+        for (const key of ['url', 'path', 'href']) {
+          const name = inboxNameFromRef(ref[key]);
+          if (name) { const d = resolve(name); if (d) { ref[key] = d.newLocation; fixed++; break; } }
+        }
+      }
+    }
+  }
+
+  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') {
+        // Bare basename = an inbox pill. Skip tokens already relocated.
+        if (n.startsWith('archive:') || n.startsWith('kb:')) continue;
+        const d = resolve(n);
+        if (d && d.fileToken) { notes[i] = d.fileToken; fixed++; }
+      } else if (n && typeof n === 'object') {
+        let name = inboxNameFromRef(n.path);
+        if (!name && typeof n.file === 'string'
+            && !n.file.startsWith('archive:') && !n.file.startsWith('kb:')) {
+          name = n.file;
+        }
+        if (name) {
+          const d = resolve(name);
+          if (d) {
+            if (typeof n.path === 'string') n.path = d.newLocation;
+            if (d.fileToken && typeof n.file === 'string') n.file = d.fileToken;
+            fixed++;
+          }
+        }
+      }
+    }
+  }
+
+  if (Array.isArray(item.artifacts)) {
+    for (const a of item.artifacts) {
+      if (a && typeof a === 'object') {
+        const name = inboxNameFromRef(a.path);
+        if (name) { const d = resolve(name); if (d) { a.path = d.newLocation; fixed++; } }
+      }
+    }
+  }
+
+  return fixed;
+}
+
+// Scan the canonical SQL `work_items` table and repair broken note links in
+// place. db is a node:sqlite DatabaseSync (the migration's connection). Per-row
+// try/catch so one corrupt row can't abort the pass. Returns a summary.
+function backfillBrokenNoteLinks(db, opts = {}) {
+  const shared = require('./shared');
+  const minionsDir = opts.minionsDir || shared.MINIONS_DIR;
+  const resolve = buildNoteResolver({
+    inboxDir: path.join(minionsDir, 'notes', 'inbox'),
+    archiveDir: path.join(minionsDir, 'notes', 'archive'),
+    knowledgeDir: path.join(minionsDir, 'knowledge'),
+    kbCategories: shared.KB_CATEGORIES,
+  });
+
+  let scopes;
+  try {
+    scopes = db.prepare('SELECT DISTINCT scope FROM work_items').all().map(r => r.scope);
+  } catch {
+    return { scanned: 0, fixedItems: 0, fixedLinks: 0 };
+  }
+
+  const now = opts.now || Date.now();
+  const upd = db.prepare('UPDATE work_items SET data = ?, updated_at = ? WHERE scope = ? AND id = ?');
+  let scanned = 0, fixedItems = 0, fixedLinks = 0;
+
+  for (const scope of scopes) {
+    let rows;
+    try { rows = db.prepare('SELECT id, data FROM work_items WHERE scope = ?').all(scope); } catch { continue; }
+    for (const row of rows) {
+      let item;
+      try { item = JSON.parse(row.data); } catch { continue; }
+      scanned++;
+      try {
+        const n = repointItemNoteLinks(item, resolve);
+        if (n > 0) {
+          upd.run(JSON.stringify(item), now, scope, item.id);
+          fixedItems++;
+          fixedLinks += n;
+        }
+      } catch { /* skip unfixable row */ }
+    }
+  }
+
+  return { scanned, fixedItems, fixedLinks };
+}
+
+module.exports = {
+  inboxNameFromRef,
+  buildNoteResolver,
+  repointItemNoteLinks,
+  backfillBrokenNoteLinks,
+};

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++;
               }
             }
           }
@@ -7447,6 +7503,7 @@ module.exports = {
   extractWorkItemPrRef,
   extractStructuredWorkItemPrRef,
   rewriteInboxRefsAcrossProjects,
+  _artifactNoteFileToken, // exported so the one-time note-link backfill shares the token grammar
   getProjectPrScope,
   getPrNumber,
   getPrDisplayId,

package/package.json

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