@yemi33/minions 0.1.2137 → 0.1.2139

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

@@ -758,6 +758,7 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
             [FAILURE_CLASS.EMPTY_OUTPUT]: 'agent produced no output \u2014 likely crashed on startup',
             [FAILURE_CLASS.BUILD_FAILURE]: 'build/test/lint failure in output',
             [FAILURE_CLASS.MERGE_CONFLICT]: 'merge conflict',
+            [FAILURE_CLASS.DEPENDENCY_MERGE_SETUP]: 'dependency merge setup failed',
             [FAILURE_CLASS.MAX_TURNS]: 'reached max turn limit',
             [FAILURE_CLASS.TIMEOUT]: 'timed out waiting for agent',
             [FAILURE_CLASS.SPAWN_ERROR]: 'agent process failed to start',

package/engine/shared.js

@@ -3519,6 +3519,7 @@ const FAILURE_CLASS = {
   WORKTREE_PREFLIGHT: 'worktree-preflight', // Pre-spawn worktree validation rejected (nested-in-project, drive-root collapse) — never retryable
   WORKTREE_DIRTY: 'worktree-dirty',         // #2996: reused worktree had uncommitted edits and the engine could not auto-heal (or already quarantined). Non-retryable for this dispatch — next discovery cycle creates a fresh worktree.
   WORKTREE_DIVERGENT: 'worktree-divergent', // #2996: reused worktree's local branch was N commits ahead of origin (unsafe to reset, may contain unpushed agent work). Engine quarantined the worktree + backed up the local ref; non-retryable for this dispatch.
+  DEPENDENCY_MERGE_SETUP: 'dependency-merge-setup', // Dependency pre-merge plumbing (stash/status/reset) failed before a real file conflict was verified. Retryable so a fresh worktree can recover.
   INVALID_KEEP_PROCESSES_WORKDIR: 'invalid-keep-processes-workdir', // W-mp6k7ywi000fa33c: keep-pids.json declared a cwd that is not a real git worktree (likely a selective copy of the repo) — never retryable; agent must rerun in a real worktree
   INVALID_KEEP_PROCESSES_SCHEMA: 'invalid-keep-processes-schema', // W-mp7i902u000l991f: keep-pids.json failed validation for a reason other than workdir (pids-missing, ttl-too-long, expires_at-missing, pids-too-many, port-invalid, etc.) — agent wrote the wrong shape; never retryable until they fix the file
   INVALID_MANAGED_SPAWN: 'invalid-managed-spawn', // P-7a3b1c92: agents/<id>/managed-spawn.json failed validator (bad schema, broken workdir, executable/env not on allowlist, healthcheck shape wrong). Engine refuses to spawn any spec — agent must fix file; never retryable as-is.
@@ -5090,6 +5091,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 +6582,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

@@ -208,6 +208,51 @@ function parseConflictFiles(mergeOutput) {
   return [...new Set(files)]; // dedupe
 }
 
+function gitOutputToString(result) {
+  if (result == null) return '';
+  if (Buffer.isBuffer(result)) return result.toString();
+  if (typeof result === 'string') return result;
+  if (result.stdout != null) return gitOutputToString(result.stdout);
+  return String(result);
+}
+
+function gitErrorOutput(err) {
+  return [
+    err?.message || '',
+    gitOutputToString(err?.stdout),
+    gitOutputToString(err?.stderr),
+  ].filter(Boolean).join('\n');
+}
+
+async function listUnmergedFiles(worktreePath, gitOpts = {}) {
+  try {
+    const out = await shared.shellSafeGit(['diff', '--name-only', '--diff-filter=U'], { ...gitOpts, cwd: worktreePath });
+    return gitOutputToString(out).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+  } catch (e) {
+    log('warn', `Failed to inspect unmerged files in ${worktreePath}: ${e.message}`);
+    return [];
+  }
+}
+
+function classifyDepMergeFailureOutput(errOutput, unmergedFiles = []) {
+  const output = String(errOutput || '');
+  const files = Array.isArray(unmergedFiles) ? unmergedFiles.filter(Boolean) : [];
+  const conflictFiles = files.length > 0 ? files : parseConflictFiles(output);
+  const hasConflictSignal = files.length > 0
+    || /\bCONFLICT \(/.test(output)
+    || /Automatic merge failed/i.test(output)
+    || /fix conflicts/i.test(output)
+    || /you have unmerged paths/i.test(output);
+  const stashPlumbingFailed = /(?:fatal:\s*)?stash failed/i.test(output)
+    || /cannot save.*stash/i.test(output)
+    || /could not.*stash/i.test(output);
+  return {
+    isConflict: hasConflictSignal,
+    isPlumbingFailure: stashPlumbingFailed && !hasConflictSignal,
+    conflictFiles: hasConflictSignal ? conflictFiles : [],
+  };
+}
+
 // Build the work item used by the dep-merge-failure auto-queue path
 // (W-mpcwojgr000a0244). Routes the conflict-fix through the shared-branch
 // dispatch path (`branchStrategy: 'shared-branch'` + `featureBranch:
@@ -2029,6 +2074,8 @@ async function spawnAgent(dispatchItem, config) {
           let depMergeFailed = false;
           let depConflictBranch = null; // track which dep branch caused the conflict
           let depConflictFiles = [];    // conflicting file names parsed from git output
+          let depMergeSetupFailed = false;
+          let depMergeSetupReason = '';
           // W-mpcuc8i80003a7b3 — track whether ANY git op in the dep phase
           // failed with an ADO auth signature. If so, we escalate as
           // FAILURE_CLASS.AUTH (non-retryable + dedup'd inbox alert) instead
@@ -2186,14 +2233,18 @@ async function spawnAgent(dispatchItem, config) {
           let stashed = false;
           if (!depMergeFailed && !skipDepMerge && prunedDeps.length > 0) {
             try {
-              const statusOut = (await shared.shellSafeGit(['status', '--porcelain'], { ..._gitOpts, cwd: worktreePath })).stdout.toString().trim();
+              const statusOut = gitOutputToString(await shared.shellSafeGit(['status', '--porcelain'], { ..._gitOpts, cwd: worktreePath })).trim();
               if (statusOut) {
                 await shared.shellSafeGit(['stash', 'push', '--include-untracked', '-m', 'engine: stash before dep re-merge'], { ..._gitOpts, cwd: worktreePath });
                 stashed = true;
                 log('info', `Stashed uncommitted changes in ${branchName} before dep merge`);
               }
             } catch (stashErr) {
-              log('warn', `Failed to stash changes in ${branchName} before dep merge: ${stashErr.message}`);
+              const stashMsg = gitErrorOutput(stashErr);
+              depMergeFailed = true;
+              depMergeSetupFailed = true;
+              depMergeSetupReason = `Dependency merge setup failed while stashing local changes in ${branchName}: ${stashMsg || stashErr.message}`;
+              log('warn', depMergeSetupReason);
             }
           }
           if (!depMergeFailed && !skipDepMerge) {
@@ -2222,41 +2273,49 @@ async function spawnAgent(dispatchItem, config) {
                   }
                   log('info', `Successfully re-merged all ${prunedDeps.length} dep branches after reset for ${branchName}`);
                 } catch (resetErr) {
-                  const errOutput = (resetErr.message || '') + '\n' + (resetErr.stdout?.toString?.() || '') + '\n' + (resetErr.stderr?.toString?.() || '');
+                  const errOutput = gitErrorOutput(resetErr);
                   log('warn', `Failed to reset and re-merge deps for ${branchName}: ${resetErr.message}`);
                   if (adoGitAuth.isAdoAuthFailure(resetErr)) _depAuthFailed = true;
                   try { await shared.shellSafeGit(['merge', '--abort'], { ..._gitOpts, cwd: worktreePath }); } catch (_) { /* no merge in progress */ }
+                  const unmergedFiles = await listUnmergedFiles(worktreePath, _gitOpts);
+                  const depFailure = classifyDepMergeFailureOutput(errOutput, unmergedFiles);
+                  if (depFailure.isPlumbingFailure) {
+                    depMergeSetupFailed = true;
+                    depMergeSetupReason = `Dependency merge setup failed in engine git plumbing for ${branchName}: ${errOutput.split('\n').find(Boolean) || resetErr.message}`;
+                  }
                   // Post-mortem: incremental simulation to identify which dep caused the conflict (#958)
                   // Uses same chained merge-tree approach as pre-flight to catch inter-dep conflicts
                   const pmMainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-                  try {
-                    const sim = await preflightMergeSimulation(prunedDeps, pmMainRef, _gitOpts, rootDir);
-                    if (!sim.ok) {
-                      depConflictBranch = sim.conflictBranch;
-                      depConflictFiles = sim.conflictFiles;
-                      _isInterDepConflict = sim.isInterDep;
-                      _preflightConflictPrev = sim.prevBranch;
+                  if (!depMergeSetupFailed || depFailure.isConflict) {
+                    try {
+                      const sim = await preflightMergeSimulation(prunedDeps, pmMainRef, _gitOpts, rootDir);
+                      if (!sim.ok) {
+                        depConflictBranch = sim.conflictBranch;
+                        depConflictFiles = sim.conflictFiles;
+                        _isInterDepConflict = sim.isInterDep;
+                        _preflightConflictPrev = sim.prevBranch;
+                      }
+                    } catch (_simErr) {
+                      // Fallback: old per-branch isolation check via 3-arg git merge-tree
+                      for (const { branch: reBranch2 } of prunedDeps) {
+                        try {
+                          const mainRef2 = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
+                          const mergeBase = gitOutputToString(await shared.shellSafeGit(['merge-base', `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir })).trim();
+                          const treeResult = await shared.shellSafeGit(['merge-tree', mergeBase, `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir });
+                          const treeOutput = gitOutputToString(treeResult);
+                          if (treeOutput.includes('<<<<<<<') || treeOutput.includes('changed in both')) {
+                            depConflictBranch = reBranch2;
+                            depConflictFiles = parseConflictFiles(treeOutput);
+                            break;
+                          }
+                        } catch (_e) { /* merge-tree may fail — continue checking other branches */ }
+                      }
                     }
-                  } catch (_simErr) {
-                    // Fallback: old per-branch isolation check via 3-arg git merge-tree
-                    for (const { branch: reBranch2 } of prunedDeps) {
-                      try {
-                        const mainRef2 = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-                        const mergeBase = (await shared.shellSafeGit(['merge-base', `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir })).stdout.toString().trim();
-                        const treeResult = await shared.shellSafeGit(['merge-tree', mergeBase, `origin/${mainRef2}`, `origin/${reBranch2}`], { ..._gitOpts, cwd: rootDir });
-                        const treeOutput = treeResult.stdout?.toString?.() || '';
-                        if (treeOutput.includes('<<<<<<<') || treeOutput.includes('changed in both')) {
-                          depConflictBranch = reBranch2;
-                          depConflictFiles = parseConflictFiles(treeOutput);
-                          break;
-                        }
-                      } catch (_e) { /* merge-tree may fail — continue checking other branches */ }
+                    // Fallback: use verified unmerged files or conflict output if merge-tree didn't identify them.
+                    if (!depConflictBranch) {
+                      depConflictFiles = depFailure.conflictFiles;
                     }
                   }
-                  // Fallback: parse conflict files from the error output if merge-tree didn't identify them
-                  if (!depConflictBranch) {
-                    depConflictFiles = parseConflictFiles(errOutput);
-                  }
                   depMergeFailed = true;
                 }
                 break;
@@ -2327,6 +2386,18 @@ async function spawnAgent(dispatchItem, config) {
               cleanupTempAgent(agentId);
               return;
             }
+            if (depMergeSetupFailed) {
+              const setupReason = (depMergeSetupReason || `Dependency merge setup failed for ${branchName}`).slice(0, 800);
+              completeDispatch(
+                id,
+                DISPATCH_RESULT.ERROR,
+                setupReason,
+                'Engine dependency pre-merge plumbing failed before any real unmerged files were verified. Retrying in a fresh worktree should recover if the dependency branches still merge cleanly.',
+                { failureClass: FAILURE_CLASS.DEPENDENCY_MERGE_SETUP, agentRetryable: true },
+              );
+              cleanupTempAgent(agentId);
+              return;
+            }
             // Build actionable failReason identifying the conflicting branch and files (#958)
             const mainBranch = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
             let failReason = 'Dependency merge failed';
@@ -8082,6 +8153,7 @@ module.exports = {
   reconcileItemsWithPrs, detectDependencyCycles,
   areDependenciesMet, // exported for testing (P-bf04-decompose-zero-children)
   parseConflictFiles, pruneAncestorDeps, preflightMergeSimulation, // exported for testing
+  gitOutputToString, gitErrorOutput, classifyDepMergeFailureOutput, listUnmergedFiles, // exported for testing
   buildDepConflictFixItem, deriveConflictFixKey, // exported for testing (W-mpcwojgr000a0244)
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
   pruneStaleWorktreeForBranch, // exported for testing

package/package.json

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