@yemi33/minions 0.1.2196 → 0.1.2197

package/dashboard/js/modal-qa.js

@@ -335,6 +335,19 @@ function _qaBuildRawErrorHtml(err) {
     '</details>';
 }
 
+function _qaDocStreamErrorMessage(evt) {
+  if (!evt) return 'Failed';
+  if (typeof evt.error === 'string' && evt.error) return evt.error;
+  if (evt.message) return String(evt.message);
+  if (evt.errorMessage) return String(evt.errorMessage);
+  if (evt.error && typeof evt.error === 'object') {
+    if (evt.error.errorMessage) return String(evt.error.errorMessage);
+    if (evt.error.message) return String(evt.error.message);
+    if (evt.error.stderr) return String(evt.error.stderr);
+  }
+  return 'Failed';
+}
+
 function _qaBuildAssistantHtml(text, opts) {
   const body = opts?.isError ? escHtml(text) : renderMd(text);
   const style = opts?.isError
@@ -713,6 +726,7 @@ async function _processQaMessage(message, selection, opts) {
     const decoder = new TextDecoder();
     let buf = '';
     let terminalEventSeen = false;
+    let pendingStreamErrorEvent = null;
 
     async function _qaHandleStreamEvent(evt) {
       if (!evt || !evt.type) return;
@@ -842,8 +856,8 @@ async function _processQaMessage(message, selection, opts) {
         return;
       }
       if (evt.type === 'error') {
-        _clearQaStreamWatchdog();
-        throw new Error(evt.error || 'Failed');
+        pendingStreamErrorEvent = evt;
+        return;
       }
     }
 
@@ -867,7 +881,11 @@ async function _processQaMessage(message, selection, opts) {
         await _qaHandleStreamEvent(JSON.parse(line.slice(6)));
       }
     }
-    if (!terminalEventSeen) throw new Error('The response stream ended before completion.');
+    if (!terminalEventSeen) {
+      throw new Error(pendingStreamErrorEvent
+        ? _qaDocStreamErrorMessage(pendingStreamErrorEvent)
+        : 'The response stream ended before completion.');
+    }
   } catch (e) {
     clearInterval(qaTimer);
     _clearQaStreamWatchdog();

package/engine/dispatch.js

@@ -12,7 +12,7 @@ const dispatchEvents = require('./dispatch-events');
 
 const { safeJsonArr, mutateWorkItems,
   mutatePullRequests, getProjects, projectPrPath, log, ts, dateStamp,
-  sidecarDispatchPrompt, deleteDispatchPromptSidecar,
+  sidecarDispatchPrompt, deleteDispatchPromptSidecar, DONE_STATUSES,
   WI_STATUS, WORK_TYPE, DISPATCH_RESULT, ENGINE_DEFAULTS, AGENT_STATUS, FAILURE_CLASS, PR_STATUS } = shared;
 const { getConfig, INBOX_DIR } = queries;
 
@@ -426,12 +426,12 @@ function getStalePrDispatchReason(entry, config) {
   //   1. `entry.meta?.source !== 'work-item'` — blocks any non-work-item dispatch
   //      (e.g. legacy `pr`/`pr-human-feedback` discovery paths) from running
   //      against a context-only PR. Auto-discovery in engine.js#discoverFromPrs
-  //      already skips _contextOnly PRs at the source, so this is defense-in-depth.
+  //      already skips context-only PRs at the source, so this is defense-in-depth.
   //   2. `!NON_MUTATING_DISPATCH_TYPES.has(entry.type)` — even an explicit
   //      work-item dispatch is dropped if it's a mutating type (fix, implement,
   //      test, verify, decompose, docs). Only review/ask/explore — which never
   //      push to the PR's source branch — are allowed through.
-  if (tracked._contextOnly
+  if (shared.isContextOnlyPrRecord(tracked)
       && (entry.meta?.source !== 'work-item' || !NON_MUTATING_DISPATCH_TYPES.has(entry.type))) {
     return `PR ${tracked.id || prLabel} is context-only`;
   }
@@ -445,6 +445,40 @@ function getStalePrDispatchReason(entry, config) {
   return '';
 }
 
+function cancelSourceWorkItemForPrunedDispatch(entry, reason) {
+  const itemId = entry?.meta?.item?.id;
+  if (!itemId) return false;
+  let wiPath;
+  try { wiPath = lifecycle().resolveWorkItemPath(entry.meta); }
+  catch (e) {
+    log('warn', `Failed to resolve source work item for pruned dispatch ${entry.id}: ${e.message}`);
+    return false;
+  }
+  if (!wiPath) return false;
+
+  let cancelled = false;
+  try {
+    mutateWorkItems(wiPath, (items) => {
+      if (!Array.isArray(items)) return items;
+      const wi = items.find(w => w && w.id === itemId);
+      if (!wi) return items;
+      if (DONE_STATUSES.has(wi.status) || wi.status === WI_STATUS.FAILED || wi.status === WI_STATUS.CANCELLED) return items;
+      wi.status = WI_STATUS.CANCELLED;
+      wi._cancelledBy = reason || 'stale PR dispatch pruned';
+      wi.cancelledAt = ts();
+      wi._lastDispatchResult = 'pruned-stale-pr-dispatch';
+      delete wi.dispatched_at;
+      delete wi.dispatched_to;
+      delete wi._pendingReason;
+      cancelled = true;
+      return items;
+    }, { skipWriteIfUnchanged: true });
+  } catch (e) {
+    log('warn', `Failed to cancel work item ${itemId} for pruned dispatch ${entry.id}: ${e.message}`);
+  }
+  return cancelled;
+}
+
 function pruneStalePrDispatches(config = queries.getConfig()) {
   const removed = [];
   mutateDispatch((dispatch) => {
@@ -459,7 +493,8 @@ function pruneStalePrDispatches(config = queries.getConfig()) {
 
   for (const { entry, reason } of removed) {
     try { deleteDispatchPromptSidecar(entry); } catch { /* cleanup best-effort */ }
-    log('info', `Dropped stale PR dispatch ${entry.id}: ${reason}`);
+    const cancelled = cancelSourceWorkItemForPrunedDispatch(entry, reason);
+    log('info', `Dropped stale PR dispatch ${entry.id}: ${reason}${cancelled ? ' (source work item cancelled)' : ''}`);
   }
   return removed.length;
 }

package/engine/lifecycle.js

@@ -790,6 +790,19 @@ function reconcilePrdStatuses(config) {
 
 // ─── PR Sync from Output ─────────────────────────────────────────────────────
 
+const ONE_SHOT_CONTEXT_PR_TYPES = new Set([
+  WORK_TYPE.REVIEW,
+  WORK_TYPE.ASK,
+  WORK_TYPE.EXPLORE,
+]);
+
+function shouldSyncPrAsContextOnly(meta) {
+  const item = meta?.item;
+  if (!item?.oneShot || item.skipPr) return false;
+  const type = String(item.type || item.itemType || '').trim();
+  return ONE_SHOT_CONTEXT_PR_TYPES.has(type);
+}
+
 function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
   const { structuredCompletion = null } = opts;
   const outputText = String(output || '');
@@ -996,13 +1009,14 @@ function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
       url: prUrl,
       prdItems: meta?.item?.id ? [meta.item.id] : [],
       sourcePlan: meta?.item?.sourcePlan || '',
-      itemType: meta?.item?.itemType || ''
+      itemType: meta?.item?.itemType || '',
+      contextOnly: shouldSyncPrAsContextOnly(meta),
     };
     applyScheduleContextToPrEntry(entry, meta?.item, config);
-    // Issue #1772: one-off dispatches (e.g. human-initiated "review this PR" via CC)
-    // must not enroll the discovered PR into the auto eval loop. Tag _contextOnly so
-    // discoverFromPrs skips it for review/fix dispatch (still polled for status/comments).
-    if (meta?.item?.oneShot) entry._contextOnly = true;
+    // Issue #1772: explicit one-off review/ask/explore dispatches (for example,
+    // "review this PR" via CC) must stay reference-only. QA-session setup and
+    // other oneShot+skipPr PR-targeted work are operational context, not an
+    // observe toggle, so they must not demote a real tracked PR.
     newPrsByPath.get(prPath).entries.push({ prId, fullId, entry });
   }
 
@@ -1145,7 +1159,7 @@ function _existingPrRecordForCanonicalId(canonicalPrId) {
  * can render the real merged/abandoned status instead of a perpetual blue ○.
  *
  * Idempotent: returns `{ enrolled: false, reason: 'already_tracked' }` if a row
- * already exists. Marks new records with `_contextOnly: true` so the engine
+ * already exists. Marks new records with `contextOnly: true` so the engine
  * doesn't try to manage them (no re-dispatch of fix/review loops). Live state
  * is fetched via `gh pr view` for GitHub; ADO enrollment is best-effort with
  * a conservative ACTIVE default.
@@ -1259,7 +1273,7 @@ async function enrollPrFromCanonicalId(canonicalPrId, project, opts = {}) {
     url,
     prdItems: opts.itemId ? [opts.itemId] : [],
     _attachedAt: ts(),
-    _contextOnly: true,
+    contextOnly: true,
     _enrolledBy: 'enrollPrFromCanonicalId',
   };
   if (liveState && liveState.mergedAt) entry.mergedAt = liveState.mergedAt;

package/engine/shared.js

@@ -6348,6 +6348,15 @@ function applyPrFieldDelta(target, before, after) {
 function normalizePrRecord(pr, project = null) {
   if (!pr || typeof pr !== 'object') return false;
   let changed = false;
+  const hasCanonicalContextOnly = Object.prototype.hasOwnProperty.call(pr, 'contextOnly');
+  if (hasCanonicalContextOnly) {
+    for (const legacyKey of ['_contextOnly', '_autoObserve', '_manual']) {
+      if (Object.prototype.hasOwnProperty.call(pr, legacyKey)) {
+        delete pr[legacyKey];
+        changed = true;
+      }
+    }
+  }
   const prNumber = getPrNumber(pr.prNumber ?? pr.id ?? pr.url);
   if (prNumber != null && pr.prNumber !== prNumber) {
     pr.prNumber = prNumber;
@@ -6386,17 +6395,19 @@ function normalizePrLinkItems(value) {
   return [...new Set(items.filter(item => typeof item === 'string' && item))];
 }
 
-// W-mq5s5ttx000j7ab8-a — canonical `contextOnly` gate. The 6-clause legacy
-// body (prdItems / _autoObserve / sourcePlan / itemType / agent-heuristic) is
-// replaced by a single read of the canonical field. The one-shot boot
-// migration (migratePrGateFlags) projects the legacy signals onto
-// `contextOnly` so every on-disk record has the canonical value before any
-// tick fires. Anything new written via upsertPullRequestRecord (and the
-// dashboard link/observe paths consolidated in PR #3137 / `-c`) also lands
-// on `contextOnly` directly. See W-mq5rs2eq000da8a9 for the bug repro that
-// motivated consolidating onto a single helper.
+// W-mq5s5ttx000j7ab8-a / W-mqerisvz000n3901 — canonical `contextOnly` gate
+// with a legacy bridge. Canonical `contextOnly` wins whenever it exists; legacy
+// `_contextOnly` is only a fallback for pre-migration/raw records. This keeps
+// observe toggles (`contextOnly:false`) from being overridden by stale legacy
+// contamination while still treating old context-only rows as reference-only.
+function isContextOnlyPrRecord(pr) {
+  if (!pr || typeof pr !== 'object') return false;
+  if (typeof pr.contextOnly === 'boolean') return pr.contextOnly;
+  return pr._contextOnly === true;
+}
+
 function isAutoManagedPrRecord(pr) {
-  return !!pr && typeof pr === 'object' && pr.contextOnly !== true;
+  return !!pr && typeof pr === 'object' && !isContextOnlyPrRecord(pr);
 }
 
 function mergePrLinkItems(links, prId, itemIds) {
@@ -6548,6 +6559,13 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     prNumber: prNumber ?? entry.prNumber ?? null,
     prdItems: linkedItemIds,
   };
+  const normalizedEntryContextOnly = normalizedEntry.contextOnly != null
+    ? normalizedEntry.contextOnly
+    : normalizedEntry._contextOnly;
+  if (normalizedEntryContextOnly != null) {
+    normalizedEntry.contextOnly = normalizedEntryContextOnly === true;
+    delete normalizedEntry._contextOnly;
+  }
 
   let created = false;
   let linked = false;
@@ -6568,7 +6586,8 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     } else {
       target.id = canonicalId;
       if (prNumber != null) target.prNumber = prNumber;
-      const targetWasAutoManaged = isAutoManagedPrRecord(target);
+      const targetWasAutoManaged = isAutoManagedPrRecord(target)
+        || (target.contextOnly == null && target._contextOnly === true && _prRecordIsLegacyManaged(target));
       for (const key of ['url', 'title', 'description', 'agent', 'branch', 'reviewStatus', 'status', 'created', 'sourcePlan', 'itemType']) {
         if (normalizedEntry[key] != null && normalizedEntry[key] !== '' && (target[key] == null || target[key] === '')) {
           target[key] = normalizedEntry[key];
@@ -6591,7 +6610,10 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
         : normalizedEntry._contextOnly;
       if (incomingContextOnly != null) {
         const wouldDemoteManagedPr = incomingContextOnly === true && targetWasAutoManaged;
-        if (!wouldDemoteManagedPr) target.contextOnly = incomingContextOnly === true;
+        target.contextOnly = wouldDemoteManagedPr ? false : incomingContextOnly === true;
+        delete target._contextOnly;
+        delete target._autoObserve;
+        delete target._manual;
       }
     }
     target.prdItems = normalizePrLinkItems(target.prdItems || []);
@@ -8298,7 +8320,7 @@ module.exports = {
   normalizePrRecords,
   normalizePrLinkItems, // exported for testing
   mergePrLinkItems, // exported for testing
-  isAutoManagedPrRecord,
+  isContextOnlyPrRecord,
   upsertPullRequestRecord,
   isAutoManagedPrRecord, // W-mq5s5ttx000j7ab8-a — exported for engine + watch-plugin gate consolidation
   migratePrGateFlags, // W-mq5s5ttx000j7ab8-a — boot migration wired from engine/cli.js

package/engine.js

@@ -6043,7 +6043,7 @@ async function discoverFromPrs(config, project) {
 
   for (const pr of prs) {
     if (pr.status !== PR_STATUS.ACTIVE) continue;
-    if (pr._contextOnly) {
+    if (shared.isContextOnlyPrRecord(pr)) {
       _logPrDispatchSkipOnce(pr, 'context-only');
       continue;
     }
@@ -6057,11 +6057,9 @@ async function discoverFromPrs(config, project) {
       log('info', `Branch mutex: skipping PR ${pr.id} dispatch — branch ${prBranchForMutex} locked by another agent`);
       continue;
     }
-    // Auto-managed gate: single source of truth in engine/shared.js.
-    // Honors prdItems, _autoObserve, sourcePlan/itemType, and any non-empty
-    // non-'human' agent author. See W-mq5rs2eq000da8a9 for the bug fix —
-    // the prior inline `knownAgents.has(...) || prdItems || (_manual && !_contextOnly)`
-    // silently dropped PRs with `_autoObserve: true` + human author.
+    // Auto-managed gate: single source of truth in engine/shared.js. Canonical
+    // `contextOnly` wins over stale legacy flags; legacy `_contextOnly` is only
+    // a fallback for raw pre-migration records.
     if (!shared.isAutoManagedPrRecord(pr)) {
       _logPrDispatchSkipOnce(pr, 'not-auto-managed');
       continue;

package/package.json

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