@yemi33/minions 0.1.2313 → 0.1.2315

package/dashboard/js/refresh.js

@@ -136,7 +136,8 @@ const RENDER_VERSIONS = {
   inbox: 2,
   // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
   // Bumped 5→6 for multi-select hybrid liveValidation.type support (W-mr2m1ute000a9c01).
-  projects: 6,
+  // Bumped 6→7 for the liveValidation.autoDispatch toggle + pill "· auto-validate" suffix (W-mr2q361a00097e5c).
+  projects: 7,
   notes: 1,
   prd: 3,
   prs: 3,
@@ -149,7 +150,9 @@ const RENDER_VERSIONS = {
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
-  workItems: 7,
+  // Bumped 7→8: WI detail modal's branch pill moved out of the Artifacts
+  // chip row into its own non-interactive "Branch" field (W-mr2qjr3b0002522f).
+  workItems: 8,
   skills: 1,
   commands: 1,
   mcpServers: 1,

package/dashboard/js/render-other.js

@@ -112,7 +112,15 @@ function _renderWorktreeModePill(p) {
     if (types.length > 0) {
       const typesText = types.join(', ');
       const vt = escapeHtml(typesText);
-      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type(s) run in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree). Click to change.">⚡ Hybrid · ' + vt + '</span>';
+      // W-mr2q361a00097e5c — visibly distinguish "Hybrid (manual validation)"
+      // from "Hybrid (auto-validate)" so the operator doesn't have to reopen
+      // the picker to discover whether autoDispatch is silently off.
+      const autoDispatch = p.liveValidationAutoDispatch === true;
+      const autoSuffix = autoDispatch ? ' · auto-validate' : '';
+      const autoTitleBit = autoDispatch
+        ? ' A validation work item is automatically dispatched after each coding work item completes.'
+        : ' Auto-validation is OFF — validation must be dispatched manually after each coding work item completes.';
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type(s) run in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree).' + escHtml(autoTitleBit) + ' Click to change.">⚡ Hybrid · ' + vt + escHtml(autoSuffix) + '</span>';
     }
     return ' <span class="project-mode-pill project-mode-live project-mode-pill-clickable"' + common + ' title="Live-checkout dispatch mode — agents run in-place inside the project working tree (no isolated worktree); capped to one mutating dispatch and refused on a dirty tree. Click to change.">⚡ Live checkout</span>';
   }
@@ -276,6 +284,24 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   });
   menu.appendChild(checkboxList);
 
+  // W-mr2q361a00097e5c — "auto-validate" toggle for liveValidation.autoDispatch.
+  // Default UNCHECKED to match today's implicit default (autoDispatch absent
+  // / false) so reopening the picker on a project that has never set this
+  // never silently flips it on; preselect from the project's CURRENT value
+  // when one is already configured (mirrors the type-checkbox preselect
+  // above) so reopening an already-hybrid project reflects its real state.
+  const autoDispatchRow = document.createElement('label');
+  autoDispatchRow.className = 'checkout-mode-menu-checkbox-row checkout-mode-menu-autodispatch-row';
+  const autoDispatchCb = document.createElement('input');
+  autoDispatchCb.type = 'checkbox';
+  autoDispatchCb.className = 'checkout-mode-menu-checkbox checkout-mode-menu-autodispatch-checkbox';
+  autoDispatchCb.checked = project.liveValidationAutoDispatch === true;
+  const autoDispatchText = document.createElement('span');
+  autoDispatchText.textContent = 'Automatically validate after each coding work item completes';
+  autoDispatchRow.appendChild(autoDispatchCb);
+  autoDispatchRow.appendChild(autoDispatchText);
+  menu.appendChild(autoDispatchRow);
+
   const actions = document.createElement('div');
   actions.className = 'checkout-mode-menu-actions';
 
@@ -297,8 +323,9 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   applyBtn.addEventListener('click', function() {
     const types = checkboxes.filter(function(cb) { return cb.checked; }).map(function(cb) { return cb.value; });
     if (types.length === 0) return; // require at least one selected type
+    const autoDispatch = autoDispatchCb.checked;
     _closeCheckoutModeMenu();
-    _applyCheckoutModeChange(projectName, 'live', types);
+    _applyCheckoutModeChange(projectName, 'live', types, autoDispatch);
   });
   actions.appendChild(applyBtn);
 
@@ -316,18 +343,33 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
 // whichever shape is passed through is what gets POSTed as
 // liveValidation.type, so shared.validateLiveValidation on the server decides
 // the final persisted shape.
-async function _applyCheckoutModeChange(projectName, newMode, liveValidationType) {
+//
+// `autoDispatch` (W-mr2q361a00097e5c, optional, only meaningful for hybrid
+// mode) threads the "auto-validate" checkbox value through to the POST body
+// as liveValidation.autoDispatch. Non-hybrid callers (Worktrees / full Live
+// checkout) omit it, which correctly clears autoDispatch when leaving hybrid
+// mode (liveValidation is null entirely in that case).
+async function _applyCheckoutModeChange(projectName, newMode, liveValidationType, autoDispatch) {
   const project = _findProjectInLastStatus(projectName);
   if (!project) return;
   const typesForLabel = liveValidationType
     ? (Array.isArray(liveValidationType) ? liveValidationType : [liveValidationType])
     : [];
+  const autoDispatchOn = typesForLabel.length > 0 && !!autoDispatch;
   const label = newMode === 'worktree'
     ? 'Worktrees'
     : (typesForLabel.length > 0 ? ('Hybrid (' + typesForLabel.join(', ') + ')') : 'Live checkout');
+  // W-mr2q361a00097e5c — auto-validation is a workflow-changing decision
+  // (agents stop running local builds once it's on), so call it out
+  // explicitly in the confirm message rather than burying it in the label.
+  const autoDispatchNote = typesForLabel.length > 0
+    ? (autoDispatchOn
+      ? ' Auto-validation will be turned ON — a validation work item will be dispatched automatically after each coding work item completes, and coding agents will skip local builds/tests.'
+      : ' Auto-validation will be OFF — you will need to dispatch validation manually after each coding work item completes.')
+    : '';
   const ok = await confirmDialog({
     title: 'Change checkout mode?',
-    message: 'Switch "' + projectName + '" to ' + label + '? This changes how every future dispatch on this project runs.',
+    message: 'Switch "' + projectName + '" to ' + label + '?' + autoDispatchNote + ' This changes how every future dispatch on this project runs.',
     confirmLabel: 'Change mode',
     cancelLabel: 'Cancel',
     danger: newMode !== 'worktree',
@@ -336,11 +378,13 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
 
   const prevMode = project.checkoutMode;
   const prevType = project.liveValidationType;
+  const prevAutoDispatch = project.liveValidationAutoDispatch;
   const nextType = (newMode === 'live' && liveValidationType) ? liveValidationType : null;
   // Optimistic flip BEFORE awaiting the API call (per dashboard convention —
   // see projectChipRemove / removePinnedNote); reverted in the catch below.
   project.checkoutMode = newMode;
   project.liveValidationType = nextType;
+  project.liveValidationAutoDispatch = nextType ? autoDispatchOn : false;
   if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
 
   try {
@@ -351,7 +395,7 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
         projects: [{
           name: projectName,
           checkoutMode: newMode,
-          liveValidation: nextType ? { type: nextType } : null,
+          liveValidation: nextType ? { type: nextType, autoDispatch: autoDispatchOn } : null,
         }],
       }),
     });
@@ -361,6 +405,7 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
   } catch (err) {
     project.checkoutMode = prevMode;
     project.liveValidationType = prevType;
+    project.liveValidationAutoDispatch = prevAutoDispatch;
     if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
     showToast('cmd-toast', 'Failed to update checkout mode: ' + (err && err.message || err), false);
   }

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

@@ -889,8 +889,6 @@ function _wiRenderDetail(item) {
   // chip is needed.
   var arts = item._artifacts || {};
   var artPills = '';
-  var branchStyle = 'display:inline-flex;align-items:center;gap:3px;padding:2px 8px;border-radius:10px;font-size:var(--text-sm);background:var(--surface2);border:1px solid var(--border);color:var(--text);cursor:default';
-  if (arts.branch) artPills += '<span style="' + branchStyle + '">🌿 ' + escapeHtml(arts.branch) + '</span> ';
   if (arts.plan) artPills += renderArtifactLink({ type: 'plan', id: arts.plan, label: 'Plan' }) + ' ';
   if (arts.prd) artPills += renderArtifactLink({ type: 'prd', id: arts.prd, label: 'PRD' }) + ' ';
   if (arts.sourcePlan) artPills += renderArtifactLink({ type: 'plan', id: arts.sourcePlan, label: 'Source Plan' }) + ' ';
@@ -915,6 +913,13 @@ function _wiRenderDetail(item) {
     });
   }
   if (artPills) html += field('Artifacts', '<div style="display:flex;flex-wrap:wrap;gap:4px">' + artPills + '</div>');
+  // Branch is not a clickable artifact link (no navigation target), so it is
+  // rendered as its own plain-text field rather than sharing the Artifacts
+  // pill row's chip styling — matches render-prs.js's PR-modal "Branch:"
+  // field (dashboard/js/render-prs.js:517), which uses a plain <code> tag
+  // instead of the clickable-chip pill style (issue: branch pill looked like
+  // a dead artifact link).
+  if (arts.branch) html += field('Branch', '🌿 <code style="font-size:var(--text-sm);background:var(--surface2);padding:2px 6px;border-radius:var(--radius-sm)">' + escapeHtml(arts.branch) + '</code>');
 
   // P-d5a6f7c4 (Harness Transparency, Stage 3 — surface). Render the harness
   // usage the agent self-reported. Shape:

package/dashboard/styles.css

@@ -1341,6 +1341,9 @@
   }
   .checkout-mode-menu-checkbox-row:hover { background: var(--surface); }
   .checkout-mode-menu-checkbox { cursor: pointer; }
+  .checkout-mode-menu-autodispatch-row {
+    margin-top: 6px; padding-top: 10px; border-top: 1px solid var(--border);
+  }
   .checkout-mode-menu-actions {
     display: flex; justify-content: flex-end; gap: 6px; padding-top: 4px;
   }

package/dashboard.js

@@ -1156,16 +1156,16 @@ function findWorkItemsTargetById(id, source, projects = PROJECTS) {
   if (explicitSource) {
     const target = resolveProjectSourceTarget(source, projects);
     if (target.error) return { error: target.error };
-    const items = shared.safeJson(target.wiPath) || [];
+    const items = shared.safeJsonArr(target.wiPath);
     return { ...target, found: items.some(i => i.id === id) };
   }
 
   const central = resolveProjectSourceTarget('central', projects);
-  const centralItems = shared.safeJson(central.wiPath) || [];
+  const centralItems = shared.safeJsonArr(central.wiPath);
   if (centralItems.some(i => i.id === id)) return { ...central, found: true };
   for (const project of projects) {
     const target = resolveProjectSourceTarget(project.name, projects);
-    const items = shared.safeJson(target.wiPath) || [];
+    const items = shared.safeJsonArr(target.wiPath);
     if (items.some(i => i.id === id)) return { ...target, found: true };
   }
   return { found: false };
@@ -2769,6 +2769,13 @@ function _buildStatusSlowState() {
         liveValidationType: (shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.type)
           ? p.liveValidation.type
           : null,
+        // W-mr2q361a00097e5c — surface liveValidation.autoDispatch alongside
+        // .type so the hybrid picker can preselect the "auto-validate"
+        // checkbox and the pill can visibly distinguish manual vs
+        // auto-validating hybrid projects. Only meaningful when checkoutMode
+        // is 'live'; false otherwise (matches the implicit today-default of
+        // autoDispatch being absent/false).
+        liveValidationAutoDispatch: !!(shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.autoDispatch === true),
       };
     }),
     autoMode: {
@@ -8069,7 +8076,7 @@ const server = http.createServer(async (req, res) => {
         const config = queries.getConfig();
         const allWorkItems = queries.getWorkItems(config);
         const planWis = allWorkItems.filter(w => w.sourcePlan === body.file && w.itemType !== 'pr' && w.itemType !== 'verify');
-        const allPrs = PROJECTS.flatMap(p => shared.safeJson(shared.projectPrPath(p)) || []);
+        const allPrs = PROJECTS.flatMap(p => shared.safeJsonArr(shared.projectPrPath(p)));
         const prLinks = shared.getPrLinks();
         const implContext = (plan.missing_features || []).map(f => {
           const wi = planWis.find(w => w.id === f.id);
@@ -11004,7 +11011,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
   async function handleSettingsUpdate(req, res) {
     try {
       const body = await readBody(req);
-      const config = safeJson(CONFIG_PATH) || {};
+      const config = safeJsonObj(CONFIG_PATH);
       if (!config.engine) config.engine = {};
       if (!config.agents) config.agents = {};
       shared.pruneDefaultClaudeConfig(config);
@@ -13298,7 +13305,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           // (Round-2 review finding #3.)
           const cfg = queries.getConfig() || {};
           const scheds = cfg.schedules || [];
-          const runs = shared.safeJson(path.join(ENGINE_DIR, 'schedule-runs.json')) || {};
+          const runs = shared.safeJsonObj(path.join(ENGINE_DIR, 'schedule-runs.json'));
           return scheds.map(s => {
             const runEntry = runs[s.id];
             const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
@@ -13507,7 +13514,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // KB pin state (server-side so CC can pin items)
     { method: 'GET', path: '/api/kb-pins', desc: 'Get pinned KB item keys', handler: async (req, res) => {
-      const pins = shared.safeJson(KB_PINS_PATH) || [];
+      const pins = shared.safeJsonArr(KB_PINS_PATH);
       return jsonReply(res, 200, { pins });
     }},
     { method: 'POST', path: '/api/kb-pins', desc: 'Set pinned KB item keys', params: 'pins[]', handler: async (req, res) => {

package/docs/auto-discovery.md

@@ -12,6 +12,7 @@ The engine runs a tick every 10 seconds (configurable via `config.json` → `eng
 tick()
   1.  checkTimeouts()            Enforce runtime limits and stale-orphan cleanup
   1a. checkSteering()            Drain steering messages queued by the dashboard
+  1a2 checkSpawnPhaseStalls()    Watchdog for agents stuck before their first heartbeat
   1b. checkIdleThreshold()       Notify on excessive agent idleness
   1c. meetingTimeouts()          Advance round-based meetings whose timer fired
   2.  consolidateInbox()         Merge learnings into notes.md (Haiku-powered)
@@ -31,6 +32,8 @@ tick()
   3a. pruneStalePrDispatches()   Clear pending PR dispatches whose underlying PRs no longer warrant action
   3.  discoverWork()             Scan ALL linked projects for new tasks
   4.  updateSnapshot()           Write identity/now.md
+  4a. memoryBaseline()           Sample RSS/heap/GC every memoryBaselineEveryTicks ticks (default 6 ≈ 60s)
+  4b. heapSnapshotRequest()      Serve a pending guard-token heap-snapshot request, if any
   5.  dispatch                   Spawn agents for pending items (up to maxConcurrent)
 ```
 

package/docs/design-state-storage.md

@@ -2,7 +2,7 @@
 
 > Author: Rebecca (Architect) | Date: 2026-04-07 | Status: **Accepted — implementation in progress**
 
-> **Implementation status (as of 2026-06):** The `node:sqlite` recommendation in §3 has been adopted ahead of schedule. Phases 0–10 have shipped (events, dispatches, work_items, pull_requests, logs, metrics, watches, schedule_runs + pipeline_runs + managed_processes + worktree_pool, qa_runs + qa_sessions, pr_links, cooldowns + pending_rebases + cc_sessions + doc_sessions, and steering_deliveries (Phases 0–9); plans + prds + prd_items + prd_verify_prs (Phase 10, migration `015-plans-prds.js`) — see `CHANGELOG.md` and `engine/db/migrations/`). The SQLite schema lives under `engine/db/migrations/` and the singleton opens `engine/state.db` in WAL mode. Phase 8 added the first opt-out toggle for the JSON sidecars (`engine.qaDualWriteJson`, default true). Phase 9.4 went further and deleted the silent SQL-unavailable JSON fallbacks in the engine — SQL is now the only reader/writer for everything migrated; the JSON mirror layer is dual-written as a passive mirror and slated for deletion in Phase 9.5. Phase 10 dual-writes PRD state to SQL (`engine/prd-store.js`) and flips reads to SQL when the `prdReadsFromSql` feature flag is ON (default ON — reversible). The "Phase 2: estimated Node 26 LTS" timeline in §3 is now historical context; treat sections 1–3 as design rationale rather than a forward plan.
+> **Implementation status (as of 2026-06):** The `node:sqlite` recommendation in §3 has been adopted ahead of schedule. Phases 0–10 have shipped (events, dispatches, work_items, pull_requests, logs, metrics, watches, schedule_runs + pipeline_runs + managed_processes + worktree_pool, qa_runs + qa_sessions, pr_links, cooldowns + pending_rebases + cc_sessions + doc_sessions, and steering_deliveries (Phases 0–9); plans + prds + prd_items + prd_verify_prs (Phase 10, migration `015-plans-prds.js`) — see `CHANGELOG.md` and `engine/db/migrations/`). The SQLite schema lives under `engine/db/migrations/` and the singleton opens `engine/state.db` in WAL mode. Phase 8 added the first opt-out toggle for the JSON sidecars (`engine.qaDualWriteJson`, default true). Phase 9.4 went further and deleted the silent SQL-unavailable JSON fallbacks in the engine — SQL is now the only reader/writer for everything migrated; the JSON mirror layer is dual-written as a passive mirror and slated for deletion in Phase 9.5. Phase 10 dual-writes PRD state to SQL (`engine/prd-store.js`); the `prdReadsFromSql` read-flip flag was removed after soaking (default had been ON since 0.1.2090) — SQL is now the unconditional PRD read path in `engine/queries.js`, with SQL errors propagating instead of silently falling back to a disk scan. Phase 10 step 4.3 added a second, still-flagged toggle, `prdJoinFromFk`: it resolves the dashboard WI↔PRD-item join via the SQL FK (`work_items.prd_item_id` → `prd_items.id`) instead of the legacy feature-id string match, with a fallback to the string match when the flag is OFF or the FK is unstamped/NULL (default ON, reversible, expires 2026-12-01). The "Phase 2: estimated Node 26 LTS" timeline in §3 is now historical context; treat sections 1–3 as design rationale rather than a forward plan.
 
 ## Executive Summary
 

package/docs/pr-review-fix-loop.md

@@ -81,6 +81,10 @@ A paused cause **suppresses further auto-dispatch for that cause** until cleared
 
 The exported `recordPrNoOpFixAttempt` / `clearPrNoOpFixAttempt` / `sweepStalePrNoOpFixes` helpers in `engine/lifecycle.js` are the only sanctioned entry points. The dispatch evaluator gates re-dispatch on `shared.isPrNoOpFixCausePaused(pr, cause)` (which re-validates the fingerprint per call), the dashboard chip surface uses `shared.getPrPausedCauses(pr)` (same gate), and the `pollPrStatus` callback in `engine/ado.js` + `engine/github.js` calls `sweepStalePrNoOpFixes(pr)` each tick to GC records whose fingerprint no longer matches the live PR.
 
+#### E2. Build-fix-ineffective tracker (`pr._buildFixIneffective`, issue #639)
+
+A "branch unchanged" no-op report for a `BUILD_FAILURE`-cause fix used to be conflated with the generic `_noOpFixes[BUILD_FAILURE]` counter even when the build was still genuinely red on the unchanged head — silently masking a stuck failure as "handled". `checkBuildStillFailingLive()` re-polls host-specific live CI (`checkLiveBuildAndConflict` in `engine/github.js` / `engine/ado.js`) right after `detectPrFixBranchChange()` reports no branch change for a build-failure fix. If the build is still failing, `recordBuildFixIneffective()` tracks a **separate**, `headSha`-keyed counter (`pr._buildFixIneffective`) instead of bumping `_noOpFixes[BUILD_FAILURE]`, pausing after `prNoOpFixPauseAttempts` on the same head and writing a distinct `build-fix-ineffective-<pr>` inbox alert; `shared.isBuildFixIneffectivePaused()` re-validates the stored `headSha` against the live PR before honoring the pause (same fingerprint-revalidation pattern as `isPrNoOpFixCausePaused`), and `engine.js` wires `isBuildFixIneffectiveSuppressed()` into the `BUILD_FAILURE` dispatch gate alongside the existing no-op check. A real branch-changing fix clears the stale record. The dashboard PR list (`dashboard/js/render-prs.js`) renders a separate, non-interactive "infra issue suspected" chip for a paused `_buildFixIneffective` record (tooltip shows `reason`/`count`/`headSha`/`liveBuildStatus`) alongside the existing `_pausedCauses` chips.
+
 ## 5. Fix completes
 
 - `updatePrAfterFix()` (lifecycle.js) sets `reviewStatus = 'waiting'` + `fixedAt = ts()`
@@ -163,3 +167,4 @@ The exported `recordPrNoOpFixAttempt` / `clearPrNoOpFixAttempt` / `sweepStalePrN
 - Builds use the merge commit hash as `sourceVersion`, not the source branch commit — compare against `lastMergeCommit.commitId`
 - `partiallySucceeded` counts as passing (warnings, not failures)
 - A stale but passing build is still valid — don't re-trigger builds that already passed
+- ADO never auto-clears a reviewer's numeric vote when new commits land, so a hard-reject `-10` vote stays live forever unless the reviewer explicitly re-votes. Both `pollPrStatus()` and the pre-dispatch `checkLiveReviewStatus()` treat a `-10` as **stale/superseded** (resolving to `waiting` instead of `changes-requested`) via `isStaleAdoRejectVote()` once a fix has completed after the vote's last review (`fixedAt > lastReviewedAt`) with no push since (`lastPushedAt <= fixedAt`) — otherwise the auto re-review-after-fix flow can never fire for that PR (issue #633).

package/docs/team-memory.md

@@ -48,6 +48,8 @@ Filenames follow the `YYYY-MM-DD-<agent>-<slug>.md` convention so chronological
 
 Agents read `knowledge/` directly with grep/glob/view. They **do not** write to it. See [Sweep-write-only constraint](#sweep-write-only-constraint) below.
 
+**Full-body copies vs. condensed stubs.** When `engine/consolidation.js#classifyToKnowledgeBase` promotes an inbox note into `knowledge/`, it only copies the full body when the note is routed to `conventions/` or its content carries a reusable-knowledge section header (`## Patterns`, `## Conventions`, `## Gotchas`, `## Dependencies`, `## Best Practices`, etc.). Narrowly-scoped, one-off notes (a single PR review, a task status update) instead get a deterministic, LLM-free condensed stub — title + first-paragraph abstract + a link back to the archived inbox note — to avoid duplicating disk usage and prompt-token cost on every future dispatch. Every promoted entry's frontmatter gains a `reusable: true|false` field so this can be audited (issue #604).
+
 ### 3. `notes.md` — consolidated team notes
 
 `notes.md` is the rolling team notebook. The consolidation sweep periodically merges high-signal findings from the inbox into dated `### YYYY-MM-DD` sections at the top of `notes.md`, with links back to the underlying KB entries.

package/docs/watches.md

@@ -169,7 +169,7 @@ I/O happens **outside the lock**: notifications via `writeToInbox`, follow-up ac
 | `dispatch-work-item`   | Append a new WI to the project (or central) `work-items.json` with `createdBy: "watch:<id>"`  |
 | `run-skill`            | Wrapper around `dispatch-work-item` that asks the agent to run a specific `.claude` skill     |
 | `webhook`              | `http`/`https` request to an arbitrary URL (10s safety timeout, JSON or string body)          |
-| `minions-api`          | Loopback call to the in-process dashboard at `http://127.0.0.1:${MINIONS_PORT \|\| 7331}` — `endpoint` must start with `/api/`; sets `X-Minions-Internal: 1`; returns `{ok, status, summary, response}` for chain-step templating |
+| `minions-api`          | Loopback call to the in-process dashboard at `http://127.0.0.1:${shared.readDashboardPortFile(MINIONS_DIR)?.port \|\| 7331}` (reads the bound-port beacon file, not the `MINIONS_PORT` env, so it still resolves after an `EADDRINUSE` port scan) — `endpoint` must start with `/api/`; sets `X-Minions-Internal: 1`; returns `{ok, status, summary, response}` for chain-step templating |
 | `cancel-work-item`     | Flip a WI to `WI_STATUS.CANCELLED` across all known work-items files                          |
 | `trigger-pipeline`     | Start a new pipeline run (skipped if the pipeline already has an active run)                  |
 | `archive-plan`         | Set PRD `status="archived"` + `archivedAt`                                                    |

package/engine/cleanup.js

@@ -736,13 +736,26 @@ async function runCleanup(config, verbose = false) {
         // claims it.
         if (shared.isWorktreePathLive(full)) {
           log('info', `Cleanup: skip orphan worktree dir ${full} — live dispatch claims it`);
-          shared._writeWorktreeSkipLiveInboxNote(full, 'cleanup.orphanWorktreeDirSweep');
+          const blockingInfo = shared.getWorktreeBlockingDispatchInfo(full);
+          shared._writeWorktreeSkipLiveInboxNote(full, 'cleanup.orphanWorktreeDirSweep', blockingInfo);
           continue;
         }
+        // W-mr2zu0hb000f20c7 — route through shared.removeWorktree instead of a
+        // raw fs.rmSync so this path gets the same retry-with-backoff (transient
+        // Windows EBUSY/locked-file handling) and real-repo-refusal safety net
+        // that every other worktree removal in this file uses. This dir already
+        // isn't registered in `git worktree list`, so the primary
+        // `git worktree remove --force` inside removeWorktree is expected to
+        // fail and fall through to its fs.rmSync + retry logic — that's fine,
+        // the safety checks (ownership marker already verified above; real-repo
+        // and live-dispatch refusals re-checked inside removeWorktree) still apply.
         try {
-          fs.rmSync(full, { recursive: true, force: true });
-          cleaned.orphanWorktreeDirs++;
-          log('info', `Cleanup: removed orphan worktree dir ${full} (not registered in git)`);
+          if (shared.removeWorktree(full, root, wtRoot)) {
+            cleaned.orphanWorktreeDirs++;
+            log('info', `Cleanup: removed orphan worktree dir ${full} (not registered in git)`);
+          } else {
+            log('warn', `orphan worktree dir ${full}: removeWorktree declined (see prior log line for reason)`);
+          }
         } catch (err) {
           log('warn', `orphan worktree dir ${full}: ${err.message}`);
         }

package/engine/lifecycle.js

@@ -2707,10 +2707,27 @@ function recordBuildFixIneffective(target, dispatchItem, config, liveBuildStatus
   const paused = count >= pauseAfter;
   const flippedToPaused = paused && !(sameHead && prior?.paused === true);
   const now = ts();
-  const reason = `build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${String(headSha || '').slice(0, 12)}`;
+  // Human-teammate follow-up on #639/#640: once the automation is actually
+  // PAUSED here (multiple ineffective attempts against the same unchanged
+  // head, with live CI re-confirmed still red), a generic "no-op" label
+  // undersells what's going on — repeated fixes aren't landing, which is a
+  // much stronger signal of an environment/CI infra problem than a code
+  // issue. `label` is the short, canonical diagnostic tag; it stays `null`
+  // while attempts are still accumulating (not yet paused) so callers can
+  // tell "still trying" apart from "give up on code fixes, check infra".
+  // Surfaced on every consumer of this record: the PR record field itself
+  // (`label`, plus `reason` below), the pause inbox alert, and the dashboard
+  // chip (dashboard/js/render-prs.js already renders "infra issue suspected"
+  // for `paused === true` — kept in sync with this same wording here).
+  const label = paused ? 'infra issue suspected' : null;
+  const shortHead = String(headSha || '').slice(0, 12);
+  const reason = paused
+    ? `infra issue suspected — build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${shortHead} after ${count} consecutive ineffective attempt(s)`
+    : `build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${shortHead}`;
   target._buildFixIneffective = {
     count,
     paused,
+    label,
     headSha,
     liveBuildStatus: liveBuildStatus || 'failing',
     firstAt: sameHead ? (prior.firstAt || now) : now,
@@ -2721,13 +2738,14 @@ function recordBuildFixIneffective(target, dispatchItem, config, liveBuildStatus
   if (flippedToPaused) {
     try {
       const prNumber = target.prNumber || shared.getPrNumber(target) || target.id || 'unknown';
-      const noteBody = `# Build fix ineffective: ${target.id || prNumber}\n\n`
+      const noteBody = `# Build fix ineffective — infra issue suspected: ${target.id || prNumber}\n\n`
         + `**PR:** ${target.url || target.id || '(unknown)'}\n`
         + `**Branch:** ${target.branch || '(unknown)'}\n`
         + `**Head:** ${String(headSha || '').slice(0, 40) || '(unknown)'}\n`
         + `**Attempt:** ${count}/${pauseAfter} (paused)\n\n`
         + `A build-failure fix dispatch reported no branch change, but re-polling live CI showed the build is STILL \`${liveBuildStatus || 'failing'}\` against that exact commit. `
         + `The engine reached \`engine.prNoOpFixPauseAttempts\` (${pauseAfter}) consecutive ineffective-fix attempts against the same head and has paused build-failure automation for this PR.\n\n`
+        + `**Infra issue suspected:** ${count} fix dispatches in a row landed on this head without moving it, and CI is still red. This pattern usually means the failure isn't fixable by another automated code-fix pass (flaky infra, an external outage, a broken pipeline/runner, a protected-branch or permissions issue, etc.) rather than a code bug — investigate the CI environment before re-dispatching.\n\n`
         + `**Recovery options:**\n`
         + `1. A new head SHA on this PR auto-clears the pause (a real fix attempt landed).\n`
         + `2. Manually inspect the live CI logs — the automated fixes may be addressing the wrong failure, or the failure may not be fixable by re-pushing (flaky infra, protected branch, etc).\n`;
@@ -3103,7 +3121,7 @@ function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId =
       if (cause === shared.PR_FIX_CAUSE.BUILD_FAILURE && options.buildStillFailing) {
         const record = recordBuildFixIneffective(target, options.dispatchItem, options.config, options.buildStillFailing);
         result = { noOp: true, cause, fixIneffective: true, paused: !!record.paused, count: record.count };
-        log('warn', `Updated ${pr.id} → build-fix reported no branch change, but live CI is still ${options.buildStillFailing} on the same head; recorded fixIneffective attempt ${record.count}${record.paused ? ' (paused)' : ''}`);
+        log('warn', `Updated ${pr.id} → build-fix reported no branch change, but live CI is still ${options.buildStillFailing} on the same head; recorded fixIneffective attempt ${record.count}${record.paused ? ' (paused — infra issue suspected)' : ''}`);
         return prs;
       }
       const record = recordPrNoOpFixAttempt(target, cause, source, options.dispatchItem, options.branchChange, options.config, options.noopReason);

package/engine/queries.js

@@ -11,7 +11,7 @@ const os = require('os');
 const shared = require('./shared');
 const steering = require('./steering');
 
-const { safeRead, safeReadDir, safeJson, safeWrite, getProjects, mutateJsonFileLocked,
+const { safeRead, safeReadDir, safeJson, safeJsonObj, safeWrite, getProjects, mutateJsonFileLocked,
   projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS } = shared;
 
@@ -221,7 +221,7 @@ function migrateDeprecatedConfigPollKeysOnce() {
 
 function getConfig() {
   migrateDeprecatedConfigPollKeysOnce();
-  return safeJson(CONFIG_PATH) || {};
+  return safeJsonObj(CONFIG_PATH);
 }
 
 function getControl() {

package/engine/shared.js

@@ -8776,11 +8776,60 @@ function isWorktreePathLive(worktreePath, opts = {}) {
   return false;
 }
 
+// P-1d6b1aa7 — separate, best-effort lookup of the specific dispatch row
+// that is blocking a wipe, so callers can fold self-diagnosing detail (id,
+// status, age-in-non-terminal-state) into the skip-live inbox note instead
+// of forcing a human to run a follow-up SQL query against
+// engine/state.db every time W-mq5rwwss000f30a7 recurs. Deliberately kept
+// separate from isWorktreePathLive so that helper's fail-open boolean
+// contract (and its existing callers/tests) are untouched — this is an
+// additional, purely-diagnostic query run only after the guard has already
+// fired. Any failure here (SQL unavailable, no matching row, etc.) resolves
+// to `null` and the note falls back to an "unavailable" label; it must
+// never throw or change wipe/skip behavior.
+function getWorktreeBlockingDispatchInfo(worktreePath, opts = {}) {
+  try {
+    const target = _normalizeWorktreePath(worktreePath);
+    if (!target) return null;
+    const excludeDispatchId = opts.excludeDispatchId ? String(opts.excludeDispatchId) : null;
+    let db = opts.db || null;
+    if (!db) {
+      try { db = require('./db').getDb(); }
+      catch { return null; }
+    }
+    if (!db) return null;
+    const rows = db.prepare(`
+      SELECT id, status, updated_at,
+             json_extract(data, '$.worktreePath') AS top_wt,
+             json_extract(data, '$.meta.worktreePath') AS meta_wt
+      FROM dispatches
+      WHERE status IN ('pending', 'active')
+    `).all();
+    for (const row of rows || []) {
+      if (excludeDispatchId && String(row.id) === excludeDispatchId) continue;
+      const topMatch = row.top_wt && _normalizeWorktreePath(row.top_wt) === target;
+      const metaMatch = row.meta_wt && _normalizeWorktreePath(row.meta_wt) === target;
+      if (topMatch || metaMatch) {
+        const updatedAt = Number(row.updated_at) || 0;
+        const ageMs = updatedAt > 0 ? Math.max(0, Date.now() - updatedAt) : null;
+        return { id: row.id, status: row.status, ageMs };
+      }
+    }
+    return null;
+  } catch {
+    return null; // best-effort diagnostics only — never throw
+  }
+}
+
 // Drop a deduped inbox note when a wipe site skips due to the live guard so
 // operators can see when the guard fires. Filename is keyed on basename +
 // UTC date — a single skip per worktree per day produces one note; further
-// skips that day silently no-op.
-function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
+// skips that day silently no-op. `blockingInfo` (optional, shape
+// `{ id, status, ageMs }` from getWorktreeBlockingDispatchInfo) folds the
+// blocking dispatch's diagnostics into the note body so it is
+// self-diagnosing; when unavailable (no matching row, SQL unreachable,
+// etc.) the note says so explicitly instead of requiring a follow-up query.
+function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag, blockingInfo) {
   try {
     const base = path.basename(String(worktreePath || '').replace(/[\\/]+$/g, '')) || 'unknown';
     const safeBase = base.replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 80);
@@ -8790,6 +8839,13 @@ function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
     try { fs.mkdirSync(inboxDir, { recursive: true }); } catch { /* exists */ }
     const fpath = path.join(inboxDir, fname);
     if (fs.existsSync(fpath)) return; // deduped
+    const diagnosticsLines = (blockingInfo && blockingInfo.id)
+      ? [
+        `- blocking dispatch id: ${blockingInfo.id}`,
+        `- blocking dispatch status: ${blockingInfo.status || 'unknown'}`,
+        `- blocking dispatch age: ${blockingInfo.ageMs != null ? `${Math.round(blockingInfo.ageMs / 1000)}s since last update` : 'unavailable'}`,
+      ]
+      : ['- blocking dispatch diagnostics: unavailable (no matching row found, or SQL was unreachable)'];
     const body = [
       '---',
       `id: NOTE-${crypto.randomBytes(8).toString('hex')}`,
@@ -8802,6 +8858,7 @@ function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
       `- caller: ${callerTag || 'unknown'}`,
       `- worktree: ${worktreePath}`,
       `- timestamp: ${new Date().toISOString()}`,
+      ...diagnosticsLines,
       '',
       'A non-terminal dispatch row still claims this worktree. The wipe was skipped to',
       'protect agent state. If this fires repeatedly, inspect engine/state.db dispatches',
@@ -8881,7 +8938,8 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot, opts = {}) {
   const excludeDispatchId = opts && opts.excludeDispatchId ? String(opts.excludeDispatchId) : null;
   if (isWorktreePathLive(resolved, excludeDispatchId ? { excludeDispatchId } : undefined)) {
     log('warn', `removeWorktree: skip — live dispatch in ${wtPath}`);
-    _writeWorktreeSkipLiveInboxNote(wtPath, 'shared.removeWorktree');
+    const blockingInfo = getWorktreeBlockingDispatchInfo(resolved, excludeDispatchId ? { excludeDispatchId } : undefined);
+    _writeWorktreeSkipLiveInboxNote(wtPath, 'shared.removeWorktree', blockingInfo);
     return false;
   }
   _pruneRemoveWorktreeFailures();
@@ -9496,6 +9554,7 @@ module.exports = {
   listProcessReachable,
   removeWorktree,
   isWorktreePathLive,
+  getWorktreeBlockingDispatchInfo,
   WORKTREE_OWNER_MARKER,
   writeWorktreeOwnerMarker,
   hasWorktreeOwnerMarker,

package/engine.js

@@ -1697,7 +1697,8 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
   // agent's git child processes either.
   if (shared.isWorktreePathLive(worktreePath)) {
     log('warn', `_quarantineDirtyWorktree: skip — live dispatch in ${worktreePath}`);
-    shared._writeWorktreeSkipLiveInboxNote(worktreePath, '_quarantineDirtyWorktree');
+    const blockingInfo = shared.getWorktreeBlockingDispatchInfo(worktreePath);
+    shared._writeWorktreeSkipLiveInboxNote(worktreePath, '_quarantineDirtyWorktree', blockingInfo);
     return { quarantinedPath: null, backupRef: null, skipped: true };
   }
 

package/package.json

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