@yemi33/minions 0.1.2235 → 0.1.2237

package/dashboard/js/refresh.js

@@ -147,7 +147,7 @@ const RENDER_VERSIONS = {
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
-  workItems: 3,
+  workItems: 4,
   skills: 1,
   commands: 1,
   mcpServers: 1,

package/dashboard/js/render-work-items.js

@@ -238,6 +238,10 @@ function wiRow(item) {
       })() +
     '</td>' +
     '<td style="white-space:nowrap">' +
+      // W-mqqa76pi — "View live output" opens the agent slide-in panel (live-output
+      // tab auto-selected when the agent is working). Only for genuinely active
+      // dispatches with a resolvable assigned agent id.
+      ((item.status === 'dispatched' && (item.dispatched_to || item.agent)) ? '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();openArtifact(\'agent\',\'' + escapeHtml(item.dispatched_to || item.agent) + '\')" title="View live output">&#x1F4FA;</button>' : '') +
       ((item.status === 'pending' || item.status === 'failed') ? '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();editWorkItem(\'' + escapeHtml(item.id) + '\',\'' + escapeHtml(item._source || '') + '\')" title="Edit work item">&#x270E;</button>' : '') +
       ((item.status === 'done' || item.status === 'failed') ? '<button class="pr-pager-btn" style="font-size:var(--text-xs);padding:1px 6px;color:var(--muted);border-color:var(--border);margin-right:4px" onclick="event.stopPropagation();archiveWorkItem(\'' + escapeHtml(item.id) + '\',\'' + escapeHtml(item._source || '') + '\')" title="Archive work item">&#x1F4E6;</button>' : '') +
       ((item.status === 'done' || item.status === 'failed') && !item._humanFeedback ? '<button class="btn-action" style="margin-right:4px" onclick="event.stopPropagation();feedbackWorkItem(\'' + escapeHtml(item.id) + '\',\'' + escapeHtml(item._source || '') + '\')" title="Give feedback">&#x1F44D;&#x1F44E;</button>' : (item._humanFeedback ? '<span style="font-size:var(--text-xs)" title="Feedback given">' + (item._humanFeedback.rating === 'up' ? '&#x1F44D;' : '&#x1F44E;') + '</span> ' : '')) +
@@ -699,6 +703,14 @@ function _wiRenderDetail(item) {
       return ' <span class="pr-badge needs-attention" style="font-size:var(--text-xs);margin-left:4px" title="See &quot;Why this is blocked&quot; below">&#x26A0; Needs attention</span>';
     })() +
     '</div>';
+  // W-mqqa76pi — Prominent "View live output" button for an actively-dispatched
+  // WI. Opens the agent slide-in panel via openArtifact('agent', id), which
+  // resets the modal stack and selects the live-output tab when the agent is
+  // working. Gated on status==='dispatched' AND a resolvable assigned agent id.
+  if (item.status === 'dispatched' && (item.dispatched_to || item.agent)) {
+    var _wiLiveAgentId = item.dispatched_to || item.agent;
+    html += '<div style="margin-bottom:12px"><button class="pr-pager-btn" style="font-size:var(--text-base);padding:4px 12px;color:var(--green);border-color:var(--green)" onclick="openArtifact(\'agent\',\'' + escapeHtml(_wiLiveAgentId) + '\')" title="View live output">&#x1F4FA; View live output</button></div>';
+  }
   // Work item id — shown in the modal body (not just the title) so operators can
   // read/copy the canonical id (W-… or sched-…) when deeplinking in from a note.
   html += field('ID', '<code style="font-size:var(--text-sm);background:var(--surface2);padding:2px 6px;border-radius:var(--radius-sm)">' + escapeHtml(item.id || '—') + '</code>');
@@ -932,14 +944,44 @@ function _wiRenderDetail(item) {
   // (work_item: / wi: / sourceItem:). Slim string[] field set by
   // engine/queries.js#getWorkItems from _buildNotesByWiMap. Each entry is
   // either a bare inbox filename or `archive:<filename>` for archive notes.
+  //
+  // #308 — repeated attempts for one WI used to render a flat pile of
+  // indistinguishable note chips (every per-attempt failure report + legacy
+  // harness-usage note shown beside the final agent report). Partition the
+  // notes: per-attempt failure/partial reports and legacy harness-usage notes
+  // are GROUPED into a collapsed "Prior attempts" disclosure, leaving the final
+  // agent findings note(s) as the primary, always-visible chips. Backward
+  // compatible — every grouped note still opens via the same renderArtifactLink
+  // chip, just behind a <details> instead of in the flat list.
   if (Array.isArray(item._notes) && item._notes.length > 0) {
-    var mentionPills = item._notes.map(function(token) {
+    var _mentionPill = function(token) {
       var isArchive = token.indexOf('archive:') === 0;
       var fname = isArchive ? token.slice(8) : token;
       var label = fname.replace(/\.md$/, '').slice(0, 30) + (isArchive ? ' (archived)' : '');
       return renderArtifactLink({ type: 'note', id: fname, label: label, title: 'Note: ' + fname });
-    }).join(' ');
-    html += field('Mentions', '<div style="display:flex;flex-wrap:wrap;gap:4px">' + mentionPills + '</div>');
+    };
+    // A note is a "prior attempt" chip when its filename slug marks it as an
+    // engine-emitted per-attempt failure/partial report or a legacy
+    // harness-usage note. These are keyed off the writeToInbox slug embedded in
+    // the filename (agent-failure-/agent-failed-/agent-partial-/harness-usage-),
+    // so the test is a pure string check independent of frontmatter.
+    var _isPriorAttemptNote = function(token) {
+      var fname = token.indexOf('archive:') === 0 ? token.slice(8) : token;
+      return /(?:^|-)(?:agent-fail(?:ure|ed)|agent-partial|harness-usage)-/.test(fname);
+    };
+    var primaryNotes = item._notes.filter(function(t) { return !_isPriorAttemptNote(t); });
+    var priorNotes = item._notes.filter(_isPriorAttemptNote);
+    var mentionHtml = '';
+    if (primaryNotes.length > 0) {
+      mentionHtml += '<div style="display:flex;flex-wrap:wrap;gap:4px">' + primaryNotes.map(_mentionPill).join(' ') + '</div>';
+    }
+    if (priorNotes.length > 0) {
+      mentionHtml += '<details style="margin-top:' + (primaryNotes.length > 0 ? '6px' : '0') + '">'
+        + '<summary style="cursor:pointer;color:var(--muted);font-size:var(--text-sm)">Prior attempts (' + priorNotes.length + ')</summary>'
+        + '<div style="display:flex;flex-wrap:wrap;gap:4px;margin-top:4px">' + priorNotes.map(_mentionPill).join(' ') + '</div>'
+        + '</details>';
+    }
+    if (mentionHtml) html += field('Mentions', mentionHtml);
   }
 
   if (item._totalCostUsd != null) html += field('Cumulative Cost', '$' + Number(item._totalCostUsd).toFixed(4));

package/dashboard.js

@@ -1977,6 +1977,61 @@ setInterval(() => checkNpmVersion().catch(() => {}), _getVersionCheckInterval())
 let _diskVersionCache = null;
 let _diskVersionCacheTs = 0;
 const DISK_VERSION_TTL = 60000; // re-check every 60s
+
+// Read the short HEAD commit by parsing `.git` directly — NO `git` subprocess.
+// The old `execSync('git rev-parse --short HEAD', { timeout: 5000 })` spawned a
+// synchronous child process on the dashboard's single event loop; under
+// concurrent agent git activity (worktree add/merge holding repo locks) that
+// subprocess could take its full 5s timeout, and because getDiskVersion runs
+// inside the /api/status rebuild, every in-flight poll blocked for that whole
+// window. Reading `.git/HEAD` + the resolved ref (loose ref, then packed-refs
+// fallback) is a couple of tiny synchronous file reads with zero process spawn.
+// Returns { commit, isGitRepo }: commit is the 7-char short SHA or null.
+function _readGitHeadShort(repoDir) {
+  try {
+    const gitPath = path.join(repoDir, '.git');
+    let gitDir = gitPath;
+    const st = fs.statSync(gitPath); // throws if no `.git` → caught → not a repo
+    if (st.isFile()) {
+      // Linked worktree: `.git` is a file whose first line reads `gitdir: <abs>`.
+      const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs.readFileSync(gitPath, 'utf8'));
+      if (!m) return { commit: null, isGitRepo: false };
+      gitDir = path.isAbsolute(m[1]) ? m[1] : path.resolve(repoDir, m[1]);
+    }
+    const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+    let sha = null;
+    const refM = /^ref:\s*(.+?)\s*$/.exec(head);
+    if (refM) {
+      const ref = refM[1];
+      try { sha = fs.readFileSync(path.join(gitDir, ref), 'utf8').trim() || null; } catch {}
+      if (!sha) {
+        // packed-refs fallback (git gc packs loose refs). For the main repo
+        // gitDir IS the common gitdir, so packed-refs lives directly under it.
+        try {
+          const line = fs.readFileSync(path.join(gitDir, 'packed-refs'), 'utf8')
+            .split('\n').find(l => l.endsWith(' ' + ref));
+          if (line) sha = line.slice(0, 40);
+        } catch {}
+      }
+    } else if (/^[0-9a-f]{40}$/i.test(head)) {
+      sha = head; // detached HEAD: the SHA is written directly into HEAD
+    }
+    return { commit: sha ? sha.slice(0, 7) : null, isGitRepo: true };
+  } catch {
+    return { commit: null, isGitRepo: false };
+  }
+}
+
+// Two git short-SHA abbreviations name the same commit when one is a prefix of
+// the other. `git rev-parse --short` picks the minimum-unique length (often 8),
+// while _readGitHeadShort emits a fixed 7 — a strict `!==` between them would
+// false-positive into a spurious "version stale" banner. Prefix comparison is
+// the robust check across abbreviation-length differences.
+function _commitsDiffer(a, b) {
+  if (!a || !b) return false;
+  return !(a.startsWith(b) || b.startsWith(a));
+}
+
 function getDiskVersion() {
   const now = Date.now();
   if (_diskVersionCache && (now - _diskVersionCacheTs) < DISK_VERSION_TTL) return _diskVersionCache;
@@ -1990,10 +2045,11 @@ function getDiskVersion() {
   if (!diskVersion) {
     try { diskVersion = require('@yemi33/minions/package.json').version; } catch {}
   }
-  let diskCommit = null;
-  let isGitRepo = false;
-  // Prefer git (authoritative for repo-based dev), fall back to .minions-commit (installed copies)
-  try { diskCommit = require('child_process').execSync('git rev-parse --short HEAD', { cwd: MINIONS_DIR, encoding: 'utf8', timeout: 5000, windowsHide: true }).trim(); isGitRepo = true; } catch {}
+  // Prefer git (authoritative for repo-based dev), fall back to .minions-commit (installed copies).
+  // Parse `.git` directly instead of spawning `git rev-parse` — see _readGitHeadShort.
+  const head = _readGitHeadShort(MINIONS_DIR);
+  let diskCommit = head.commit;
+  let isGitRepo = head.isGitRepo;
   if (!diskCommit) {
     try { diskCommit = fs.readFileSync(path.join(MINIONS_DIR, '.minions-commit'), 'utf8').trim() || null; } catch {}
   }
@@ -2450,9 +2506,9 @@ function _buildStatusSlowState() {
       const engine = getEngineState();
       const { diskVersion, diskCommit, isGitRepo } = getDiskVersion();
       const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
-                          !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
+                          _commitsDiffer(engine.codeCommit, diskCommit);
       const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
-                             !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
+                             _commitsDiffer(diskCommit, _dashboardVersion.codeCommit);
       return {
         running: engine.codeVersion || null,
         runningCommit: engine.codeCommit || null,
@@ -3056,17 +3112,34 @@ async function _handleStatusRequest(req, res) {
   try {
     _recordDashboardBrowserPresenceFromRequest(req);
 
-    // Ensure cache is fresh + yields the event loop mid-rebuild so CC SSE
-    // heartbeats keep flowing during slow rebuilds. Synchronous getStatus()
-    // still works for SSE-periodic-push callers that can't await.
-    try { await refreshStatusAsync(); } catch { /* fall through — getStatusJson will sync-rebuild */ }
-
-    // Race-guard fallback: if refresh discarded its result because
-    // invalidateStatusCache() fired mid-rebuild, _statusCache is still null.
-    // Trigger a synchronous rebuild here so the ETag we compute reflects
-    // freshly-built post-invalidate state, not the stale pre-invalidate one.
-    if (!_statusCache) {
-      try { getStatus(); } catch { /* getStatusJson below will retry */ }
+    // Stale-while-revalidate (perf, W-status-swr). Two staleness modes exist:
+    //   • HARD invalidation — invalidateStatusCache() sets _statusCache = null
+    //     because a mutation MUST be reflected before we answer. There is
+    //     nothing valid to serve, so we await one rebuild (cold path below).
+    //   • SOFT staleness — the event-version / mtime signal advanced (e.g. an
+    //     agent emitted a state event) but _statusCache still holds a valid,
+    //     seconds-old snapshot. Under active-agent load this fires on nearly
+    //     every 4s poll. Awaiting the rebuild here is what stalled every
+    //     in-flight poll for 6–15s, because the single-flight rebuild runs
+    //     synchronous fs/git probes to completion before resolving.
+    // When we have ANY snapshot, never block the request: kick the refresh in
+    // the background (its result lands in _statusCache and bumps the ETag for
+    // the NEXT poll) and serve the current cache now. A 4s-old envelope for a
+    // 4s poller is fine; a 15s-blocked request is not.
+    if (_statusCache) {
+      Promise.resolve().then(refreshStatusAsync).catch(() => { /* next poll + SSE push retry */ });
+    } else {
+      // Cold start or post-hard-invalidation: nothing to serve → await one
+      // rebuild. refreshStatusAsync yields the event loop mid-rebuild so CC
+      // SSE heartbeats keep flowing during a slow build.
+      try { await refreshStatusAsync(); } catch { /* fall through — getStatusJson will sync-rebuild */ }
+      // Race-guard fallback: if refresh discarded its result because
+      // invalidateStatusCache() fired mid-rebuild, _statusCache is still null.
+      // Trigger a synchronous rebuild here so the ETag we compute reflects
+      // freshly-built post-invalidate state, not the stale pre-invalidate one.
+      if (!_statusCache) {
+        try { getStatus(); } catch { /* getStatusJson below will retry */ }
+      }
     }
 
     // ETag = monotonic cache version. Bumped on every successful rebuild and
@@ -12530,9 +12603,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const { diskVersion, diskCommit, isGitRepo } = getDiskVersion();
       const engine = getEngineState();
       const engineStale = !!(engine.codeVersion && diskVersion && engine.codeVersion !== diskVersion) ||
-                          !!(engine.codeCommit && diskCommit && engine.codeCommit !== diskCommit);
+                          _commitsDiffer(engine.codeCommit, diskCommit);
       const dashboardStale = !!(diskVersion && _dashboardVersion.codeVersion && diskVersion !== _dashboardVersion.codeVersion) ||
-                             !!(diskCommit && _dashboardVersion.codeCommit && diskCommit !== _dashboardVersion.codeCommit);
+                             _commitsDiffer(diskCommit, _dashboardVersion.codeCommit);
       return jsonReply(res, 200, {
         current: diskVersion,
         currentCommit: diskCommit,
@@ -14060,6 +14133,11 @@ module.exports = {
   _setStatusRefreshHook,
   _resetStatusCacheForTesting,
   _ifNoneMatchHasEtag,
+  // W-status-swr — exported for direct unit tests of the subprocess-free git
+  // HEAD parser and the prefix-tolerant short-SHA comparison. No production
+  // caller imports these; they are test seams.
+  _readGitHeadShort,
+  _commitsDiffer,
   // Exported for the engine-stale-two-signal test (W-mpof1xxe000ac689) — the
   // staleness verdict it stamps on engine.heartbeatStale is the contract under
   // test. No production caller imports this; it is a test seam.

package/docs/README.md

@@ -29,7 +29,7 @@ Architecture, design proposals, and lifecycle references for people working on t
 - [design-state-storage.md](design-state-storage.md) — Design proposal evaluating five database options for replacing Minions' file-based JSON state; recommends `node:sqlite` as the medium-term target (accepted; implementation tracked in CHANGELOG.md Phases 0–9).
 - [harness-mode.md](harness-mode.md) — Tri-Agent Harness Mode (`harness_mode: "tri_agent"` on scheduled tasks): Planner → Generator → Evaluator loop that iterates a shared on-disk artifact until a rubric passes or the iteration cap fires.
 - [harness-propagation.md](harness-propagation.md) — How user-level and project-local harness assets (skills, slash-commands, MCP config, `CLAUDE.md` / `AGENTS.md`) propagate into an agent's worktree via `--add-dir`, the `harnessPropagateProjectLocal` flag, and the project-local-on-main worktree-visibility footgun.
-- [harness-transparency.md](harness-transparency.md) — The `harnessUsed` self-report contract: capture (agent reports the skills / MCPs / commands / docs it used) → ground (engine cross-checks against `_harnessPropagated` and annotates `grounded:true\|false`, never dropping) → surface (PR comment, notes/inbox digest, work-item modal).
+- [harness-transparency.md](harness-transparency.md) — The `harnessUsed` self-report contract: capture (agent reports the skills / MCPs / commands / docs it used) → ground (engine cross-checks against `_harnessPropagated` and annotates `grounded:true\|false`, never dropping) → surface (PR comment, final agent note, work-item modal).
 - [kb-sweep.md](kb-sweep.md) — Knowledge-base consolidation sweep (hash dedup → LLM batch dedup/reclassify → per-entry compress) and the detached runner that keeps it alive across `minions restart`.
 - [keep-processes.md](keep-processes.md) — `meta.keep_processes` sidecar contract: when to use it vs managed-spawn, sidecar schema, caps, and the [`engine/keep-process-sweep.js`](../engine/keep-process-sweep.js) lifecycle.
 - [live-checkout-mode.md](live-checkout-mode.md) — Per-project opt-in `checkoutMode: 'live'`: skips `git worktree add` and dispatches in-place inside `project.localPath` for `repo`-managed trees, submodule-heavy repos, deep Windows paths, and native build state. Includes the refuse-on-dirty contract and the per-project mutating-concurrency cap of 1.

package/docs/harness-transparency.md

@@ -119,10 +119,13 @@ evaluation pass) can see what tooling drove a dispatch:
    paths review/fix agents append the section themselves per
    `playbooks/shared-rules.md` → "Harness transparency / self-report". Every
    surface consumes the one renderer, so there is no second formatter to drift.
-2. **notes/inbox digest** — harness usage is summarized into the learnings /
-   inbox stream that feeds consolidation, so cross-task patterns ("everyone
-   reaches for skill X on Android fixes") become visible to the team-memory
-   layer.
+2. **Final agent note** — for a non-clean completion (failure / partial) the
+   single final agent report (`engine/lifecycle.js#writeNonCleanAgentReport`)
+   folds the grounded harness footprint in as the same `buildHarnessUsedSection`
+   block, so the learnings / inbox stream that feeds consolidation still carries
+   it without a separate per-attempt `harness-usage-*` note. Clean completions
+   rely on the work-item modal surface (#3) instead — they write no inbox note
+   at all (#308 removed the standalone harness-usage digest to cut note spam).
 3. **Work-item detail modal** — the dashboard work-item modal shows the
    grounded harness list alongside the completion artifacts, with the
    `grounded: false` entries visually distinguished (P-d5a6f7c4). On

package/engine/lifecycle.js

@@ -4094,6 +4094,11 @@ function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredComp
   const structuredLines = structuredCompletion
     ? Object.entries(structuredCompletion).map(([key, value]) => `- ${key}: ${value}`).join('\n')
     : '- none';
+  // #308 — fold the agent's grounded harness footprint into THIS final agent
+  // report instead of emitting a separate `harness-usage-*` inbox note per
+  // attempt. buildHarnessUsedSection returns '' for an absent/empty/malformed
+  // record, so the section is appended only when there is something to show.
+  const harnessSection = buildHarnessUsedSection(structuredCompletion?.harnessUsed);
   const content = [
     `# Agent ${outcome === 'partial' ? 'Partially Completed' : 'Reported Failure'}: ${title}`,
     '',
@@ -4108,65 +4113,11 @@ function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredComp
     structuredLines,
     '',
     resultSummary ? `## Summary\n${resultSummary}` : '## Summary\n(no agent summary captured)',
+    harnessSection ? `\n${harnessSection}` : '',
   ].filter(Boolean).join('\n');
   shared.writeToInbox(agentId || 'engine', `agent-${outcome}-${dispatchItem.id}`, content, null, metadata);
 }
 
-/**
- * P-f3c8b5e6 — Harness Transparency, Stage-3 readout #3: notes/inbox digest.
- *
- * Routes a compact, one-block-per-dispatch harness-usage summary into
- * notes/inbox/ so engine/consolidation.js#consolidateInbox folds it into the
- * notes.md digest alongside the other inbox findings. Clean dispatches don't
- * otherwise write an inbox note (only failures/non-clean outcomes do, via
- * writeNonCleanAgentReport / dispatch.js writeFailedAgentReport), so without
- * this the harness footprint never reaches the digest for successful runs.
- *
- * Gating: writes nothing unless the GROUNDED harnessUsed (the canonical
- * { skills, mcpServers, commands, docs } shape produced by
- * shared.groundHarnessUsed) renders at least one entry. The render check is
- * delegated to buildHarnessUsedSection (the same platform-neutral renderer the
- * PR-comment surface uses — one renderer, no drift), which returns '' for
- * absent/malformed/all-empty records.
- *
- * Dedup: the inbox slug is keyed on the work-item id (falling back to the
- * dispatch id), so retries of the same WI — which get a fresh dispatch id —
- * collapse onto one note per day (writeToInbox skips when a same-prefix file
- * already exists). This keeps busy fleets from flooding the digest.
- *
- * Best-effort: never throws into the completion path. Returns the note id on
- * write, or false when nothing was written (empty footprint, dedup hit, or no
- * dispatch id).
- */
-function writeHarnessUsageDigest(dispatchItem, agentId, harnessUsed) {
-  try {
-    if (!dispatchItem?.id) return false;
-    const section = buildHarnessUsedSection(harnessUsed);
-    if (!section) return false; // empty / absent / malformed → write nothing
-    const itemId = dispatchItem.meta?.item?.id || '';
-    const dedupKey = itemId || dispatchItem.id;
-    const title = dispatchItem.meta?.item?.title || dispatchItem.task || dispatchItem.id;
-    const metadata = {
-      dispatchId: dispatchItem.id,
-      sourceItem: itemId || null,
-      kind: 'harness-usage',
-    };
-    const content = [
-      `# Harnesses used: ${title}`,
-      '',
-      `**Agent:** ${agentId || 'engine'}`,
-      `**Dispatch:** \`${dispatchItem.id}\``,
-      itemId ? `**Work Item:** \`${itemId}\`` : '',
-      `**Type:** ${dispatchItem.type || 'unknown'}`,
-      '',
-      section,
-    ].filter(Boolean).join('\n');
-    return shared.writeToInbox(agentId || 'engine', `harness-usage-${dedupKey}`, content, null, metadata);
-  } catch (err) {
-    log('warn', `Harness-usage inbox digest write failed for ${dispatchItem?.id} (non-fatal): ${err.message}`);
-    return false;
-  }
-}
 
 /**
  * Permissively pull all assistant-message content out of a stream-json log.
@@ -4753,9 +4704,15 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // The grounded result replaces `structuredCompletion.harnessUsed` IN PLACE, so
   // it rides the existing `structuredCompletion` storage onto the completed
   // dispatch record (completeDispatch persists `item.structuredCompletion`) for
-  // the Stage-3 surfaces (PR comment / inbox digest / WI modal) to read. Pure,
-  // non-destructive (grounded:false entries are kept + flagged, never dropped),
-  // and best-effort: any failure here must never block completion.
+  // the Stage-3 surfaces (PR comment / final agent note / WI modal) to read.
+  // Pure, non-destructive (grounded:false entries are kept + flagged, never
+  // dropped), and best-effort: any failure here must never block completion.
+  //
+  // #308 — the grounded footprint is no longer routed to its own
+  // `harness-usage-*` inbox note (that produced one duplicate-looking note chip
+  // per attempt). For clean completions the structured `_harnessUsed` WI-modal
+  // UI surfaces it; for non-clean outcomes writeNonCleanAgentReport folds the
+  // same buildHarnessUsedSection block into the single final agent note.
   if (structuredCompletion && structuredCompletion.harnessUsed) {
     try {
       const propagated = resolveHarnessPropagated(dispatchItem);
@@ -4764,11 +4721,6 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     } catch (err) {
       log('warn', `Harness grounding cross-check failed for ${dispatchItem.id} (non-fatal): ${err.message}`);
     }
-    // P-f3c8b5e6 — Stage-3 readout #3: route the grounded footprint into the
-    // notes/inbox digest. Gated on a non-empty render + deduped per WI inside
-    // writeHarnessUsageDigest, so this is safe to call unconditionally for
-    // every dispatch (clean or not) that self-reported a harness footprint.
-    writeHarnessUsageDigest(dispatchItem, agentId, structuredCompletion.harnessUsed);
   }
 
   const completionGateSummary = resultSummary || (typeof stdout === 'string' && !stdout.includes('"type":') ? stdout : '');
@@ -5903,8 +5855,10 @@ module.exports = {
   markMissingPrAttachment,
   parseCompletionReportFile,
   resolveHarnessPropagated,
-  // P-f3c8b5e6 — notes/inbox harness-usage digest (exported for unit testing).
-  writeHarnessUsageDigest,
+  // #308 — exported for unit testing: the final non-clean agent note now folds
+  // the grounded harness footprint in as a section instead of emitting a
+  // standalone harness-usage-* inbox note.
+  writeNonCleanAgentReport,
   normalizeCompletionArtifacts,
   completionArtifactToNoteEntry,
   mergeArtifactNotes,

package/package.json

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