@yemi33/minions 0.1.2234 → 0.1.2236

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

@@ -932,14 +932,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/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.2234",
+  "version": "0.1.2236",
   "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"