@yemi33/minions 0.1.2178 → 0.1.2179

package/engine/lifecycle.js

@@ -915,9 +915,30 @@ function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
     (projects.length === 1 ? projects[0] : null);
   const useCentral = !defaultProject;
 
-  // Match each PR to its correct project by finding which repo URL appears near the PR number in output
+  // Match each PR to its correct project. W-mqba5ulq000nd255 — primary
+  // strategy is canonical scope: parse the evidence URL into a host scope
+  // (e.g. `github:opg-microsoft/minions`) and find the configured project
+  // whose `getProjectPrScope` matches. This routes the record into the
+  // correctly-scoped project file even when the dispatching agent ran
+  // against a different project (the cross-project PR case that previously
+  // produced stale `_invalidProjectScope` stubs in the wrong file). Falls
+  // back to the legacy substring match (handles legacy non-canonical
+  // configs), then to a repoName-by-_git fallback, then to the dispatching
+  // project (which will get the `_invalidProjectScope` stamp via
+  // normalizePrRecord — preserving today's tracking behavior for orphan /
+  // unknown-owner URLs).
   function resolveProjectForPr(prId) {
     const evidenceUrl = prEvidence.get(prId) || '';
+    // Scope match wins. Use the most-specific URL available: prefer the
+    // direct evidence URL captured alongside the PR id; fall back to the
+    // generic stdout scan if that's empty.
+    const urlScope = shared.getPrScopeInfo(null, evidenceUrl)?.scope || '';
+    if (urlScope) {
+      for (const p of projects) {
+        const projScope = shared.getProjectPrScope(p);
+        if (projScope && projScope === urlScope) return p;
+      }
+    }
     const evidenceText = `${outputText}\n${evidenceUrl}`;
     for (const p of projects) {
       if (!p.prUrlBase) continue;
@@ -5474,6 +5495,94 @@ function diagnoseEmptyOutput(failureClass, code, elapsedMs) {
   return `[empty-output: process exited in ${elapsedMs}ms \u2014 possible causes: machine sleep, network unavailability, auth failure]`;
 }
 
+// W-mqba5ulq000nd255 — Reconciliation sweep: delete PR records flagged with
+// `_invalidProjectScope: { reason: "pr_scope_mismatch" }` IFF a sibling
+// record for the same canonical pr.id exists in another project whose scope
+// matches the PR URL (i.e. the correctly-scoped project owns the canonical
+// record). Sibling-less mismatches are preserved as tracking. Runs once per
+// tick from engine.js after the ADO/GitHub reconcile polls finish.
+//
+// Returns { pruned, scanned } so the engine tick can log a summary line.
+function pruneScopeMismatchDuplicatePrs(config) {
+  config = config || getConfig();
+  const projects = shared.getProjects(config) || [];
+  if (projects.length === 0) return { pruned: 0, scanned: 0 };
+
+  // Map project name -> canonical scope so we can find which project IS the
+  // correctly-scoped owner for a given mismatch record.
+  const scopeByProject = new Map();
+  const projectByScope = new Map();
+  for (const p of projects) {
+    if (!p || !p.name) continue;
+    const sc = shared.getProjectPrScope(p);
+    if (!sc) continue;
+    scopeByProject.set(p.name, sc);
+    projectByScope.set(sc, p);
+  }
+
+  // Index all PRs by canonical id across all projects (post-_scope decoration).
+  const store = require('./pull-requests-store');
+  const allPrs = store.readAllPullRequests() || [];
+  const byId = new Map();
+  for (const pr of allPrs) {
+    if (!pr || !pr.id) continue;
+    if (!byId.has(pr.id)) byId.set(pr.id, []);
+    byId.get(pr.id).push(pr);
+  }
+
+  // Build per-project delete sets keyed by id, so we batch one mutation per
+  // affected project file.
+  const deletesByProject = new Map(); // projectName -> Set(prId)
+  let scanned = 0;
+  let pruned = 0;
+
+  for (const records of byId.values()) {
+    if (records.length < 2) continue;
+    for (const rec of records) {
+      scanned++;
+      if (!rec._invalidProjectScope || rec._invalidProjectScope.reason !== 'pr_scope_mismatch') continue;
+      const correctScope = rec._invalidProjectScope.prScope;
+      if (!correctScope) continue;
+      const correctProject = projectByScope.get(correctScope);
+      if (!correctProject) continue; // no configured project owns the URL — keep as tracking
+      // Sibling check: is there a record under the correct scope for the same id?
+      const sibling = records.find(r => r !== rec && r._scope === correctProject.name);
+      if (!sibling) continue;
+      // Safe to prune.
+      const owningScope = rec._scope;
+      if (!owningScope || owningScope === 'central') continue;
+      if (!deletesByProject.has(owningScope)) deletesByProject.set(owningScope, new Set());
+      deletesByProject.get(owningScope).add(rec.id);
+    }
+  }
+
+  if (deletesByProject.size === 0) return { pruned: 0, scanned };
+
+  for (const [projectName, idsToDelete] of deletesByProject) {
+    const project = projects.find(p => p.name === projectName);
+    if (!project) continue;
+    const prPath = projectPrPath(project);
+    try {
+      shared.mutatePullRequests(prPath, (prs) => {
+        const before = prs.length;
+        const next = prs.filter(p => !idsToDelete.has(p?.id));
+        const deleted = before - next.length;
+        if (deleted > 0) {
+          pruned += deleted;
+          for (const id of idsToDelete) {
+            log('info', `[pull-requests] pruned scope-mismatch duplicate ${id} from project=${projectName} (sibling exists in correctly-scoped project)`);
+          }
+        }
+        return next;
+      });
+    } catch (err) {
+      log('warn', `pruneScopeMismatchDuplicatePrs: failed to mutate ${projectName}: ${err?.message || err}`);
+    }
+  }
+
+  return { pruned, scanned };
+}
+
 module.exports = {
   checkPlanCompletion,
   archivePlan,
@@ -5482,6 +5591,7 @@ module.exports = {
   syncPrdItemStatus,
   reconcilePrdStatuses,
   syncPrsFromOutput,
+  pruneScopeMismatchDuplicatePrs,
   updatePrAfterReview,
   updatePrAfterFix,
   updatePrAfterFixError,

package/engine/queries.js

@@ -734,6 +734,118 @@ function getPrs(project) {
 let _prsCache = null;
 let _prsCacheAt = 0;
 
+// ── W-mqba5ulq000nd255 — cross-project PR de-dupe helpers ────────────────────
+//
+// When a dispatching agent in project A reports a PR URL that actually lives
+// on project B's repo, the engine historically wrote the PR into BOTH project
+// files. The A copy got stamped with `_invalidProjectScope` (a tracking
+// breadcrumb) but was never pruned. getPullRequests' legacy first-write-wins
+// dedupe then surfaced the wrong scope first, masking the real record. These
+// helpers collapse those duplicates at read time, with field-merge so we
+// never drop prdItems, sourcePlan, itemType, minionsReview, or
+// _automationFixCauses that lived on the loser.
+
+// Timestamps that signal "this record was touched recently". Highest of the
+// three breaks ties when neither record has a scope advantage.
+function _prFreshnessMs(pr) {
+  if (!pr) return 0;
+  const cands = [pr.lastPushedAt, pr.mergedAt, pr.lastPolledAt, pr.lastPolled, pr._attachedAt, pr.created];
+  let best = 0;
+  for (const c of cands) {
+    if (!c) continue;
+    const t = typeof c === 'number' ? c : Date.parse(c);
+    if (Number.isFinite(t) && t > best) best = t;
+  }
+  return best;
+}
+
+function _groupPrRecordsById(prs) {
+  const groups = new Map();
+  const order = [];
+  for (const pr of prs) {
+    if (!pr || !pr.id) continue;
+    if (!groups.has(pr.id)) {
+      const g = [];
+      groups.set(pr.id, g);
+      order.push(g);
+    }
+    groups.get(pr.id).push(pr);
+  }
+  return order;
+}
+
+// Choose the winning record from a group of cross-scope duplicates. Fields
+// the winner left empty are filled from the loser(s). Returns the winner +
+// the dropped sibling records so the caller can log the pruning decision.
+function _pickPrDedupeWinner(group, projects) {
+  if (group.length === 1) return { winner: group[0], dropped: [] };
+
+  // Map each project name -> its canonical scope, so we can detect when a
+  // record's _scope matches the PR url-derived scope (preference #2 below).
+  const projectScopeByName = new Map();
+  for (const p of projects || []) {
+    if (!p || !p.name) continue;
+    const sc = shared.getProjectPrScope(p);
+    if (sc) projectScopeByName.set(p.name, sc);
+  }
+
+  // Resolve the PR's "correct" scope from its URL (independent of _scope).
+  // Falls back to the canonical id when the URL is absent. Group members
+  // share the same id so any non-empty url is sufficient.
+  let urlScope = '';
+  for (const pr of group) {
+    const info = shared.getPrScopeInfo(pr, pr.url || '');
+    if (info && info.scope) { urlScope = info.scope; break; }
+  }
+
+  // Score each candidate. Higher is better. Composite key:
+  //  bit 2: no _invalidProjectScope stamp (best signal)
+  //  bit 1: _scope matches url-derived scope
+  //  bit 0: freshness rank (broken into a separate tiebreak after)
+  function scoreOf(pr) {
+    const scopeOk = !pr._invalidProjectScope ? 1 : 0;
+    const projectScope = projectScopeByName.get(pr._scope) || '';
+    const matchesUrl = urlScope && projectScope && projectScope === urlScope ? 1 : 0;
+    return (scopeOk << 1) | matchesUrl;
+  }
+
+  let winnerIdx = 0;
+  let winnerScore = scoreOf(group[0]);
+  let winnerFresh = _prFreshnessMs(group[0]);
+  for (let i = 1; i < group.length; i++) {
+    const s = scoreOf(group[i]);
+    const f = _prFreshnessMs(group[i]);
+    if (s > winnerScore || (s === winnerScore && f > winnerFresh)) {
+      winnerIdx = i;
+      winnerScore = s;
+      winnerFresh = f;
+    }
+  }
+
+  const winner = group[winnerIdx];
+  const dropped = group.filter((_, i) => i !== winnerIdx);
+
+  // Field-merge: fill empty winner fields from any loser. Winner wins on
+  // every field it has; losers only contribute where the winner is missing
+  // the field entirely (undefined, null, '', or empty array).
+  function isEmpty(v) {
+    if (v == null) return true;
+    if (typeof v === 'string') return v === '';
+    if (Array.isArray(v)) return v.length === 0;
+    return false;
+  }
+  const mergeKeys = ['prdItems', 'sourcePlan', 'itemType', 'minionsReview', '_automationFixCauses'];
+  for (const loser of dropped) {
+    for (const key of mergeKeys) {
+      if (isEmpty(winner[key]) && !isEmpty(loser[key])) {
+        winner[key] = loser[key];
+      }
+    }
+  }
+
+  return { winner, dropped };
+}
+
 function getPullRequests(config) {
   const now = Date.now();
   if (_prsCache && (now - _prsCacheAt) < 1000) return _prsCache;
@@ -741,14 +853,34 @@ function getPullRequests(config) {
   const projects = getProjects(config);
   const projectByName = new Map(projects.map(p => [p.name, p]));
   const allPrs = [];
-  const seenIds = new Set();
 
   // SQL is the canonical (and only) PR store after Phase 9.
   const store = require('./pull-requests-store');
   const sqlPrs = store.readAllPullRequests() || [];
 
-  for (const pr of sqlPrs) {
-    if (!pr?.id || seenIds.has(pr.id)) continue;
+  // W-mqba5ulq000nd255 — Read-side de-dupe across project scopes. When the
+  // same canonical pr.id appears under multiple scopes (e.g. an agent in
+  // project A reported a PR URL that actually lives on project B's repo,
+  // landing a stub stamped with _invalidProjectScope in A while the real
+  // record lives in B), collapse to one record using the preference order:
+  //   1. record where `_invalidProjectScope` is FALSY
+  //   2. record whose scope matches the PR url-derived scope
+  //   3. most-recently-updated (lastPushedAt / mergedAt / _attachedAt)
+  //   4. first-seen
+  // Then merge non-conflicting fields from the loser into the winner so we
+  // never lose prdItems, sourcePlan, itemType, minionsReview, or
+  // _automationFixCauses if only the loser carried them.
+  const groups = _groupPrRecordsById(sqlPrs);
+  for (const group of groups) {
+    const { winner, dropped } = _pickPrDedupeWinner(group, projects);
+    if (dropped.length > 0) {
+      try {
+        const droppedScopes = dropped.map(d => d._scope || 'unknown').join(', ');
+        shared.log('info', `[pull-requests] de-duped ${winner.id} across ${group.length} records, kept _project=${winner._scope || 'unknown'}, dropped [${droppedScopes}]`);
+      } catch { /* logging is best-effort */ }
+    }
+
+    const pr = winner;
     const scope = pr._scope;
     delete pr._scope;
     if (scope === 'central') {
@@ -769,7 +901,6 @@ function getPullRequests(config) {
     // _noOpFixes themselves.
     pr._pausedCauses = shared.getPrPausedCauses(pr);
     allPrs.push(pr);
-    seenIds.add(pr.id);
   }
   allPrs.sort((a, b) => {
     // W-mpej044m00076d63: sort by the full ISO `created` timestamp DESC so
@@ -2597,6 +2728,10 @@ module.exports = {
 
   // Pull requests
   getPrs, getPullRequests,
+  // W-mqba5ulq000nd255 — exported for direct unit testing of the cross-project
+  // PR dedupe helpers.
+  _pickPrDedupeWinner,
+  _groupPrRecordsById,
 
   // Skills
   collectSkillFiles, getSkills, getSkillIndex, invalidateSkillsCache,

package/engine/shared.js

@@ -484,18 +484,99 @@ function resolveEngineCacheDir(fallbackEngineDir) {
 // Cross-platform URL opener. Uses execSync so failures fall through the
 // try/catch and the caller sees them. Dashboard self-open and `minions dash`
 // / `minions restart` post-health open all funnel through here.
-function openUrlInBrowser(url) {
+//
+// Every call writes a structured `event: 'browser-open'` entry to log.json
+// (via shared.log) and bumps a per-reason counter in `_engine.browserOpens`
+// in metrics.json. Callers MUST pass `opts.reason` so the log/metric is
+// attributable; a missing reason is logged at `warn` level with
+// `reason: 'unknown'` to make a regression loud rather than silent.
+//
+// `MINIONS_NO_AUTO_OPEN=1` short-circuits the open and writes a debug-level
+// SUPPRESSED entry instead — this lets us prove the kill-switch is firing
+// in production (absence of opens otherwise looks identical whether the
+// guard worked, nobody tried to open, or the guard regressed).
+//
+// Note: browser windows opened by external MCP servers (e.g. @playwright/mcp)
+// do NOT funnel through this primitive and are therefore NOT logged. See
+// MTG-mqam2mjs000e39d7.
+//
+// @param {string} url - URL to open in the user's default browser.
+// @param {Object} [opts]
+// @param {string} [opts.reason] - Why we are opening (e.g. 'cli-dash-warm',
+//   'cli-start-force-open', 'dashboard-self-open'). Required-in-practice;
+//   missing values are logged at warn level.
+// @param {string} [opts.callerHint] - Optional `file:line` to disambiguate
+//   when one reason has multiple call sites.
+// @returns {{ok: boolean, error?: string, suppressed?: boolean}}
+function openUrlInBrowser(url, opts = {}) {
+  const reason = (opts && typeof opts.reason === 'string' && opts.reason) ? opts.reason : 'unknown';
+  const callerHint = (opts && typeof opts.callerHint === 'string') ? opts.callerHint : null;
+  // Heuristic-driven opens (no explicit user action this dispatch) log at warn
+  // so a leak shows up as a warn cluster in the dashboard log filter.
+  const HEURISTIC_REASONS = new Set(['cli-restart-no-beacon', 'dashboard-self-open']);
+  let level = HEURISTIC_REASONS.has(reason) ? 'warn' : 'info';
+  if (reason === 'unknown') level = 'warn';
+  const callerStack = (new Error()).stack.split('\n').slice(2, 5).map(s => s.trim()).join(' | ');
+  const baseMeta = {
+    event: 'browser-open',
+    url,
+    reason,
+    callerHint,
+    callerStack,
+    pid: process.pid,
+    platform: process.platform,
+  };
+
+  // Kill-switch: log SUPPRESSED at debug level and skip execSync. Centralizing
+  // the check here means every caller (existing + future) is observable, and
+  // outer guards (e.g. ralph's W-mqb9y83o000le41e leak fixes) become belt-and-
+  // suspenders without breaking the log audit trail.
+  if (process.env.MINIONS_NO_AUTO_OPEN) {
+    log('debug', `[browser-open] SUPPRESSED reason=${reason} url=${url} (MINIONS_NO_AUTO_OPEN=1)`, {
+      ...baseMeta,
+      suppressed: true,
+    });
+    _bumpBrowserOpenMetric(reason, { suppressed: true });
+    return { ok: false, suppressed: true };
+  }
+
+  log(level, `[browser-open] reason=${reason} url=${url}`, baseMeta);
+  _bumpBrowserOpenMetric(reason);
+
   const { execSync } = require('child_process');
   try {
     if (process.platform === 'win32') execSync(`start "" "${url}"`, { stdio: 'ignore', windowsHide: true });
     else if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
     else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+    log(level, `[browser-open] ok reason=${reason}`, { ...baseMeta, ok: true });
     return { ok: true };
   } catch (e) {
-    return { ok: false, error: e && e.message ? e.message : String(e) };
+    const errMsg = e && e.message ? e.message : String(e);
+    log(level, `[browser-open] failed reason=${reason} error=${errMsg}`, { ...baseMeta, ok: false, error: errMsg });
+    return { ok: false, error: errMsg };
   }
 }
 
+// Bump per-reason counter under metrics._engine.browserOpens. Best-effort —
+// metrics.json writes must never throw out of openUrlInBrowser. Schema:
+//   _engine.browserOpens.<reason> = { count, suppressedCount, lastAt }
+function _bumpBrowserOpenMetric(reason, { suppressed = false } = {}) {
+  try {
+    mutateMetrics((metrics) => {
+      if (!metrics._engine || typeof metrics._engine !== 'object') metrics._engine = {};
+      if (!metrics._engine.browserOpens || typeof metrics._engine.browserOpens !== 'object') {
+        metrics._engine.browserOpens = {};
+      }
+      const slot = metrics._engine.browserOpens[reason] || { count: 0, suppressedCount: 0, lastAt: null };
+      if (suppressed) slot.suppressedCount = (slot.suppressedCount || 0) + 1;
+      else slot.count = (slot.count || 0) + 1;
+      slot.lastAt = new Date().toISOString();
+      metrics._engine.browserOpens[reason] = slot;
+      return metrics;
+    });
+  } catch { /* metric best-effort — never throw out of openUrlInBrowser */ }
+}
+
 function _flushLogBuffer() {
   if (_logBuffer.length === 0) return;
   const drained = _logBuffer.splice(0);
@@ -2533,6 +2614,11 @@ const ENGINE_DEFAULTS = {
   cleanupEvery: 60,                  // runCleanup + MCP sync every N ticks (~10 min at default 10s tick)
   planCompletionScanEvery: 60,       // periodic PRD completion sweep (~10 min at default 10s tick) — catches plans completed while engine was down
   watchPollEvery: 18,                // checkWatches every N ticks (~3 min at default 10s tick)
+  // P-b2c3d4e5: cadence for MEMORY_BASELINE log line + diagnostics-memory.json
+  // sidecar write driven from engine.js tickInner. Defaults to 6 ticks ≈ 60s
+  // at the default 10s tickInterval. Set to 0 (or any non-positive integer)
+  // to disable both the log emission and sidecar write cleanly (operator opt-out).
+  memoryBaselineEveryTicks: 6,
   stalledDispatchSweepEvery: 120,    // stalled-dispatch retry sweep (~20 min at default 10s tick) — only fires when all agents idle
   // W-mp5trwh60008386d: per-PR 404 must repeat across N consecutive successful base-repo probes
   // before flipping a PR to `abandoned`. A single 404 on `repos/{slug}/pulls/{n}` can be a transient
@@ -4284,6 +4370,30 @@ function getProjects(config) {
   return [];
 }
 
+// Generic, ambiguous project-name tokens that read poorly as a bare label in
+// the dashboard. For these, projectDisplayName derives a `<parentFolder>/<name>`
+// label from the project's localPath. `src` is the required case. DISPLAY ONLY —
+// the project `name` field is a load-bearing identifier and is never mutated.
+const GENERIC_PROJECT_NAME_TOKENS = new Set(['src', 'source', 'repo']);
+
+// Human-facing label for a project. Returns `project.name` unchanged for normal
+// names. When the name is a generic token (e.g. `src`), derives the parent
+// folder one level up from localPath and returns `<parentBasename>/<name>` —
+// e.g. name `src` at localPath `C:/office/src` → `office/src`. Falls back to the
+// bare name when localPath is missing or the parent can't be derived. Never
+// mutates the project; preserves the original name casing.
+function projectDisplayName(project) {
+  if (!project || typeof project !== 'object') return '';
+  const name = project.name == null ? '' : String(project.name);
+  if (!GENERIC_PROJECT_NAME_TOKENS.has(name.trim().toLowerCase())) return name;
+  const localPath = project.localPath == null ? '' : String(project.localPath);
+  const normalized = localPath.replace(/\\/g, '/').replace(/\/+$/, '');
+  if (!normalized) return name;
+  const parent = path.basename(path.dirname(normalized));
+  if (!parent || parent === '.') return name;
+  return `${parent}/${name}`;
+}
+
 function formatUnknownProjectError(projectName, projects = []) {
   const known = projects.map(p => p.name).filter(Boolean).join(', ') || '(none configured)';
   return `Project "${projectName}" not found. Known projects: ${known}`;
@@ -7721,6 +7831,7 @@ module.exports = {
   mergeManifestAllowedTools,
   formatManifestRejection,
   getProjects,
+  projectDisplayName,
   formatUnknownProjectError,
   findProjectByName,
   findProjectByNameOrPath,

package/engine/watchdog.js

@@ -146,6 +146,12 @@ async function tick(opts) {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
+      // W-mqb9y83o — suppress auto-open in the respawned dashboard. The
+      // watchdog has no user-intent signal (it fires on health failure, not
+      // user action), so the post-restart hook MUST NOT pop a browser tab.
+      // The CLI's spawnFullStackAndVerify reads this env var as a hard
+      // kill-switch via MINIONS_NO_AUTO_OPEN=1.
+      env: { ...process.env, MINIONS_NO_AUTO_OPEN: '1' },
     });
     if (child && typeof child.unref === 'function') child.unref();
     logLine(minionsHome, `spawned minions ${action} pid=${child && child.pid} (detached)`);

package/engine.js

@@ -168,7 +168,12 @@ const { runPostCompletionHooks, updateWorkItemStatus, syncPrdItemStatus, reconci
   syncPrsFromOutput, updatePrAfterReview, updatePrAfterFix, checkForLearnings, extractSkillsFromOutput,
   updateAgentHistory, updateMetrics, createReviewFeedbackForAuthor, parseAgentOutput, syncPrdFromPrs,
   isItemCompleted, classifyFailure: classifyFailureFallback, diagnoseEmptyOutput, processPendingRebases, resolveWorkItemPath,
-  mergeArtifactNotes, promoteCompletionArtifacts } = require('./engine/lifecycle');
+  mergeArtifactNotes, promoteCompletionArtifacts, pruneScopeMismatchDuplicatePrs } = require('./engine/lifecycle');
+
+// ─── Diagnostics: memory + event-loop + GC sampler (P-a1b2c3d4 / P-b2c3d4e5) ─
+
+const diagnosticsMemory = require('./engine/diagnostics-memory');
+const DIAGNOSTICS_MEMORY_PATH = path.join(ENGINE_DIR, 'diagnostics-memory.json');
 
 // ─── Agent Spawner ──────────────────────────────────────────────────────────
 
@@ -8670,6 +8675,20 @@ async function tickInner() {
     }
     if (reconcilePolls.length) await Promise.allSettled(reconcilePolls);
     if (_isTickStale(myGeneration)) return;
+
+    // W-mqba5ulq000nd255 — Cross-project PR scope-mismatch sweep. Cleans up
+    // stale records that were stamped with `_invalidProjectScope` and have a
+    // sibling in the correctly-scoped project. Cheap (a single read of all
+    // PRs + a per-affected-project mutation). Runs once per reconcile tick;
+    // sibling-less stamps are preserved as tracking signals.
+    try {
+      const result = pruneScopeMismatchDuplicatePrs(config);
+      if (result?.pruned > 0) {
+        log('info', `[pull-requests] scope-mismatch sweep pruned ${result.pruned} duplicate record(s) across ${result.scanned} scanned`);
+      }
+    } catch (err) {
+      log('warn', `[pull-requests] scope-mismatch sweep error: ${err?.message || err}`);
+    }
   }
 
   // 2.9. Stalled dispatch detection — auto-retry failed items blocking the graph (~20 min — cadence in ENGINE_DEFAULTS.stalledDispatchSweepEvery)
@@ -9209,6 +9228,29 @@ async function tickInner() {
   if (!discoveryOk) {
     log('warn', 'Discovery failed after pending dispatch pass — new work may be stale until next tick');
   }
+
+  // 6. Periodic memory baseline (P-b2c3d4e5).
+  // Sample once every ENGINE_DEFAULTS.memoryBaselineEveryTicks ticks (default
+  // 6 ≈ 60s at the default 10s tickInterval). When the cadence is <= 0,
+  // sampling is disabled cleanly — no log emission, no sidecar write
+  // (operator opt-out). The diagnostics-memory.json sidecar is a passive
+  // cache (single-object latest sample) — gitignored and exempt from the
+  // SQL-first state rule, same as engine/dashboard-port.json.
+  safe('memoryBaseline', () => emitMemoryBaseline(tickCount));
+}
+
+function emitMemoryBaseline(tickN) {
+  const every = Number(ENGINE_DEFAULTS.memoryBaselineEveryTicks);
+  if (!Number.isFinite(every) || every <= 0) return;
+  if ((tickN % every) !== 0) return;
+  const sample = diagnosticsMemory.sampleSelf({ label: 'engine' });
+  diagnosticsMemory.recordSample(sample);
+  try { safeWrite(DIAGNOSTICS_MEMORY_PATH, sample); }
+  catch (e) { log('warn', `memoryBaseline sidecar write: ${e.message}`); }
+  log('info',
+    `MEMORY_BASELINE engine rss=${sample.rss} heapUsed=${sample.heapUsed} ` +
+    `eventLoopLagP99=${sample.eventLoopLagP99.toFixed(2)}ms ` +
+    `gcPauses=${sample.gcCount}/${sample.gcPausesTotalMs.toFixed(2)}ms tickN=${tickN}`);
 }
 
 // ─── Exports (for engine/cli.js and other modules) ──────────────────────────
@@ -9287,6 +9329,8 @@ module.exports = {
   resolvePreDispatchEvalConcurrency,
   // P-c2e5a1d9-a — exported for testing the tick-generation force-release path
   _isTickStale,
+  // P-b2c3d4e5 — exported for testing the memory baseline emitter + sidecar path
+  emitMemoryBaseline, DIAGNOSTICS_MEMORY_PATH,
   get tickGeneration() { return tickGeneration; },
   set tickGeneration(v) { tickGeneration = v; },
   get tickRunning() { return tickRunning; },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2178",
+  "version": "0.1.2179",
   "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"
@@ -25,7 +25,7 @@
     "test:e2e:report": "npx playwright show-report test/playwright/report",
     "test:e2e:video": "npx playwright test --video=on --headed",
     "test:all": "node test/run-parallel.js && node test/minions-tests.js && node test/integration/run.js",
-    "test:perf": "node test/perf/managed-spawn-load.test.js",
+    "test:perf": "node test/perf/run.js",
     "test:e2e:accept": "node test/playwright/accept-baseline.js",
     "test:e2e:accept-force": "node test/playwright/accept-baseline.js --force",
     "test:setup": "npx playwright install chromium",