@yemi33/minions 0.1.2424 → 0.1.2426

package/engine/github.js

@@ -7,8 +7,14 @@
 const shared = require('./shared');
 const { exec, execAsync, getProjects, readWorkItems, readPullRequests, safeJson, safeJsonArr, safeWrite, mutateMetrics, mutatePullRequests, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, ENGINE_DEFAULTS, createThrottleTracker, getProjectOrg } = shared;
 const { getPrs } = require('./queries');
-const { isPreviewStatusBody, hasMinionsMarker, hasVerdictPrefix } = require('./comment-classifier');
+const {
+  isPreviewStatusBody,
+  hasMinionsMarker,
+  hasVerdictPrefix,
+  classifyNonActionableAutomationComment,
+} = require('./comment-classifier');
 const { wrapUntrusted, buildSource } = require('./untrusted-fence');
+const reviewLearning = require('./review-learning');
 const ghToken = require('./gh-token');
 const path = require('path');
 
@@ -176,19 +182,16 @@ function _isNonActionableComment(c, config = {}) {
   const ignoredAuthors = new Set((config.engine?.ignoredCommentAuthors || []).map(a => String(a).toLowerCase()));
   const login = String(c?.user?.login || '').toLowerCase();
   if (ignoredAuthors.has(login)) return true;
-  // W-mqr41te300026723: removed blanket _isGitHubBotComment author-type drop.
-  // Bot comments are now filtered by CONTENT (isPreviewStatusBody below), not
-  // author type — symmetric with ADO's pollPrHumanComments which has no
-  // user.type==='bot' equivalent and relies solely on body-content + marker gates.
+  // W-mqr41te300026723: no blanket bot-author drop. Known automation noise
+  // requires a content signature; identity is consulted only for exact
+  // producer envelopes such as the visual-evidence GitHub Actions status.
   if (_isAgentComment(c)) return true;
-  // P-f23classifier (F2): body-only preview/CI-report check is now host-
-  // agnostic. The legacy `_isCiReportCommentBody` body match (Coverage /
-  // Build / Test / Deploy / Pipeline headings + shields.io badges) is the
-  // strict subset of isPreviewStatusBody, so a single call covers both
-  // pre-existing branches. Bot-author gated preview matches still go
-  // through _isPreviewStatusComment for callers that want the narrower
-  // bot-only signal exported for testing.
-  if (isPreviewStatusBody(c?.body)) return true;
+  const automationReason = classifyNonActionableAutomationComment({
+    host: 'github',
+    body: c?.body,
+    author: c?.user,
+  });
+  if (automationReason) return true;
   if (_isMinionsAuthoredComment(c)) return true;
   return false;
 }
@@ -1259,7 +1262,18 @@ async function pollPrHumanComments(config) {
     const allComments = [
       ...(comments || []).map(c => ({ ...c, _type: 'issue' })),
       ...(Array.isArray(reviewComments) ? reviewComments : []).map(c => ({ ...c, _type: 'review' }))
-    ];
+    ].filter(c => c?.id != null);
+    for (const c of allComments) {
+      c._commentSource = reviewLearning.buildReviewCommentSource({
+        host: 'github',
+        commentType: c._type,
+        commentId: c.id,
+        author: c.user?.login || 'Human',
+        createdAt: c.created_at,
+        updatedAt: c.updated_at || c.created_at,
+        content: c.body || '',
+      });
+    }
 
     // Backfill viewerDidAuthor on each comment so _isMinionsAuthoredComment
     // can actually fire on production traffic. No-op when GraphQL or a test
@@ -1274,17 +1288,23 @@ async function pollPrHumanComments(config) {
     // timestamp differs from what we already saw are queued as new feedback so
     // a follow-up fix re-dispatches. First-seen comments and re-polls of
     // already-seen edits do NOT route through this path.
-    const prevEditsSeen = (pr.humanFeedback && pr.humanFeedback.editsSeen) || {};
     const editsInput = allComments.map(c => ({
-      id: c.id,
+      id: c._commentSource.key,
       createdRaw: c.created_at,
       updatedRaw: c.updated_at,
     }));
+    const persistedEditsSeen = pr.humanFeedback?.editsSeen || {};
+    const prevEditsSeen = reviewLearning.migrateLegacyReviewCommentEdits(
+      persistedEditsSeen,
+      editsInput.map(entry => entry.id),
+    );
+    const editsMigrationChanged = JSON.stringify(prevEditsSeen) !== JSON.stringify(persistedEditsSeen);
     // Sort chronologically by updated timestamp so FIFO cap eviction keeps the
     // most-recently-edited entries (the ones most likely to be re-edited).
     editsInput.sort((a, b) => String(a.updatedRaw || '').localeCompare(String(b.updatedRaw || '')));
-    const { editsSeen, newlyEditedIds, changed: editsSeenChanged } =
+    const { editsSeen, newlyEditedIds, changed } =
       shared.buildEditsSeen(editsInput, prevEditsSeen);
+    const editsSeenChanged = changed || editsMigrationChanged;
 
     // Collect comments that should advance the cutoff separately from comments
     // that should dispatch a fix. Informational bot/status comments and
@@ -1292,7 +1312,6 @@ async function pollPrHumanComments(config) {
     const allCommentDates = [];
     const allCommentEntries = [];
     const newComments = [];
-    const seenInNewComments = new Set();
     const nonActionableCommentKeys = new Set();
     const nonActionableCommentIds = new Set();
 
@@ -1317,6 +1336,8 @@ async function pollPrHumanComments(config) {
         author: c.user?.login || 'Human',
         content: c.body || '',
         date,
+        createdAt: c.created_at || date,
+        updatedAt: c.updated_at || c.created_at || date,
         _isAgent: false,
         // Issue #2994: namespace GH comment ids by API source ("issue" from
         // `/issues/N/comments` vs "review" from `/pulls/N/comments`). Each
@@ -1327,17 +1348,20 @@ async function pollPrHumanComments(config) {
         _type: c._type,
       };
       entry.commentKey = _entryCommentKey(entry);
+      entry.commentSource = c._commentSource;
       allCommentEntries.push(entry);
 
       if (dateMs && dateMs > cutoffMs) {
         newComments.push(entry);
-        seenInNewComments.add(String(c.id));
-      } else if (c.id != null && newlyEditedIds.has(String(c.id))) {
+      } else if (newlyEditedIds.has(entry.commentSource.key)) {
         // F6: pre-cutoff comment that was newly edited — route into newComments
         // so a fresh fix dispatches, but tag with the edit timestamp so the
         // fix-agent prompt context flags it as new.
-        newComments.push({ ...entry, date: editsSeen[String(c.id)] || date, _isEditedRedispatch: true });
-        seenInNewComments.add(String(c.id));
+        entry._isEditedRedispatch = true;
+        newComments.push({
+          ...entry,
+          date: editsSeen[entry.commentSource.key] || entry.commentSource.updatedAt || date,
+        });
       }
     }
 
@@ -1348,6 +1372,15 @@ async function pollPrHumanComments(config) {
     newComments.sort((a, b) => a.date.localeCompare(b.date));
     const latestActionableComment = allCommentEntries[allCommentEntries.length - 1] || null;
     const currentFeedback = pr.humanFeedback || {};
+    const observedCommentSources = reviewLearning.normalizeReviewCommentSources(
+      allCommentEntries.map(entry => entry.commentSource),
+    );
+    const commentSources = reviewLearning.selectReviewCommentSourceSnapshot(
+      currentFeedback,
+      observedCommentSources,
+    );
+    const commentSourcesChanged = JSON.stringify(commentSources)
+      !== JSON.stringify(reviewLearning.normalizeReviewCommentSources(currentFeedback.commentSources));
     const currentCommentKey = String(currentFeedback.lastProcessedCommentKey || '');
     const currentCommentId = String(currentFeedback.lastProcessedCommentId || '');
     const currentCauseIsNonActionable = !!(
@@ -1366,6 +1399,7 @@ async function pollPrHumanComments(config) {
         delete nextFeedback.lastProcessedCommentId;
         delete nextFeedback.lastProcessedCommentKey;
         delete nextFeedback.feedbackContent;
+        delete nextFeedback.commentSources;
       }
       return true;
     };
@@ -1376,12 +1410,15 @@ async function pollPrHumanComments(config) {
       pr.humanFeedback = { ...currentFeedback, lastProcessedCommentDate: allNewDates.sort().pop() };
       repairNonActionableCause(pr.humanFeedback);
       if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
+      if (commentSources.length > 0) pr.humanFeedback.commentSources = commentSources;
       return true; // non-actionable comments only — persist cutoff without triggering fix
     }
     if (newComments.length === 0) {
-      if (currentCauseIsNonActionable) {
+      if (currentCauseIsNonActionable || commentSourcesChanged) {
         pr.humanFeedback = { ...currentFeedback };
         repairNonActionableCause(pr.humanFeedback);
+        if (commentSources.length > 0) pr.humanFeedback.commentSources = commentSources;
+        else delete pr.humanFeedback.commentSources;
         if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
         return true;
       }
@@ -1403,14 +1440,18 @@ async function pollPrHumanComments(config) {
     // attacker-controlled part) lands inside.
     const feedbackContent = allCommentEntries
       .map(c => {
-        const isNew = (new Date(c.date).getTime() || 0) > cutoffMs;
+        const isNew = c._isEditedRedispatch || (new Date(c.date).getTime() || 0) > cutoffMs;
+        const displayDate = c._isEditedRedispatch
+          ? (c.commentSource.updatedAt || c.updatedAt || c.date)
+          : c.date;
         const cleanedBody = String(c.content || '').replace(/@minions\s*/gi, '').trim();
         const source = buildSource('pr-comment', {
           host: 'gh', slug, number: prNum, author: c.author || 'unknown',
+          key: c.commentSource.key,
         });
         const fenced = wrapUntrusted(cleanedBody, source);
         const bodyForPrompt = fenced || cleanedBody;
-        return `${isNew ? '**[NEW]** ' : ''}**${c.author}** (${c.date}):\n${bodyForPrompt}`;
+        return `${isNew ? '**[NEW]** ' : ''}**${c.author}** (${displayDate}):\n${bodyForPrompt}`;
       })
       .join('\n\n---\n\n');
 
@@ -1426,6 +1467,7 @@ async function pollPrHumanComments(config) {
       lastProcessedCommentKey: newComments[newComments.length - 1].commentKey || _entryCommentKey(newComments[newComments.length - 1]),
       pendingFix: true,
       feedbackContent,
+      commentSources: observedCommentSources,
       editsSeen,
     };
 

package/engine/harness-context.js

@@ -0,0 +1,313 @@
+/**
+ * engine/harness-context.js — "Repo harnesses used" PR-body section.
+ *
+ * W-mrtdmtwq000kf391. When Minions opens/updates a PR for a dispatch, we surface
+ * the repo HARNESS assets that were actually USED by THAT dispatch's runtime +
+ * project, so the PR reviewer can see which CLAUDE.md / AGENTS.md / MCP / skill
+ * context the agent actually ran with. The report is the intersection of
+ * "configured" and "actually applied by the resolved runtime" — categories that
+ * produced nothing are omitted entirely (no "none" filler), and the rendered
+ * block is kept compact (a short bullet list, no preamble).
+ *
+ * This module is pure REPORTING. It reuses the same read-only harness-diagnostics
+ * source that backs `GET /api/harness/diagnostics` and `minions doctor --harness`
+ * (engine/preflight.js `_runtimeHarnessRows`) plus the CLAUDE.md propagation
+ * discovery (engine/claude-md-context.js). It never propagates, injects,
+ * suppresses, or attests any repository harness asset — the runtime-adapter
+ * harness methods are diagnostic-only (see docs/harness-propagation.md).
+ *
+ * engine/playbook.js renders the section into a dispatch prompt appendix that
+ * instructs the agent to append the fenced block verbatim to its PR body. The
+ * block is delimited by stable HTML-comment markers so a PR-description refresh
+ * (the description audit) can replace it in place instead of duplicating it.
+ *
+ * No engine state, no locking, no writes.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HARNESS_SECTION_HEADING = '## Repo harnesses used';
+const HARNESS_BLOCK_START = '<!-- minions:harnesses:start -->';
+const HARNESS_BLOCK_END = '<!-- minions:harnesses:end -->';
+
+// Defensive caps so a pathological skills dir or MCP config can never balloon
+// the PR body / prompt appendix.
+const MAX_NAMES = 25;
+
+function _existing(rows) {
+  return (Array.isArray(rows) ? rows : []).filter(r => r && r.exists && r.path);
+}
+
+// Enumerate skill NAMES: each immediate subdirectory of an existing skill root
+// is one skill (matches how Claude/Copilot/Codex discover skills from a root).
+function _listSkillNames(rows, existsFn) {
+  const names = new Set();
+  for (const r of _existing(rows)) {
+    if (typeof existsFn === 'function' && !existsFn(r.path)) continue;
+    let entries;
+    try { entries = fs.readdirSync(r.path, { withFileTypes: true }); }
+    catch { continue; }
+    for (const ent of entries) {
+      try { if (ent.isDirectory()) names.add(ent.name); } catch { /* ignore */ }
+      if (names.size >= MAX_NAMES) break;
+    }
+    if (names.size >= MAX_NAMES) break;
+  }
+  return [...names].sort().slice(0, MAX_NAMES);
+}
+
+// Does a native-discovery runtime actually SEE an AGENTS.md this dispatch?
+// Copilot/Codex walk up from their cwd (the dispatch worktree) to find the
+// nearest AGENTS.md. We report the category only when one actually applies —
+// checking the worktree root plus any dispatch path hints — so the block never
+// claims discovery that produced nothing.
+function _agentsMdApplied({ scanRoot, pathHints = [], existsFn = fs.existsSync }) {
+  if (!scanRoot) return false;
+  const dirs = new Set([scanRoot]);
+  for (const h of (Array.isArray(pathHints) ? pathHints : [])) {
+    if (h && typeof h === 'string') {
+      try { dirs.add(path.resolve(scanRoot, h)); } catch { /* ignore bad hint */ }
+    }
+  }
+  for (const d of dirs) {
+    try { if (existsFn(path.join(d, 'AGENTS.md'))) return true; } catch { /* ignore */ }
+  }
+  return false;
+}
+
+// Enumerate MCP server NAMES by reading the keys of each existing MCP config
+// file (the cross-runtime `mcpServers` / `servers` / `mcp` object).
+function _listMcpServerNames(rows) {
+  const names = new Set();
+  for (const r of _existing(rows)) {
+    let json;
+    try { json = JSON.parse(fs.readFileSync(r.path, 'utf8')); }
+    catch { continue; }
+    const servers = (json && (json.mcpServers || json.servers || json.mcp)) || {};
+    if (servers && typeof servers === 'object' && !Array.isArray(servers)) {
+      for (const k of Object.keys(servers)) {
+        names.add(k);
+        if (names.size >= MAX_NAMES) break;
+      }
+    }
+    if (names.size >= MAX_NAMES) break;
+  }
+  return [...names].sort().slice(0, MAX_NAMES);
+}
+
+/**
+ * Compute the harness inventory for a dispatch's runtime + project.
+ *
+ * The inventory reflects the RESOLVED dispatch — the runtime's actual
+ * invocation options and the actual dispatched checkout — not static
+ * discovery. Callers thread the values the engine already resolved so the
+ * report never over-claims context the runtime never saw:
+ *   - `bareMode`             — a `--bare` invocation strips the runtime's native
+ *                              repo-context discovery (CLAUDE.md/AGENTS.md).
+ *   - `propagateClaudeMd`    — the engine only injects CLAUDE.md into non-native
+ *                              runtimes when this resolves true.
+ *   - `claudeMdInjectedFiles`— the authoritative list of files the engine
+ *                              actually injected this dispatch (preferred over
+ *                              re-discovery, which can diverge).
+ *   - `worktreePath`         — the actual dispatch checkout; project-scoped MCP /
+ *                              skill discovery scans THIS, not the operator
+ *                              checkout (`project.localPath`) the runtime never ran in.
+ *
+ * @param {object} opts
+ * @param {string} opts.runtimeCli   Resolved runtime name (copilot|claude|codex).
+ * @param {object} [opts.project]    Project object with `localPath` / `name`.
+ * @param {string} [opts.worktreePath] Dispatch checkout root for project-scoped scan.
+ * @param {boolean} [opts.bareMode]  Resolved `--bare` invocation option.
+ * @param {boolean} [opts.nativeClaudeMd] Runtime's CLAUDE.md native-discovery
+ *                                   capability (derived from the adapter when omitted).
+ * @param {string[]} [opts.claudeMdInjectedFiles] Authoritative injected-file result.
+ * @param {boolean} [opts.propagateClaudeMd] Resolved propagation flag (default true).
+ * @param {string[]} [opts.pathHints] CLAUDE.md discovery hints (fallback only).
+ * @param {string} [opts.homeDir]    Override for tests.
+ * @param {function} [opts.existsFn] Override for tests.
+ * The returned inventory reports only harnesses ACTUALLY applied by the resolved
+ * runtime for this dispatch — the intersection of "configured" and "in effect".
+ * Categories that produced nothing are left empty and the renderer omits them.
+ *
+ * Skills are the exception: the engine cannot know at prompt-render time WHICH
+ * of the available project skills the agent will actually invoke, and listing
+ * every discovered/available skill is exactly the "discovered not used" bug the
+ * PR-body block must avoid. So `availableSkills` is a REFERENCE list (project
+ * scope only, BLOCKING-3 no user-scope leak) that the playbook hands to the
+ * agent; the agent reports the subset it actually used. It is intentionally NOT
+ * rendered into the block by `buildHarnessSection`.
+ *
+ * @returns {{runtime:string, claudeMd:{native:boolean, files:string[]},
+ *            agentsMd:boolean, mcp:string[], availableSkills:string[]}}
+ */
+function computeDispatchHarnessInventory({
+  runtimeCli,
+  project = null,
+  worktreePath = '',
+  bareMode = false,
+  nativeClaudeMd = undefined,
+  claudeMdInjectedFiles = undefined,
+  propagateClaudeMd = true,
+  pathHints = [],
+  homeDir = os.homedir(),
+  existsFn = fs.existsSync,
+} = {}) {
+  const runtime = String(runtimeCli || '').trim() || 'copilot';
+  const inv = {
+    runtime,
+    claudeMd: { native: false, files: [] },
+    agentsMd: false,
+    mcp: [],
+    availableSkills: [],
+  };
+
+  let claudeMdCtx = null;
+  let preflight = null;
+  let registry = null;
+  try { claudeMdCtx = require('./claude-md-context'); } catch { /* optional */ }
+  try { preflight = require('./preflight'); } catch { /* optional */ }
+  try { registry = require('./runtimes'); } catch { /* optional */ }
+
+  // CLAUDE.md discovery is a runtime CAPABILITY (Claude reads CLAUDE.md itself;
+  // Copilot/Codex do not). Prefer the caller-resolved value; fall back to the
+  // adapter capability for callers that don't thread it.
+  const nativeCapable = (typeof nativeClaudeMd === 'boolean')
+    ? nativeClaudeMd
+    : (claudeMdCtx ? !!claudeMdCtx.runtimeAutoDiscoversClaudeMd(runtime) : false);
+
+  // A `--bare` invocation strips the runtime's native repo-context discovery, so
+  // native CLAUDE.md discovery is only in effect when the runtime is capable AND
+  // not running bare.
+  inv.claudeMd.native = nativeCapable && !bareMode;
+
+  if (!nativeCapable) {
+    // Copilot/Codex: the engine's bounded propagation injects CLAUDE.md only
+    // when the propagation flag is on. Prefer the authoritative injected-file
+    // result the engine actually produced this dispatch; fall back to discovery
+    // (under the same propagate gate) for callers that don't thread it. Scan the
+    // dispatch worktree, not the operator checkout the runtime never ran in.
+    if (propagateClaudeMd) {
+      if (Array.isArray(claudeMdInjectedFiles)) {
+        inv.claudeMd.files = claudeMdInjectedFiles.slice(0, MAX_NAMES);
+      } else if (claudeMdCtx) {
+        const scanRoot = worktreePath || (project && project.localPath) || '';
+        if (scanRoot) {
+          try {
+            const files = claudeMdCtx.discoverClaudeMdFiles({
+              projectRoot: scanRoot,
+              pathHints: Array.isArray(pathHints) ? pathHints : [],
+            });
+            inv.claudeMd.files = files.map(f => f.relPath);
+          } catch { /* degrade to none */ }
+        }
+      }
+    }
+  }
+
+  // AGENTS.md: the runtimes that do NOT read CLAUDE.md natively (Copilot/Codex)
+  // DO discover AGENTS.md natively; Claude reads CLAUDE.md instead. Report the
+  // category only when the resolved runtime performs the discovery AND an
+  // AGENTS.md actually applies in the dispatch checkout the runtime ran in —
+  // never as a bare capability claim that produced nothing.
+  inv.agentsMd = nativeCapable
+    ? false
+    : _agentsMdApplied({
+      scanRoot: worktreePath || (project && project.localPath) || '',
+      pathHints: Array.isArray(pathHints) ? pathHints : [],
+      existsFn,
+    });
+
+  // MCP + skills: reuse the diagnostic harness-rows source, scoped to this
+  // single project's ACTUAL checkout (the worktree), and enumerate the concrete
+  // names present on disk. Only PROJECT-scoped rows are reported — user-scoped
+  // (personal) MCP/skill directories are NOT disclosed in a public PR body, as
+  // they can leak private integration/client identifiers (e.g. a personal skill
+  // dir named `private-client-alpha`).
+  //
+  // MCP servers configured in the project are loaded/available to the runtime,
+  // so they are reported directly. Skills, by contrast, are only AVAILABLE — the
+  // engine can't know which the agent invokes — so they populate `availableSkills`
+  // (a reference the playbook hands to the agent) and are NOT rendered into the
+  // block; the agent reports the subset it actually used.
+  let adapter = null;
+  if (registry) { try { adapter = registry.resolveRuntime(runtime); } catch { adapter = null; } }
+  if (preflight && adapter && typeof preflight._runtimeHarnessRows === 'function') {
+    const scanProject = project
+      ? (worktreePath ? { ...project, localPath: worktreePath } : project)
+      : null;
+    try {
+      const rows = preflight._runtimeHarnessRows(adapter, {
+        homeDir,
+        projects: scanProject ? [scanProject] : [],
+        existsFn,
+      });
+      inv.mcp = _listMcpServerNames(rows.mcpConfigProject || []);
+      inv.availableSkills = _listSkillNames(rows.skillRootsProject || [], existsFn);
+    } catch { /* degrade to empty */ }
+  }
+
+  return inv;
+}
+
+/**
+ * Render the fenced "Repo harnesses used" markdown block from an inventory.
+ * Compact and used-only: the Runtime line always anchors the block, and every
+ * other engine-determinable category is emitted ONLY when it actually applied —
+ * no "none"/"n/a" filler rows and no explanatory preamble.
+ *
+ * Skills are deliberately NOT rendered here. The engine cannot know which of the
+ * available project skills the agent actually invoked, and enumerating all of
+ * them is the "discovered not used" bug this block must avoid. The playbook
+ * instructs the agent to add a `- **Skills used:** …` line for the skills it
+ * actually used (from `inventory.availableSkills`), or omit it entirely.
+ *
+ * The HTML-comment markers make the block idempotently replaceable when a PR
+ * body is refreshed.
+ */
+function buildHarnessSection(inventory) {
+  const inv = inventory || {};
+  const claudeMd = inv.claudeMd || { native: false, files: [] };
+
+  const lines = [
+    HARNESS_SECTION_HEADING,
+    '',
+    HARNESS_BLOCK_START,
+    `- **Runtime:** ${inv.runtime || 'unknown'}`,
+  ];
+
+  if (claudeMd.native) {
+    lines.push('- **CLAUDE.md:** native (claude)');
+  } else if (Array.isArray(claudeMd.files) && claudeMd.files.length) {
+    lines.push(`- **CLAUDE.md:** ${claudeMd.files.join(', ')}`);
+  }
+  if (inv.agentsMd) {
+    lines.push('- **AGENTS.md:** discovered');
+  }
+  if (Array.isArray(inv.mcp) && inv.mcp.length) {
+    lines.push(`- **MCP:** ${inv.mcp.join(', ')}`);
+  }
+
+  lines.push(HARNESS_BLOCK_END);
+  return lines.join('\n');
+}
+
+/**
+ * Convenience: compute the inventory for a dispatch and render the section.
+ * Returns `{ inventory, section }`. `section` is always a non-empty string.
+ */
+function renderHarnessSectionForDispatch(opts = {}) {
+  const inventory = computeDispatchHarnessInventory(opts);
+  return { inventory, section: buildHarnessSection(inventory) };
+}
+
+module.exports = {
+  HARNESS_SECTION_HEADING,
+  HARNESS_BLOCK_START,
+  HARNESS_BLOCK_END,
+  MAX_NAMES,
+  computeDispatchHarnessInventory,
+  buildHarnessSection,
+  renderHarnessSectionForDispatch,
+};

package/engine/inbox-store.js

@@ -239,7 +239,7 @@ function deleteInboxEntriesOlderThan(timestampMs, { unreadOnly = false } = {}) {
       query += ' AND unread = 1';
     }
     const result = db.prepare(query).run(...params);
-    if (result.changes > 0) _emitInboxEvent({ timestampMs, unreadOnly, action: 'delete_older_than' });
+    if (result.changes > 0) _emitInboxEvent({ timestampMs, unreadOnly, action: 'delete_older_than', deletedCount: result.changes });
     return { wrote: result.changes > 0, deletedCount: result.changes };
   });
 }