@yemi33/minions 0.1.981 → 0.1.983

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.1.981 (2026-04-15)
+## 0.1.983 (2026-04-15)
 
 ### Features
 -  gate build failure auto-fix behind autoFixBuilds flag
@@ -25,6 +25,9 @@
 - add /api/work-items/reopen endpoint and reopen-work-item CC action (#982)
 
 ### Fixes
+- Remove autoReview flag — consolidate into evalLoop (#1093)
+- link scheduled task notes back to originating item (#1090)
+-  restore rereview and human-fix dispatch
 -  build fix sets fixDispatched to block same-tick conflict fix
 -  ENGINE_DEFAULTS undefined in tick + playbook empty-var false positives
 -  defer review setCooldown to post-gating in discoverWork
@@ -42,9 +45,6 @@
 -  restore queue flush after abort — queued messages are user intent
 -  CC stale lock auto-release + queue drain on abort
 -  CC streaming 'tabId' TDZ error on new tab first message
-- fix tabId scope and close-event lock race in CC handlers
-- defer setCooldown to post-gating in discoverWork
-- fix CC queued message 'already processing' and thinking UX stacking
 
 ### Other
 - refactor(watches): rename maxTriggers→stopAfter, add onNotMet per-poll action

package/dashboard.js

@@ -395,7 +395,13 @@ function getStatus() {
     schedules: (() => {
       const scheds = CONFIG.schedules || [];
       const runs = shared.safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {};
-      return scheds.map(s => ({ ...s, _lastRun: runs[s.id] || null }));
+      return scheds.map(s => {
+        const runEntry = runs[s.id];
+        // Backward compat: runEntry can be a string (old format) or object (new format with back-references)
+        const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
+        const extra = typeof runEntry === 'object' && runEntry ? { _lastWorkItemId: runEntry.lastWorkItemId, _lastResult: runEntry.lastResult, _lastCompletedAt: runEntry.lastCompletedAt } : {};
+        return { ...s, _lastRun, ...extra };
+      });
     })(),
     watches: watchesMod.getWatches(),
     meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
@@ -3683,7 +3689,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     reloadConfig();
     const schedules = CONFIG.schedules || [];
     const runs = shared.safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {};
-    const result = schedules.map(s => ({ ...s, _lastRun: runs[s.id] || null }));
+    const result = schedules.map(s => {
+      const runEntry = runs[s.id];
+      // Backward compat: runEntry can be a string (old format) or object (new format with back-references)
+      const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
+      const extra = typeof runEntry === 'object' && runEntry ? { _lastWorkItemId: runEntry.lastWorkItemId, _lastResult: runEntry.lastResult, _lastCompletedAt: runEntry.lastCompletedAt } : {};
+      return { ...s, _lastRun, ...extra };
+    });
     return jsonReply(res, 200, { schedules: result });
   }
 

package/docs/deprecated.json

@@ -6,5 +6,13 @@
     "reason": "Consolidated into review + evalLoop config. No separate evaluate dispatch.",
     "locations": ["routing.md: evaluate row removed", "CLAUDE.md: evaluate references removed"],
     "cleanup": "Already cleaned — routing.md and CLAUDE.md updated 2026-04-02"
+  },
+  {
+    "id": "autoReview-flag",
+    "summary": "autoReview ENGINE_DEFAULT consolidated into evalLoop",
+    "deprecated": "2026-04-15",
+    "reason": "Redundant with evalLoop; evalLoop is the single gate for the review+fix cycle",
+    "locations": ["engine/shared.js ENGINE_DEFAULTS.autoReview", "engine.js discoverFromPrs autoReview variable"],
+    "cleanup": "Removed from ENGINE_DEFAULTS, removed autoReview variable from engine.js, replaced with reviewEnabled = evalLoopEnabled && pollEnabled"
   }
 ]

package/engine/cooldown.js

@@ -90,6 +90,13 @@ function setCooldownFailure(key) {
   saveCooldowns();
 }
 
+function clearCooldown(key) {
+  if (!dispatchCooldowns.has(key)) return false;
+  dispatchCooldowns.delete(key);
+  saveCooldowns();
+  return true;
+}
+
 function isAlreadyDispatched(key) {
   const dispatch = queries.getDispatch();
   // Check pending and active
@@ -130,6 +137,7 @@ module.exports = {
   setCooldownWithContext,
   getCoalescedContexts,
   setCooldownFailure,
+  clearCooldown,
   isAlreadyDispatched,
   isBranchActive,
 };

package/engine/lifecycle.js

@@ -1712,6 +1712,37 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   // Archive is manual — user archives plans from the dashboard when ready
 
+  // Scheduled task back-reference: update schedule-runs.json and write linked inbox note
+  if (meta?.item?._scheduleId) {
+    try {
+      const scheduleId = meta.item._scheduleId;
+      const itemId = meta.item.id;
+      const schedRunsPath = path.join(ENGINE_DIR, 'schedule-runs.json');
+      mutateJsonFileLocked(schedRunsPath, (runs) => {
+        runs[scheduleId] = {
+          lastRun: typeof runs[scheduleId] === 'string' ? runs[scheduleId] : (runs[scheduleId]?.lastRun || ts()),
+          lastWorkItemId: itemId,
+          lastResult: effectiveSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR,
+          lastCompletedAt: ts(),
+        };
+        return runs;
+      }, { defaultValue: {} });
+      // Write a completion note to inbox with back-references
+      const noteSlug = `sched-completion-${scheduleId}`;
+      const status = effectiveSuccess ? 'succeeded' : 'failed';
+      const noteContent = `# Scheduled Task ${status}: ${meta.item.title || scheduleId}\n\n` +
+        `**Schedule:** \`${scheduleId}\`\n` +
+        `**Work Item:** \`${itemId}\`\n` +
+        `**Result:** ${status}\n` +
+        (resultSummary ? `\n## Summary\n${resultSummary}\n` : '');
+      shared.writeToInbox('engine', noteSlug, noteContent, null, {
+        sourceItem: itemId,
+        scheduleId,
+      });
+      log('info', `Scheduled task ${scheduleId} (${itemId}) → ${status}, back-reference written`);
+    } catch (err) { log('warn', `Scheduled task back-reference: ${err.message}`); }
+  }
+
   // Clean up worktree for non-shared-branch tasks after completion
   if (meta?.branch && meta?.branchStrategy !== 'shared-branch') {
     try {

package/engine/scheduler.js

@@ -116,7 +116,9 @@ function discoverScheduledWork(config) {
       if (!sched.id || !sched.cron || !sched.title) continue;
       if (!sched.enabled) continue; // truthy check — matches dashboard UI badge behavior
 
-      const lastRun = runs[sched.id] || null;
+      // Backward compat: runs[sched.id] can be a string (old format) or object (new format)
+      const runEntry = runs[sched.id] || null;
+      const lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || null);
       if (!shouldRunNow(sched, lastRun)) continue;
 
       work.push({
@@ -133,8 +135,9 @@ function discoverScheduledWork(config) {
         _scheduleId: sched.id,
       });
 
-      // Record run time inside the lock
-      runs[sched.id] = ts();
+      // Record run time inside the lock — preserve existing fields (lastWorkItemId, lastResult, etc.)
+      const existing = typeof runs[sched.id] === 'object' && runs[sched.id] ? runs[sched.id] : {};
+      runs[sched.id] = { ...existing, lastRun: ts() };
     }
   }, { defaultValue: {} });
 

package/engine/shared.js

@@ -295,18 +295,22 @@ function parseNoteId(content) {
   return m ? m[1] : null;
 }
 
-function writeToInbox(agentId, slug, content, _inboxDir) {
+function writeToInbox(agentId, slug, content, _inboxDir, metadata) {
   try {
     const inboxDir = _inboxDir || path.join(MINIONS_DIR, 'notes', 'inbox');
     const prefix = `${agentId}-${slug}-${dateStamp()}`;
     const existing = safeReadDir(inboxDir).find(f => f.startsWith(prefix));
     if (existing) return false;
     const noteId = `NOTE-${uid()}`;
+    // Build optional metadata lines for frontmatter injection
+    const metaLines = (metadata && typeof metadata === 'object')
+      ? Object.entries(metadata).filter(([, v]) => v != null).map(([k, v]) => `${k}: ${v}`).join('\n')
+      : '';
     // Inject structured ID as YAML frontmatter if content doesn't already have it
     const hasFrontmatter = /^\s*---[\r\n]/.test(content);
     const tagged = hasFrontmatter
-      ? content.replace(/^\s*---[\r\n]+/, `---\nid: ${noteId}\n`)
-      : `---\nid: ${noteId}\nagent: ${agentId}\ndate: ${dateStamp()}\n---\n\n${content}`;
+      ? content.replace(/^\s*---[\r\n]+/, `---\nid: ${noteId}\n${metaLines ? metaLines + '\n' : ''}`)
+      : `---\nid: ${noteId}\nagent: ${agentId}\ndate: ${dateStamp()}\n${metaLines ? metaLines + '\n' : ''}---\n\n${content}`;
     const filePath = path.join(inboxDir, `${prefix}.md`);
     safeWrite(filePath, tagged);
     return noteId;
@@ -532,7 +536,6 @@ const ENGINE_DEFAULTS = {
   autoDecompose: true, // auto-decompose implement:large items into sub-tasks
   autoApprovePlans: false, // auto-approve PRDs without waiting for human approval
   autoArchive: false, // opt-in: auto-archive plans after verify completes (false = mark ready, user archives manually)
-  autoReview: true, // auto-dispatch review agents for new PRs (disable for manual review workflow)
   autoFixConflicts: true, // auto-dispatch fix agents when a PR has merge conflicts
   autoFixBuilds: true, // auto-dispatch fix agents when a PR build fails
   meetingRoundTimeout: 600000, // 10min per meeting round before auto-advance
@@ -618,6 +621,12 @@ const PR_POLLABLE_STATUSES = new Set([PR_STATUS.ACTIVE, PR_STATUS.LINKED]);
 const WATCH_STATUS = { ACTIVE: 'active', PAUSED: 'paused', TRIGGERED: 'triggered', EXPIRED: 'expired' };
 const WATCH_TARGET_TYPE = { PR: 'pr', WORK_ITEM: 'work-item' };
 const WATCH_CONDITION = { MERGED: 'merged', BUILD_FAIL: 'build-fail', BUILD_PASS: 'build-pass', COMPLETED: 'completed', FAILED: 'failed', STATUS_CHANGE: 'status-change', ANY: 'any' };
+// Absolute conditions auto-expire on first trigger when stopAfter=0 (fire-once semantics).
+// Change-based conditions (status-change, any) run forever when stopAfter=0.
+const WATCH_ABSOLUTE_CONDITIONS = new Set([
+  WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
+  WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
+]);
 
 /** Update per-agent review metrics (prsApproved/prsRejected). Only writes for configured agents. */
 function trackReviewMetric(pr, newReviewStatus, config) {
@@ -1144,7 +1153,7 @@ module.exports = {
   classifyInboxItem,
   ENGINE_DEFAULTS,
   WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
-  WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION,
+  WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, ESCALATION_POLICY, COMPLETION_FIELDS,
   DEFAULT_AGENT_METRICS,

package/engine/watches.js

@@ -237,15 +237,10 @@ function checkWatches(config, state) {
           }
           log('info', `Watch triggered: ${watch.id} — ${result.message}`);
 
-          // Expire: absolute conditions auto-expire when stopAfter is 0 (fire-once semantics),
-          // change-based conditions (status-change, any) respect stopAfter literally (0 = run forever).
-          const isAbsolute = WATCH_ABSOLUTE_CONDITIONS.has(watch.condition);
+          // Expire when stopAfter limit is reached. stopAfter=0 means run forever (no limit).
           if (watch.stopAfter > 0 && watch.triggerCount >= watch.stopAfter) {
             watch.status = WATCH_STATUS.EXPIRED;
             log('info', `Watch expired (stopAfter limit reached): ${watch.id}`);
-          } else if (isAbsolute && watch.stopAfter === 0) {
-            watch.status = WATCH_STATUS.EXPIRED;
-            log('info', `Watch expired (absolute condition auto-expire): ${watch.id}`);
           }
         } else if (watch.onNotMet === 'notify' && watch.owner) {
           // Queue per-poll notification when condition is not yet met — unique key per poll

package/engine.js

@@ -1500,7 +1500,7 @@ function updateSnapshot(config) {
 
 const { COOLDOWN_PATH, dispatchCooldowns, loadCooldowns, saveCooldowns,
   isOnCooldown, setCooldown, setCooldownWithContext, getCoalescedContexts,
-  setCooldownFailure, isAlreadyDispatched, isBranchActive } = require('./engine/cooldown');
+  setCooldownFailure, clearCooldown, isAlreadyDispatched, isBranchActive } = require('./engine/cooldown');
 
 
 
@@ -1898,6 +1898,13 @@ async function discoverFromPrs(config, project) {
 
   const projMeta = { name: project?.name, localPath: project?.localPath };
 
+  // Resolve poll-enabled per project — stale reviewStatus is untrustworthy without poller
+  const isAdoProject = project?.repoHost !== 'github';
+  const pollEnabled = isAdoProject
+    ? (config.engine?.adoPollEnabled ?? DEFAULTS.adoPollEnabled)
+    : (config.engine?.ghPollEnabled ?? DEFAULTS.ghPollEnabled);
+  const evalLoopEnabled = config.engine?.evalLoop !== false;
+
   // Collect active PR dispatches to prevent simultaneous review+fix on same PR
   const dispatch = getDispatch();
   const activePrIds = new Set(
@@ -1945,10 +1952,10 @@ async function discoverFromPrs(config, project) {
       log('warn', `PR ${pr.id}: review→fix escalated after ${evalCycles} cycles — suspending auto-dispatch`);
     }
 
-    // PRs needing review: pending review status and not already reviewed without new commits
-    const autoReview = config.engine?.autoReview !== false;
+    // PRs needing review: evalLoop gates the entire review+fix cycle; pollEnabled ensures reviewStatus is fresh
+    const reviewEnabled = evalLoopEnabled && pollEnabled;
     const alreadyReviewed = pr.lastReviewedAt && (!pr.lastPushedAt || pr.lastPushedAt <= pr.lastReviewedAt);
-    const needsReview = autoReview && reviewStatus === 'pending' && !alreadyReviewed && !evalEscalated;
+    const needsReview = reviewEnabled && reviewStatus === 'pending' && !alreadyReviewed && !evalEscalated;
     if (needsReview) {
       const key = `review-${project?.name || 'default'}-${pr.id}`;
       if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
@@ -1972,6 +1979,47 @@ async function discoverFromPrs(config, project) {
           } catch {}
           continue;
         }
+      } catch (e) { log('warn', `Pre-dispatch vote check for ${pr.id}: ${e.message} — skipping dispatch`); continue; }
+
+      const agentId = resolveAgent('review', config);
+      if (!agentId) continue;
+
+      const item = buildPrDispatch(agentId, config, project, pr, 'review', {
+        pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: pr.branch || '',
+        pr_author: pr.agent || '', pr_url: pr.url || '',
+      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
+      if (item) { newWork.push(item); }
+    }
+
+    // Re-review after fix: trigger when a fix was pushed after the last minions review,
+    // or when no minions review has completed yet (e.g. human-feedback-only fix path).
+    const fixedAfterReview = !!(pr.minionsReview?.fixedAt &&
+      (!pr.lastReviewedAt || pr.minionsReview.fixedAt > pr.lastReviewedAt));
+    const needsReReview = autoReview && reviewStatus === 'waiting' &&
+      fixedAfterReview && !evalEscalated;
+    if (needsReReview) {
+      const key = `rereview-${project?.name || 'default'}-${pr.id}`;
+      // Skip isAlreadyDispatched — fixedAfterReview/lastReviewedAt already dedupe; the 1hr
+      // completed-dispatch window would block legitimate re-reviews within the hour after a fix
+      if (isOnCooldown(key, cooldownMs)) continue;
+
+      // Pre-dispatch live vote check — cached 'waiting' may be stale if reviewer already acted
+      try {
+        const checkFn = project.repoHost === 'github' ? ghCheckLiveReview : adoCheckLiveReview;
+        const liveStatus = await checkFn(pr, project);
+        if (liveStatus && liveStatus !== 'waiting') {
+          log('info', `Pre-dispatch vote check: ${pr.id} is ${liveStatus} (cached was waiting) — skipping re-review`);
+          if (pr.reviewStatus !== 'approved') pr.reviewStatus = liveStatus;
+          try {
+            mutateJsonFileLocked(projectPrPath(project), data => {
+              if (!Array.isArray(data)) return data;
+              const target = data.find(p => p.id === pr.id);
+              if (target && target.reviewStatus !== 'approved') target.reviewStatus = liveStatus;
+              return data;
+            });
+          } catch {}
+          continue;
+        }
       } catch (e) { log('warn', `Pre-dispatch vote check for ${pr.id}: ${e.message}`); }
 
       const agentId = resolveAgent('review', config);
@@ -2013,7 +2061,15 @@ async function discoverFromPrs(config, project) {
     const hasCoalescedFeedback = (dispatchCooldowns.get(humanFixKey)?.pendingContexts || []).length > 0;
     if ((pr.humanFeedback?.pendingFix || hasCoalescedFeedback) && !awaitingReReview && !fixDispatched) {
       const key = humanFixKey;
-      if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) {
+      let staleCoalesced = [];
+      const alreadyDispatched = isAlreadyDispatched(key);
+      const blockedByCooldown = isOnCooldown(key, cooldownMs);
+      if (blockedByCooldown && !alreadyDispatched) {
+        staleCoalesced = getCoalescedContexts(key);
+        clearCooldown(key);
+        log('info', `Cleared stale cooldown for ${key} — no matching dispatch history`);
+      }
+      if (alreadyDispatched || isOnCooldown(key, cooldownMs)) {
         // Coalesce: save feedback for next dispatch
         if (pr.humanFeedback?.feedbackContent) {
           setCooldownWithContext(key, { feedbackContent: pr.humanFeedback.feedbackContent, timestamp: ts() });
@@ -2023,7 +2079,7 @@ async function discoverFromPrs(config, project) {
       const agentId = resolveAgent('fix', config, pr.agent);
       if (!agentId) continue;
 
-      const coalesced = getCoalescedContexts(key);
+      const coalesced = [...staleCoalesced, ...getCoalescedContexts(key)];
       let reviewNote = pr.humanFeedback.feedbackContent || 'See PR thread comments';
       if (coalesced.length > 0) {
         const earlier = coalesced.map(c => c.feedbackContent).filter(Boolean).join('\n\n---\n\n');
@@ -2035,7 +2091,7 @@ async function discoverFromPrs(config, project) {
         reviewer: 'Human Reviewer',
         review_note: reviewNote,
       }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, source: 'pr-human-feedback', pr, branch: pr.branch, project: projMeta });
-      if (item) { newWork.push(item); setCooldown(key); fixDispatched = true; }
+      if (item) { newWork.push(item); fixDispatched = true; }
     }
 
     // PRs with build failures — route to author (has session context from implementing)
@@ -3561,4 +3617,3 @@ if (require.main === module) {
   const [cmd, ...args] = process.argv.slice(2);
   handleCommand(cmd, args);
 }
-

package/package.json

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