@yemi33/minions 0.1.2392 → 0.1.2394

package/dashboard/js/qa.js

@@ -554,6 +554,8 @@ const QA_SESSION_TERMINAL_STATES = new Set(['done', 'failed', 'killed']);
 let _qaSessionsPollInterval = null;
 let _qaSessionsCache = [];
 let _qaRunnersCache = [];
+// Polling replaces the cards every three seconds, so disclosure state lives outside the DOM.
+const _qaExpandedFlows = new Set();
 
 function _stopQaSessionsPoll() {
   if (_qaSessionsPollInterval) {
@@ -706,6 +708,17 @@ function _qaAfterSessionsRender() {
   if (allTerminal) _stopQaSessionsPoll();
 }
 
+function qaSessionFlowsToggle(details) {
+  if (!details) return;
+  const isOpen = details.open;
+  const summary = details.querySelector('.qa-session-flows-summary');
+  if (summary) summary.setAttribute('aria-expanded', isOpen ? 'true' : 'false');
+  const id = details.getAttribute('data-session-id');
+  if (!id) return;
+  if (isOpen) _qaExpandedFlows.add(id);
+  else _qaExpandedFlows.delete(id);
+}
+
 function _qaRenderSessionCard(s) {
   const id = s && s.id || '';
   const state = (s && s.state) || 'unknown';
@@ -749,7 +762,19 @@ function _qaRenderSessionCard(s) {
 
   let body = '';
   if (flowsShort) {
-    body += '<div class="qa-session-flows"><strong>Flows:</strong> ' + escHtml(flowsShort) + '</div>';
+    const flowsOpen = _qaExpandedFlows.has(id);
+    body += '<details class="qa-session-flows"' + (flowsOpen ? ' open' : '') +
+      ' data-session-id="' + escHtml(id) + '" ontoggle="qaSessionFlowsToggle(this)">' +
+        '<summary class="qa-session-flows-summary" aria-expanded="' + (flowsOpen ? 'true' : 'false') + '">' +
+          '<strong class="qa-session-flows-label">Flows:</strong>' +
+          '<span class="qa-session-flows-preview">' + escHtml(flowsShort) + '</span>' +
+          '<span class="qa-session-flows-affordance">' +
+            '<span class="qa-session-flows-expand-label">Show full prompt</span>' +
+            '<span class="qa-session-flows-collapse-label">Hide full prompt</span>' +
+          '</span>' +
+        '</summary>' +
+        '<div class="qa-session-flows-full">' + escHtml(flowsRaw) + '</div>' +
+      '</details>';
   }
   if (state === 'failed' && (failureClass || error)) {
     body += '<div class="qa-session-error"><strong>' + escHtml(failureClass || 'failed') + ':</strong> ' + escHtml(error || summary || 'no details') + '</div>';

package/dashboard/styles.css

@@ -1597,6 +1597,31 @@
     background: var(--surface); padding: var(--space-3);
     border-radius: var(--radius-sm); border: 1px solid var(--border);
   }
+  .qa-session-flows-summary {
+    display: grid; grid-template-columns: auto minmax(0, 1fr) auto;
+    align-items: start; gap: var(--space-2); cursor: pointer; list-style: none;
+  }
+  .qa-session-flows-summary::-webkit-details-marker { display: none; }
+  .qa-session-flows-summary::marker { content: ''; }
+  .qa-session-flows-summary:focus-visible {
+    outline: 2px solid var(--blue); outline-offset: 3px;
+    border-radius: var(--radius-sm);
+  }
+  .qa-session-flows-preview,
+  .qa-session-flows-full { overflow-wrap: anywhere; }
+  .qa-session-flows-affordance {
+    color: var(--blue); font-size: var(--text-xs); white-space: nowrap;
+  }
+  .qa-session-flows-affordance::before { content: '+ '; }
+  .qa-session-flows-collapse-label { display: none; }
+  .qa-session-flows[open] .qa-session-flows-preview { display: none; }
+  .qa-session-flows[open] .qa-session-flows-affordance::before { content: '- '; }
+  .qa-session-flows[open] .qa-session-flows-expand-label { display: none; }
+  .qa-session-flows[open] .qa-session-flows-collapse-label { display: inline; }
+  .qa-session-flows-full {
+    margin-top: var(--space-3); padding-top: var(--space-3);
+    border-top: 1px solid var(--border); white-space: pre-wrap;
+  }
   .qa-session-error {
     font-size: var(--text-base); color: var(--red);
     background: rgba(248, 81, 73, 0.08); padding: var(--space-3);

package/docs/pr-auto-fix-dispatch.md

@@ -51,7 +51,7 @@ Independent of the master kill-switches, each PR tracks repeated no-op fix outco
 2. Click the red chip → `POST /api/pull-requests/clear-paused-cause` with `{ prId, cause }`.
 3. Direct API call to the same endpoint.
 
-This per-PR per-cause pause is unrelated to `autoFixPaused`. Cause keys are validated against `shared.PR_FIX_CAUSE` (e.g. `BUILD_FAILURE`, `REVIEW_FEEDBACK`, `HUMAN_FEEDBACK`, `MERGE_CONFLICT`, `PR_FIX`). Full mechanics in [`docs/pr-review-fix-loop.md`](pr-review-fix-loop.md) §4E.
+This per-PR per-cause pause is unrelated to `autoFixPaused`. Cause values are validated against `Object.values(shared.PR_FIX_CAUSE)` (`human-feedback`, `review-feedback`, `build-failure`, `merge-conflict`, or `pr-fix`). Full mechanics in [`docs/pr-review-fix-loop.md`](pr-review-fix-loop.md) §4E.
 
 ## Key files
 

package/engine/lifecycle.js

@@ -2629,7 +2629,7 @@ function normalizePrFixBranchName(branch) {
 }
 
 function getPrFixBaselineHead(pr) {
-  return String(pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
+  return String(pr?.headRefOid || pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
 }
 
 function findPrFixWorktree(meta, project, config) {
@@ -5962,7 +5962,14 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   }
   if (effectiveSuccess && !skipDoneStatus) {
     // Coding WIs and direct PR-sourced fix dispatches share this follow-up path.
-    try { autoDispatchLiveValidationWi(meta, config, dispatchItem); } catch (err) { log('warn', `autoDispatchLiveValidationWi: ${err.message}`); }
+    const verifiedHeadSha = prFixBranchChange?.evidence === 'remote-head'
+      ? prFixBranchChange.afterHead
+      : '';
+    try {
+      autoDispatchLiveValidationWi(meta, config, dispatchItem, { verifiedHeadSha });
+    } catch (err) {
+      log('warn', `autoDispatchLiveValidationWi: ${err.message}`);
+    }
   }
   // Failure retry is handled by completeDispatch in dispatch.js — not duplicated here.
   // Only clear _decomposing flag on failure so decompose items don't get permanently stuck.
@@ -6943,9 +6950,9 @@ function collapseAllDuplicatePrRecords(config) {
 // always a canonical `test` WI with the PR-focused `build-and-test` playbook;
 // liveValidation.type controls routing, not the semantic type of the task.
 //
-// Deduplicates per codingWiId: any non-terminal WI with
-// meta.liveValidationFor === codingWiId blocks a second dispatch, so only one
-// validation task is ever in flight per coding completion.
+// Deduplicates both per codingWiId and per canonical PR source revision. This
+// keeps concurrent/repeated fixes for one unchanged PR head from queueing
+// duplicate validations while allowing a fresh validation after the head moves.
 //
 // W-mr9u39az000db5c2 — guard against a self-referential recursive cascade.
 // When liveValidation.type overlaps with a coding WI's own type set (e.g.
@@ -6970,7 +6977,7 @@ const ELIGIBLE_LIVE_VALIDATION_TYPES = new Set([
   WORK_TYPE.BUILD_FIX_COMPLEX,
 ]);
 
-function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
+function autoDispatchLiveValidationWi(meta, config, dispatchItem = null, options = {}) {
   const item = meta?.item || null;
   const sourceType = item?.type || dispatchItem?.type || null;
   const sourceKey = item?.id || dispatchItem?.id || null;
@@ -7033,27 +7040,48 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
   const prTarget = prUrl || (prId != null ? String(prId) : null);
   if (!prTarget) return;
 
+  const prIdentityRef = {
+    id: prId != null ? String(prId) : prTarget,
+    url: prUrl || '',
+  };
+  let currentPr = typeof prRef === 'object' ? prRef : null;
+  try {
+    currentPr = shared.findPrRecord(shared.readPullRequests(project), prIdentityRef, project) || currentPr;
+  } catch (err) {
+    log('warn', `liveValidation: could not resolve tracked PR ${prTarget}: ${err.message}`);
+  }
+  const liveValidationPrId = shared.getPrIdentityKey(currentPr || prIdentityRef, project);
+  if (!liveValidationPrId) return;
+  const liveValidationHeadSha = String(options?.verifiedHeadSha || '').trim()
+    || getPrFixBaselineHead(currentPr);
+
   const codingWiId = sourceKey;
   const wiScope = item ? resolveWorkItemScope(meta) : projectName;
   if (!wiScope) return;
 
   try {
-    mutateWorkItems(wiScope, items => {
+    mutateWorkItems(wiScope, (items, comparisonItems) => {
       if (!Array.isArray(items)) return items;
 
-      // Dedup: only one validation WI in flight per coding WI. Any non-terminal
-      // WI already tracking this coding WI (meta.liveValidationFor) blocks a
-      // second dispatch, regardless of its validation type. (Back-compat: WIs
-      // created before meta.liveValidationType existed are matched too, since
-      // we key solely on liveValidationFor.)
-      const existing = items.find(i =>
-        i &&
-        i.meta &&
-        i.meta.liveValidationFor === codingWiId &&
-        !PLAN_TERMINAL_STATUSES.has(i.status)
-      );
+      // Keep the source-WI guard and revision guard in this same mutation as the
+      // insert, and compare both supported scopes while the SQLite write
+      // transaction is held. Legacy live-validation WIs predate the persisted
+      // revision fields, so derive their identity from structured PR fields and
+      // conservatively treat a missing head as matching until terminal.
+      const existing = comparisonItems.find(i => {
+        if (!i?.meta?.liveValidationFor || PLAN_TERMINAL_STATUSES.has(i.status)) return false;
+        if (i.meta.liveValidationFor === codingWiId) return true;
+
+        const existingPrRef = i.meta.liveValidationPrId || shared.extractStructuredWorkItemPrRef(i);
+        if (!existingPrRef) return false;
+        const existingPrId = shared.getPrIdentityKey(existingPrRef, project);
+        if (existingPrId !== liveValidationPrId) return false;
+
+        const existingHeadSha = String(i.meta.liveValidationHeadSha || '').trim();
+        return !existingHeadSha || !liveValidationHeadSha || existingHeadSha === liveValidationHeadSha;
+      });
       if (existing) {
-        log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} already exists for ${codingWiId}`);
+        log('info', `liveValidation: dedup — non-terminal validation WI ${existing.id} blocks another validation for ${codingWiId} (${liveValidationPrId}@${liveValidationHeadSha || 'unknown'})`);
         return items;
       }
 
@@ -7081,6 +7109,8 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
         meta: {
           liveValidationFor: codingWiId,
           liveValidationType: validationType,
+          liveValidationPrId,
+          ...(liveValidationHeadSha ? { liveValidationHeadSha } : {}),
           playbook: 'build-and-test',
           ...(dispatchItem?.id ? { sourceDispatchId: dispatchItem.id } : {}),
         },
@@ -7093,7 +7123,7 @@ function autoDispatchLiveValidationWi(meta, config, dispatchItem = null) {
       items.push(validationWi);
       log('info', `liveValidation: auto-dispatched validation WI ${validationWi.id} (type=${validationType}) for coding WI ${codingWiId}`);
       return items;
-    });
+    }, { readScopes: ['central', projectName] });
   } catch (err) {
     log('warn', `autoDispatchLiveValidationWi for ${codingWiId}: ${err.message}`);
   }

package/engine/shared.js

@@ -7702,12 +7702,17 @@ function readWorkItems(source = null) {
   return require('./work-items-store').readWorkItemsForScope(stateScope(source));
 }
 
-function mutateWorkItems(source, mutator) {
+function mutateWorkItems(source, mutator, opts = {}) {
   const store = require('./work-items-store');
-  const { wrote, result } = store.applyWorkItemsMutation(stateScope(source), (items) => {
+  const scope = stateScope(source);
+  const normalizedOpts = { ...opts };
+  if (Array.isArray(opts.readScopes)) {
+    normalizedOpts.readScopes = opts.readScopes.map(stateScope);
+  }
+  const { wrote, result } = store.applyWorkItemsMutation(scope, (items, comparisonItems) => {
     if (!Array.isArray(items)) items = [];
-    return mutator(items) || items;
-  });
+    return mutator(items, comparisonItems) || items;
+  }, normalizedOpts);
   if (wrote) {
     try { require('./db-events').emitStateEvent('work_items'); } catch { /* optional */ }
     try { require('./queries').invalidateWorkItemsCache(); } catch { /* queries not loaded */ }

package/engine/work-items-store.js

@@ -128,13 +128,14 @@ function _applyWorkItemsDiff(db, diff) {
 
 // Apply a mutation to the work-items array for a given scope. Wrapped in
 // a single transaction so the diff and apply can't race against a
-// concurrent reader/writer.
+// concurrent reader/writer. Optional readScopes are exposed to the mutator
+// as a combined comparison set; only target-scope mutations are persisted.
 //
 // Returns { wrote, result }:
 //   wrote  — true iff at least one INSERT/UPDATE/DELETE landed
 //   result — the post-mutation array (legacy return shape of
 //            mutateJsonFileLocked)
-function applyWorkItemsMutation(scope, mutator, opts) {
+function applyWorkItemsMutation(scope, mutator, opts = {}) {
   const { getDb, withTransaction } = require('./db');
   const db = getDb();
 
@@ -144,8 +145,14 @@ function applyWorkItemsMutation(scope, mutator, opts) {
     // added by readAllWorkItems only and would round-trip as garbage into
     // the data column otherwise.
     for (const wi of before) { if (wi && wi._source) delete wi._source; }
+    const comparisonItems = [...before];
+    const readScopes = Array.isArray(opts.readScopes) ? opts.readScopes : [];
+    for (const readScope of new Set(readScopes)) {
+      if (readScope === scope) continue;
+      comparisonItems.push(...readWorkItemsForScope(readScope));
+    }
     const beforeSnapshot = JSON.parse(JSON.stringify(before));
-    const next = mutator(before);
+    const next = mutator(before, comparisonItems);
     const after = (next === undefined || next === null)
       ? before
       : (Array.isArray(next) ? next : before);

package/package.json

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

package/playbooks/plan-to-prd.md

@@ -135,7 +135,7 @@ Rules for items:
       { "id": "P-bbb2", "name": "UI client",    "project": "web-dashboard",   ... }
     ]
     ```
-    The engine routes each item to that project's SQL work-item scope. The verify task at plan completion picks the project with the most completed items and runs cross-repo verification from there. See the **Cross-repo plans** section below for the full output contract when `{{target_projects}}` is set.
+    The engine routes each item to that project's SQL work-item scope. At plan completion, the engine creates one project-scoped verify work item per touched project (each project with an active PR linked to a completed plan item). If no linked PRs surface, it falls back to one verify work item on the primary project. See the **Cross-repo plans** section below for the full output contract when `{{target_projects}}` is set.
 - `depends_on` lists IDs of items that must be done first
 - Keep descriptions actionable — name the files, functions, patterns, or integration points the implementing agent should touch whenever the plan makes them clear
 - Include `acceptance_criteria` so reviewers know when it's done
@@ -161,7 +161,7 @@ Apply these rules on top of (and where they conflict, instead of) the single-pro
    - `parallel`: omit `feature_branch` entirely (the engine derives per-item branches as `user/<loginname>/<wi-id>-<slug>` in each project).
    - `shared-branch` (only with explicit justification): use the canonical `user/<loginname>/PL-<short-kebab-slug>` form. The engine will pre-create a matching branch in every project listed in `{{target_projects}}` (P-1c0f5e84) so each item can push to the same branch name in its own repo.
 
-The verify task at plan completion picks the project with the most completed items and runs cross-repo verification from there; items with no PRs (e.g. docs-only changes that landed via direct commit) are still counted via their `done` status.
+At plan completion, the engine creates one verify work item per touched project, where a touched project has at least one active PR linked to a completed plan item. Those project-scoped verify tasks run independently in parallel. If no linked PRs surface (for example, items completed without PR records or legacy state), the fan-out collapses to one verify work item on the primary project — the project with the most completed items — as a fallback.
 
 {{/target_projects}}
 ## Reusing an Existing PRD