@yemi33/minions 0.1.1702 → 0.1.1704

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.1704 (2026-05-04)
+
+### Features
+-  Add manual run control for schedules
+- deduplicate work item creation
+- isolate review metadata
+
 ## 0.1.1702 (2026-05-04)
 
 ### Other

package/dashboard/js/render-schedules.js

@@ -302,6 +302,7 @@ function renderSchedules(schedules) {
         '<td>' + enabledBadge + '</td>' +
         '<td><span class="pr-date">' + escHtml(lastRun) + '</span></td>' +
         '<td style="white-space:nowrap">' +
+          '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-right:4px" onclick="event.stopPropagation();runScheduleNow(\'' + escHtml(s.id) + '\',this)" title="Run now">Run now</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';border-color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + ';margin-right:4px" onclick="event.stopPropagation();toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ')" title="' + (s.enabled ? 'Disable' : 'Enable') + '">' + (s.enabled ? '&#x23F8;' : '&#x25B6;') + '</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();openEditScheduleModal(\'' + escHtml(s.id) + '\')" title="Edit">&#x270E;</button>' +
           '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--red);border-color:var(--red)" onclick="event.stopPropagation();deleteSchedule(\'' + escHtml(s.id) + '\')" title="Delete">&#x2715;</button>' +
@@ -336,6 +337,7 @@ function openScheduleDetail(id) {
 
   document.getElementById('modal-title').innerHTML = escHtml(s.title || s.id) +
     ' <div style="display:flex;gap:4px;margin-top:4px">' +
+      '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--green)" onclick="runScheduleNow(\'' + escHtml(s.id) + '\',this)">Run now</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--blue)" onclick="closeModal();openEditScheduleModal(\'' + escHtml(s.id) + '\')">Edit</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:' + (s.enabled ? 'var(--yellow)' : 'var(--green)') + '" onclick="toggleScheduleEnabled(\'' + escHtml(s.id) + '\',' + !s.enabled + ');closeModal()">' + (s.enabled ? 'Disable' : 'Enable') + '</button>' +
       '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--red)" onclick="deleteSchedule(\'' + escHtml(s.id) + '\');closeModal()">Delete</button>' +
@@ -544,6 +546,26 @@ async function toggleScheduleEnabled(id, enabled) {
   } catch (e) { _showScheduleError('Toggle error: ' + e.message); refresh(); }
 }
 
+async function runScheduleNow(id, btn) {
+  if (btn) { btn.textContent = 'Running...'; btn.style.pointerEvents = 'none'; btn.style.opacity = '0.6'; }
+  try {
+    const res = await fetch('/api/schedules/run-now', {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id })
+    });
+    if (res.ok) {
+      showToast('cmd-toast', 'Schedule run queued', true);
+      refresh();
+    } else {
+      const d = await res.json().catch(() => ({}));
+      showToast('cmd-toast', 'Run failed: ' + (d.error || 'unknown'), false);
+    }
+  } catch (e) {
+    showToast('cmd-toast', 'Run error: ' + e.message, false);
+  }
+  if (btn) { btn.textContent = 'Run now'; btn.style.pointerEvents = ''; btn.style.opacity = ''; }
+}
+
 async function deleteSchedule(id) {
   if (!confirm('Delete scheduled task "' + id + '"?')) return;
   showToast('cmd-toast', 'Schedule deleted', true);
@@ -562,4 +584,4 @@ async function deleteSchedule(id) {
 // Expose _generateScheduleId globally for the inline oninput handler
 window._generateScheduleId = _generateScheduleId;
 
-window.MinionsSchedules = { renderSchedules, openCreateScheduleModal, openEditScheduleModal, openScheduleDetail, submitSchedule, toggleScheduleEnabled, deleteSchedule, _cronToHuman, _parseNaturalCron, _toggleCronMode, _quickSelectDays, _toggleDayPill, _updateCronPreview, _schedPrev, _schedNext, _schedSetView };
+window.MinionsSchedules = { renderSchedules, openCreateScheduleModal, openEditScheduleModal, openScheduleDetail, submitSchedule, toggleScheduleEnabled, runScheduleNow, deleteSchedule, _cronToHuman, _parseNaturalCron, _toggleCronMode, _quickSelectDays, _toggleDayPill, _updateCronPreview, _schedPrev, _schedNext, _schedSetView };

package/dashboard.js

@@ -126,6 +126,124 @@ function copyWorkItemPrFields(item, input, pr = null) {
   if (pr?.title || input.prTitle) item.prTitle = pr?.title || input.prTitle;
   if (pr?.url || input.prUrl) item.prUrl = pr?.url || input.prUrl;
 }
+
+function normalizeWorkItemDedupText(value) {
+  return String(value == null ? '' : value)
+    .replace(/\r\n/g, '\n')
+    .replace(/[ \t]+$/gm, '')
+    .trim();
+}
+
+function resolveWorkItemDedupProject(item, wiPath = '') {
+  const projectName = normalizeWorkItemDedupText(item?.project || item?._project || item?._source);
+  if (projectName) {
+    const namedProject = PROJECTS.find(p => p?.name === projectName);
+    if (namedProject) return namedProject;
+  }
+  if (!wiPath) return null;
+  const resolvedWiPath = path.resolve(wiPath);
+  return PROJECTS.find(p => path.resolve(shared.projectWorkItemsPath(p)) === resolvedWiPath) || null;
+}
+
+function getWorkItemPrRefCandidates(item) {
+  return [
+    item?.targetPr,
+    item?.pr,
+    item?.prId,
+    item?.pullRequest,
+    item?.sourcePr,
+    item?.prUrl,
+    item?.pr_id,
+    item?.prNumber,
+  ].filter(value => value != null && value !== '');
+}
+
+function normalizeWorkItemDedupPrIdentity(item, project = null) {
+  if (!item || typeof item !== 'object') return '';
+  const candidates = getWorkItemPrRefCandidates(item);
+  for (const candidate of candidates) {
+    const scoped = shared.getPrScopeInfo(candidate);
+    if (scoped) return `${scoped.scope}#${scoped.prNumber}`;
+  }
+  const prNumber = candidates.reduce((found, candidate) => (
+    found ?? shared.getPrNumber(candidate)
+  ), null);
+  if (project && prNumber != null) {
+    const canonical = shared.getCanonicalPrId(project, prNumber);
+    if (canonical) return canonical;
+  }
+  if (prNumber != null) return `PR-${prNumber}`;
+  const prRef = getWorkItemPrRef(item) || item.pr_id || item.targetPr || item.prUrl || '';
+  return normalizeWorkItemDedupText(prRef).toLowerCase();
+}
+
+function workItemCreateFingerprint(item, options = {}) {
+  const project = resolveWorkItemDedupProject(item, options.wiPath);
+  return {
+    title: normalizeWorkItemDedupText(item?.title),
+    type: routing.normalizeWorkType(item?.type || item?.workType, WORK_TYPE.IMPLEMENT),
+    priority: normalizeWorkItemDedupText(item?.priority || 'medium').toLowerCase(),
+    description: normalizeWorkItemDedupText(item?.description),
+    prIdentity: normalizeWorkItemDedupPrIdentity(item, project),
+  };
+}
+
+function isActiveWorkItemCreateStatus(status) {
+  return status === WI_STATUS.PENDING || status === WI_STATUS.DISPATCHED || status === WI_STATUS.QUEUED;
+}
+
+function isWithinWorkItemCreateDedupWindow(item, nowMs, windowMs) {
+  const createdMs = Date.parse(item?.created || item?.createdAt || item?.created_at || '');
+  if (!Number.isFinite(createdMs)) return true;
+  return nowMs - createdMs <= windowMs;
+}
+
+function findDuplicateWorkItemCreate(items, candidate, options = {}) {
+  if (!Array.isArray(items)) return null;
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const windowMs = Number.isFinite(options.windowMs) ? options.windowMs : shared.ENGINE_DEFAULTS.workItemCreateDedupWindowMs;
+  const candidateFingerprint = workItemCreateFingerprint(candidate, options);
+  return items.find(item => {
+    if (!isActiveWorkItemCreateStatus(item?.status)) return false;
+    if (!isWithinWorkItemCreateDedupWindow(item, nowMs, windowMs)) return false;
+    const existingFingerprint = workItemCreateFingerprint(item, options);
+    return existingFingerprint.title === candidateFingerprint.title &&
+      existingFingerprint.type === candidateFingerprint.type &&
+      existingFingerprint.priority === candidateFingerprint.priority &&
+      existingFingerprint.description === candidateFingerprint.description &&
+      existingFingerprint.prIdentity === candidateFingerprint.prIdentity;
+  }) || null;
+}
+
+function createWorkItemWithDedup(wiPath, item, options = {}) {
+  let result = null;
+  mutateWorkItems(wiPath, items => {
+    const existing = findDuplicateWorkItemCreate(items, item, { ...options, wiPath });
+    if (existing) {
+      result = { created: false, item: existing, duplicateOf: existing.id };
+      return items;
+    }
+    items.push(item);
+    result = { created: true, item };
+    return items;
+  });
+  return result || { created: false, item: null };
+}
+
+function resolveWorkItemsCreateTarget(projectName, projects = PROJECTS) {
+  const project = String(projectName || '').trim();
+  let targetProject = null;
+  if (project) {
+    targetProject = projects.find(p => p.name === project) || (projects.length > 0 ? projects[0] : null);
+    if (!targetProject) return { error: 'No projects configured' };
+  } else if (projects.length === 1) {
+    targetProject = projects[0];
+  }
+  return {
+    project: targetProject,
+    wiPath: targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json'),
+  };
+}
 function linkPullRequestForTracking({ url, title, project: projectName, autoObserve, context, workItemId }, config = CONFIG, options = {}) {
   if (!url) {
     const err = new Error('url required');
@@ -1531,20 +1649,21 @@ async function executeCCActions(actions) {
           // Mark oneShot so any discovered PR is tagged _contextOnly (skips eval loop).
           const ccOneShotTypes = new Set(['review', 'explore', 'test']);
           const isOneShot = action.oneShot === true || (action.oneShot !== false && ccOneShotTypes.has(workType));
-          shared.mutateJsonFileLocked(wiPath, items => {
-            if (!Array.isArray(items)) items = [];
-            const item = {
-              id, title: action.title, type: workType,
-              priority: action.priority || 'medium', description: action.description || '',
-              status: WI_STATUS.PENDING, created: new Date().toISOString(),
-              createdBy: 'command-center', project: targetProject?.name || project,
-              ...(agentHints.length ? { preferred_agent: agentHints[0], agents: agentHints } : {}),
-              ...(isOneShot ? { oneShot: true } : {}),
-            };
-            copyWorkItemPrFields(item, action, linkedPr);
-            items.push(item);
-            return items;
-          }, { defaultValue: [] });
+          const item = {
+            id, title: action.title.trim(), type: workType,
+            priority: action.priority || 'medium', description: action.description || '',
+            status: WI_STATUS.PENDING, created: new Date().toISOString(),
+            createdBy: 'command-center', project: targetProject?.name || project,
+            ...(agentHints.length ? { preferred_agent: agentHints[0], agents: agentHints } : {}),
+            ...(isOneShot ? { oneShot: true } : {}),
+          };
+          copyWorkItemPrFields(item, action, linkedPr);
+          const createResult = createWorkItemWithDedup(wiPath, item);
+          if (!createResult.created) {
+            const duplicateId = createResult.duplicateOf || createResult.item?.id;
+            results.push({ type: action.type, id: duplicateId, ok: true, duplicate: true, duplicateOf: duplicateId });
+            break;
+          }
           results.push({ type: action.type, id, ok: true });
 
           // Pre-flight routing check: warn the user if no agent is currently available so the new
@@ -2840,22 +2959,17 @@ const server = http.createServer(async (req, res) => {
     try {
       const body = await readBody(req);
       if (!body.title || !body.title.trim()) return jsonReply(res, 400, { error: 'title is required' });
-      let wiPath;
-      if (body.project) {
-        // Write to project-specific queue
-        const targetProject = PROJECTS.find(p => p.name === body.project) || (PROJECTS.length > 0 ? PROJECTS[0] : null);
-        if (!targetProject) return jsonReply(res, 400, { error: 'No projects configured' });
-        wiPath = shared.projectWorkItemsPath(targetProject);
-      } else {
-        // Write to central queue — agent decides which project
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      }
+      const target = resolveWorkItemsCreateTarget(body.project);
+      if (target.error) return jsonReply(res, 400, { error: target.error });
+      const wiPath = target.wiPath;
+      const targetProject = target.project;
       const id = 'W-' + shared.uid();
       const item = {
         id, title: body.title.trim(), type: routing.normalizeWorkType(body.type, WORK_TYPE.IMPLEMENT),
         priority: body.priority || 'medium', description: body.description || '',
         status: WI_STATUS.PENDING, created: new Date().toISOString(), createdBy: 'dashboard',
       };
+      if (targetProject) item.project = targetProject.name;
       if (body.scope) item.scope = body.scope;
       // Agent assignment normalization: `agent` and `agents` are routing hints.
       // Use agentLock/hardAgent only for the rare case where an item must wait
@@ -2870,18 +2984,11 @@ const server = http.createServer(async (req, res) => {
       if (body.skipPr) item.skipPr = true;
       if (body.oneShot) item.oneShot = true;
       copyWorkItemPrFields(item, body);
-      let dupId = null;
-      mutateJsonFileLocked(wiPath, (items) => {
-        if (!Array.isArray(items)) items = [];
-        const existing = items.find(i =>
-          i.title === item.title &&
-          (i.status === WI_STATUS.PENDING || i.status === WI_STATUS.DISPATCHED || i.status === WI_STATUS.QUEUED)
-        );
-        if (existing) { dupId = existing.id; return items; }
-        items.push(item);
-        return items;
-      });
-      if (dupId) return jsonReply(res, 200, { ok: true, id: dupId, duplicate: true });
+      const createResult = createWorkItemWithDedup(wiPath, item);
+      if (!createResult.created) {
+        const duplicateId = createResult.duplicateOf || createResult.item?.id;
+        return jsonReply(res, 200, { ok: true, id: duplicateId, duplicate: true, duplicateOf: duplicateId });
+      }
       return jsonReply(res, 200, { ok: true, id });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
@@ -5446,6 +5553,69 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return jsonReply(res, 200, { ok: true });
   }
 
+  async function handleSchedulesRunNow(req, res) {
+    const body = await readBody(req);
+    const { id } = body;
+    if (!id) return jsonReply(res, 400, { error: 'id required' });
+
+    reloadConfig();
+    const sched = (CONFIG.schedules || []).find(s => s.id === id);
+    if (!sched) return jsonReply(res, 404, { error: 'Schedule not found' });
+
+    const schedulerMod = require('./engine/scheduler');
+    let item;
+    try {
+      item = schedulerMod.createScheduledWorkItem(sched);
+    } catch (e) {
+      return jsonReply(res, 400, { error: e.message });
+    }
+
+    let meeting = null;
+    if (item.type === WORK_TYPE.MEETING) {
+      const { createMeeting } = require('./engine/meeting');
+      meeting = createMeeting({
+        title: item.title,
+        agenda: item.description,
+        participants: Array.isArray(sched.participants) ? sched.participants : [],
+      });
+    } else {
+      const centralPath = path.join(MINIONS_DIR, 'work-items.json');
+      let duplicate = null;
+      mutateJsonFileLocked(centralPath, (items) => {
+        if (!Array.isArray(items)) items = [];
+        duplicate = items.find(i =>
+          i._scheduleId === item._scheduleId &&
+          i.status !== WI_STATUS.DONE &&
+          i.status !== WI_STATUS.FAILED
+        );
+        if (!duplicate) items.push(item);
+        return items;
+      }, { defaultValue: [] });
+      if (duplicate) {
+        return jsonReply(res, 409, {
+          error: 'Schedule already has an active work item',
+          id: duplicate.id,
+          scheduleId: sched.id,
+        });
+      }
+    }
+
+    const runEntry = schedulerMod.recordScheduleRun(sched.id, item.id);
+    try {
+      shared.mutateControl(control => ({ ...control, _wakeupAt: Date.now() }));
+    } catch (e) {
+      shared.log('warn', `Schedule run-now wakeup failed for ${sched.id}: ${e.message}`);
+    }
+    invalidateStatusCache();
+    return jsonReply(res, 200, {
+      ok: true,
+      id: item.id,
+      scheduleId: sched.id,
+      lastRun: runEntry?.lastRun || null,
+      ...(meeting ? { meetingId: meeting.id } : {}),
+    });
+  }
+
   async function handleSchedulesParseNatural(req, res) {
     const body = await readBody(req);
     const { text } = body;
@@ -6427,6 +6597,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/schedules', desc: 'Create a new schedule', params: 'cron, title, id?, type?, project?, agent?, description?, priority?, enabled?', handler: handleSchedulesCreate },
     { method: 'POST', path: '/api/schedules/update', desc: 'Update an existing schedule', params: 'id, cron?, title?, type?, project?, agent?, description?, priority?, enabled?', handler: handleSchedulesUpdate },
     { method: 'POST', path: '/api/schedules/delete', desc: 'Delete a schedule', params: 'id', handler: handleSchedulesDelete },
+    { method: 'POST', path: '/api/schedules/run-now', desc: 'Manually enqueue the work item for a schedule', params: 'id', handler: handleSchedulesRunNow },
 
     // Watches
     { method: 'GET', path: '/api/watches', desc: 'List all watches', handler: handleWatchesList },
@@ -6757,6 +6928,9 @@ module.exports = {
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,
   _ccValidateAction,
+  _findDuplicateWorkItemCreate: findDuplicateWorkItemCreate,
+  _createWorkItemWithDedup: createWorkItemWithDedup,
+  _resolveWorkItemsCreateTarget: resolveWorkItemsCreateTarget,
   executeCCActions,
 };
 

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T07:21:09.935Z"
+  "cachedAt": "2026-05-04T07:35:19.967Z"
 }

package/engine/lifecycle.js

@@ -1273,12 +1273,31 @@ function reviewPrRefFromCompletion(completion) {
   return value;
 }
 
+function reviewPrRefMatchesDispatchTarget(reportedPr, dispatchPr, project) {
+  if (!reportedPr || !dispatchPr) return true;
+  const reportedUrl = typeof reportedPr === 'object' ? reportedPr.url || '' : String(reportedPr || '');
+  const dispatchUrl = typeof dispatchPr === 'object' ? dispatchPr.url || '' : String(dispatchPr || '');
+  const reportedId = shared.getCanonicalPrId(project, reportedPr, reportedUrl);
+  const dispatchId = shared.getCanonicalPrId(project, dispatchPr, dispatchUrl);
+  if (!reportedId || !dispatchId || reportedId === dispatchId) return true;
+
+  const reportedNumber = shared.getPrNumber(reportedPr);
+  const dispatchNumber = shared.getPrNumber(dispatchPr);
+  if (reportedNumber == null || dispatchNumber == null || reportedNumber !== dispatchNumber) return false;
+
+  const reportedScoped = !/^PR-\d+$/i.test(reportedId);
+  const dispatchScoped = !/^PR-\d+$/i.test(dispatchId);
+  return !(reportedScoped && dispatchScoped);
+}
+
 function centralPrPath() {
   return path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
 }
 
 function resolveReviewPrContext(pr, project, config, structuredCompletion = null) {
-  const refs = [pr, reviewPrRefFromCompletion(structuredCompletion)].filter(Boolean);
+  const reportedPr = reviewPrRefFromCompletion(structuredCompletion);
+  if (reportedPr && pr && !reviewPrRefMatchesDispatchTarget(reportedPr, pr, project)) return null;
+  const refs = reportedPr ? [reportedPr] : [pr].filter(Boolean);
   if (refs.length === 0) return null;
 
   const projects = shared.getProjects(config);
@@ -1292,6 +1311,8 @@ function resolveReviewPrContext(pr, project, config, structuredCompletion = null
     const prPath = shared.projectPrPath(candidateProject);
     const prs = safeJson(prPath) || [];
     for (const ref of refs) {
+      const refUrl = typeof ref === 'object' ? ref.url || '' : String(ref || '');
+      if (!shared.isPrCompatibleWithProject(candidateProject, ref, refUrl)) continue;
       const target = shared.findPrRecord(prs, ref, candidateProject);
       if (target) return { pr: { ...target }, project: candidateProject, prPath };
     }
@@ -1299,11 +1320,14 @@ function resolveReviewPrContext(pr, project, config, structuredCompletion = null
 
   const centralPath = centralPrPath();
   const centralPrs = safeJson(centralPath) || [];
-  for (const ref of refs) {
+  const centralRefs = reportedPr ? [reportedPr] : refs;
+  for (const ref of centralRefs) {
     const target = shared.findPrRecord(centralPrs, ref, null);
     if (target) return { pr: { ...target }, project: null, prPath: centralPath };
   }
 
+  if (reportedPr) return null;
+
   return pr?.id
     ? { pr, project: project || null, prPath: project ? shared.projectPrPath(project) : centralPath }
     : null;
@@ -1312,6 +1336,12 @@ function resolveReviewPrContext(pr, project, config, structuredCompletion = null
 async function updatePrAfterReview(agentId, pr, project, config, resultSummary, structuredCompletion = null, dispatchItem = null) {
 
   if (!config) config = getConfig();
+  const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  if (completionStatus && NON_TERMINAL_COMPLETION_STATUSES.has(completionStatus)) {
+    const target = pr?.id || reviewPrRefFromCompletion(structuredCompletion) || 'unknown PR';
+    log('warn', `Skipping review update for ${target}: completion status is ${structuredCompletion.status}`);
+    return;
+  }
   const reviewContext = resolveReviewPrContext(pr, project, config, structuredCompletion);
   if (!reviewContext?.pr?.id) {
     const reportedPr = reviewPrRefFromCompletion(structuredCompletion);
@@ -1349,6 +1379,7 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
   }
 
   let updatedTarget = null;
+  const reviewNote = String(resultSummary || '').trim();
   shared.mutateJsonFileLocked(prPath, (prs) => {
     if (!Array.isArray(prs)) return prs;
     const target = shared.findPrRecord(prs, reviewPr, reviewProject);
@@ -1365,7 +1396,7 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
     target.minionsReview = {
       reviewer: reviewerName,
       reviewedAt: ts(),
-      note: resultSummary || '',
+      note: reviewNote,
       dispatchId: dispatchItem?.id || structuredCompletion?.dispatchId || null,
       sourceItem: dispatchItem?.meta?.item?.id || null,
       // Preserve fixedAt across re-reviews so the poller guard knows a fix was pushed.
@@ -1388,7 +1419,14 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
   }
 
   log('info', `Updated ${reviewPr.id} → minions review: ${postReviewStatus || 'waiting'} by ${reviewerName}`);
-  if (updatedTarget) createReviewFeedbackForAuthor(agentId, updatedTarget, config, { dispatchItem, structuredCompletion });
+  if (updatedTarget) {
+    createReviewFeedbackForAuthor(agentId, updatedTarget, config, {
+      reviewContent: reviewNote,
+      project: reviewProject,
+      dispatchId: dispatchItem?.id || structuredCompletion?.dispatchId || null,
+      sourceItem: dispatchItem?.meta?.item?.id || null,
+    });
+  }
 }
 
 function updatePrAfterFix(pr, project, source) {
@@ -1838,28 +1876,35 @@ function createReviewFeedbackForAuthor(reviewerAgentId, pr, config, opts = {}) {
   const authorAgentId = pr.agent.toLowerCase();
   if (!config.agents[authorAgentId]) return;
   const today = dateStamp();
-  const inboxFiles = getInboxFiles();
-  const reviewFiles = inboxFiles.filter(f => f.includes(reviewerAgentId) && f.includes(today));
-  if (reviewFiles.length === 0) return;
-  const matchedReviewContent = [];
-  for (const f of reviewFiles) {
-    const content = safeRead(path.join(INBOX_DIR, f));
-    if (!content) continue;
-    if (!reviewFeedbackSourceMatches({
-      fileName: f,
-      content,
-      reviewerAgentId,
-      pr,
-      dispatchItem: opts.dispatchItem,
-      structuredCompletion: opts.structuredCompletion,
-    })) continue;
-    matchedReviewContent.push(content);
-  }
-  if (matchedReviewContent.length === 0) return;
-  const reviewContent = matchedReviewContent.join('\n\n');
+  const project = opts.project || opts.dispatchItem?.meta?.project || null;
+  let reviewContent = String(opts.reviewContent || '').trim();
+  if (reviewContent) {
+    if (!reviewContentMatchesPr(reviewContent, pr, project)) {
+      log('warn', `Skipped review feedback for ${pr.id}: review content references a different PR`);
+      return;
+    }
+  } else {
+    const inboxFiles = getInboxFiles();
+    const reviewFiles = inboxFiles.filter(f => f.includes(reviewerAgentId) && f.includes(today));
+    if (reviewFiles.length === 0) return;
+    const matchedReviewContent = [];
+    for (const f of reviewFiles) {
+      const content = safeRead(path.join(INBOX_DIR, f));
+      if (!content) continue;
+      if (!reviewFeedbackSourceMatches({
+        fileName: f,
+        content,
+        reviewerAgentId,
+        pr,
+        dispatchItem: opts.dispatchItem,
+        structuredCompletion: opts.structuredCompletion,
+      })) continue;
+      matchedReviewContent.push(content);
+    }
+    if (matchedReviewContent.length === 0) return;
+    reviewContent = matchedReviewContent.join('\n\n');
+  }
   const prSlug = shared.safeSlugComponent(pr.id, 60);
-  const feedbackFile = `feedback-${authorAgentId}-from-${reviewerAgentId}-${prSlug}-${today}.md`;
-  const feedbackPath = shared.uniquePath(path.join(INBOX_DIR, feedbackFile));
   const content = `# Review Feedback for ${config.agents[authorAgentId]?.name || authorAgentId}\n\n` +
     `**PR:** ${pr.id} — ${pr.title || ''}\n` +
     `**Reviewer:** ${config.agents[reviewerAgentId]?.name || reviewerAgentId}\n` +
@@ -1868,7 +1913,14 @@ function createReviewFeedbackForAuthor(reviewerAgentId, pr, config, opts = {}) {
     `## Action Required\n\nRead this feedback carefully. When you work on similar tasks in the future, ` +
     `avoid the patterns flagged here. If you are assigned to fix this PR, ` +
     `address every point raised above.\n`;
-  shared.safeWrite(feedbackPath, content);
+  shared.writeToInbox('feedback', `${authorAgentId}-from-${reviewerAgentId}-${prSlug}`, content, null, {
+    sourcePr: pr.id,
+    reviewer: reviewerAgentId,
+    author: authorAgentId,
+    dispatchId: opts.dispatchId || opts.dispatchItem?.id || opts.structuredCompletion?.dispatchId || null,
+    sourceItem: opts.sourceItem || opts.dispatchItem?.meta?.item?.id || null,
+    project: project?.name || null,
+  });
   log('info', `Created review feedback for ${authorAgentId} from ${reviewerAgentId} on ${pr.id}`);
 }
 
@@ -2235,6 +2287,33 @@ function reviewVerdictFromCompletion(completion) {
   return normalizeReviewVerdict(completion.verdict || completion.review_verdict || completion.reviewVerdict);
 }
 
+function reviewContentMatchesPr(content, pr, project) {
+  const text = String(content || '').trim();
+  if (!text) return false;
+  const targetId = shared.getCanonicalPrId(project, pr, pr?.url || '');
+  const targetNumber = shared.getPrNumber(pr);
+  if (!targetId) return true;
+
+  const explicitRefs = new Set();
+  for (const match of text.matchAll(/\b(?:github|ado):[A-Za-z0-9._~/-]+#\d+\b/g)) {
+    explicitRefs.add(shared.getCanonicalPrId(project, match[0]));
+  }
+  for (const match of text.matchAll(/https?:\/\/[^\s)>"]+(?:\/pull\/|\/pullrequest\/)\d+[^\s)>"]*/gi)) {
+    const url = match[0].replace(/[.,;:]+$/g, '');
+    explicitRefs.add(shared.getCanonicalPrId(project, url, url));
+  }
+  if (explicitRefs.size > 0) return explicitRefs.size === 1 && explicitRefs.has(targetId);
+
+  const mentionedNumbers = new Set();
+  for (const match of text.matchAll(/\bPR\s*(?:#|-)\s*(\d+)\b/gi)) {
+    mentionedNumbers.add(parseInt(match[1], 10));
+  }
+  if (mentionedNumbers.size > 0 && targetNumber != null) {
+    return mentionedNumbers.size === 1 && mentionedNumbers.has(targetNumber);
+  }
+  return true;
+}
+
 function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, exitCode) {
   if (!dispatchItem?.id || !outcome) {
     log('warn', 'Cannot write non-clean agent report without dispatch id and outcome');
@@ -2663,7 +2742,10 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // (retryCount was being deleted by done-marking before the check could read it)
   // Review verdict check similarly moved before updateWorkItemStatus(DONE) — same root cause.
 
-  if (type === WORK_TYPE.REVIEW && effectiveSuccess && !skipDoneStatus) {
+  const hardContractFail = completionContractFailure?.severity === 'hard'
+    || completionContractFailure?.nonTerminal === true;
+  const finalResult = hardContractFail ? DISPATCH_RESULT.ERROR : (effectiveSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR);
+  if (type === WORK_TYPE.REVIEW && finalResult === DISPATCH_RESULT.SUCCESS && !skipDoneStatus) {
     await updatePrAfterReview(agentId, meta?.pr, meta?.project, config, resultSummary, structuredCompletion, dispatchItem);
   } else if (type === WORK_TYPE.REVIEW) {
     log('warn', `Skipping PR review metadata update for ${meta?.pr?.id || meta?.pr?.url || '(unknown PR)'} because review dispatch ${dispatchItem.id} did not complete cleanly`);
@@ -2686,9 +2768,6 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     }
   }
   checkForLearnings(agentId, config.agents[agentId], dispatchItem.task);
-  const hardContractFail = completionContractFailure?.severity === 'hard'
-    || completionContractFailure?.nonTerminal === true;
-  const finalResult = hardContractFail ? DISPATCH_RESULT.ERROR : (effectiveSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR);
   if (finalResult === DISPATCH_RESULT.SUCCESS) {
     extractSkillsFromOutput(stdout, agentId, dispatchItem, config);
     // Also scan inbox notes for skill blocks — agents often write skills to inbox, not stdout

package/engine/scheduler.js

@@ -140,6 +140,42 @@ function shouldRunNow(schedule, lastRunAt) {
   return true;
 }
 
+function createScheduledWorkItem(sched) {
+  if (!sched || !sched.id || !sched.title) {
+    throw new Error('schedule id and title are required');
+  }
+  const workItemId = `sched-${sched.id}-${Date.now()}`;
+  return {
+    id: workItemId,
+    title: resolveScheduleTemplateVars(sched.title),
+    type: routing.normalizeWorkType(sched.type, WORK_TYPE.IMPLEMENT),
+    priority: sched.priority || 'medium',
+    description: resolveScheduleTemplateVars(sched.description || sched.title),
+    status: WI_STATUS.PENDING,
+    created: ts(),
+    createdBy: 'scheduler',
+    agent: sched.agent || null,
+    ...(sched.agentLock === true || sched.hardAgent === true ? { agentLock: true } : {}),
+    project: sched.project || null,
+    _scheduleId: sched.id,
+  };
+}
+
+function writeScheduleRunEntry(runs, scheduleId, workItemId) {
+  const existing = typeof runs[scheduleId] === 'object' && runs[scheduleId] ? runs[scheduleId] : {};
+  runs[scheduleId] = { ...existing, lastRun: ts(), lastWorkItemId: workItemId };
+  return runs[scheduleId];
+}
+
+function recordScheduleRun(scheduleId, workItemId) {
+  let entry = null;
+  mutateJsonFileLocked(SCHEDULE_RUNS_PATH, (runs) => {
+    entry = writeScheduleRunEntry(runs, scheduleId, workItemId);
+    return runs;
+  }, { defaultValue: {} });
+  return entry;
+}
+
 /**
  * Discover work items from configured schedules.
  * @param {object} config -- full config object
@@ -164,21 +200,8 @@ function discoverScheduledWork(config) {
       // Substitute schedule-time template vars (e.g. {{date}}) before the work
       // item is written — single-pass playbook rendering can't reach placeholders
       // embedded inside task_description, so they must be resolved up front.
-      const workItemId = `sched-${sched.id}-${Date.now()}`;
-      work.push({
-        id: workItemId,
-        title: resolveScheduleTemplateVars(sched.title),
-        type: routing.normalizeWorkType(sched.type, WORK_TYPE.IMPLEMENT),
-        priority: sched.priority || 'medium',
-        description: resolveScheduleTemplateVars(sched.description || sched.title),
-        status: WI_STATUS.PENDING,
-        created: ts(),
-        createdBy: 'scheduler',
-        agent: sched.agent || null,
-        ...(sched.agentLock === true || sched.hardAgent === true ? { agentLock: true } : {}),
-        project: sched.project || null,
-        _scheduleId: sched.id,
-      });
+      const workItem = createScheduledWorkItem(sched);
+      work.push(workItem);
 
       // Record run time AND work-item ID at dispatch time — preserve existing
       // completion fields (lastResult, lastCompletedAt). Writing lastWorkItemId
@@ -186,12 +209,20 @@ function discoverScheduledWork(config) {
       // the dispatched work item crashes or the engine restarts before
       // lifecycle.runPostCompletionHooks runs. This is the fix that closes
       // the double-fire window alongside the same-minute guard (W-mo3zu273f8tm).
-      const existing = typeof runs[sched.id] === 'object' && runs[sched.id] ? runs[sched.id] : {};
-      runs[sched.id] = { ...existing, lastRun: ts(), lastWorkItemId: workItemId };
+      writeScheduleRunEntry(runs, sched.id, workItem.id);
     }
   }, { defaultValue: {} });
 
   return work;
 }
 
-module.exports = { parseCronExpr, parseCronField, shouldRunNow, discoverScheduledWork, resolveScheduleTemplateVars, SCHEDULE_RUNS_PATH };
+module.exports = {
+  parseCronExpr,
+  parseCronField,
+  shouldRunNow,
+  discoverScheduledWork,
+  createScheduledWorkItem,
+  recordScheduleRun,
+  resolveScheduleTemplateVars,
+  SCHEDULE_RUNS_PATH,
+};

package/engine/shared.js

@@ -770,6 +770,7 @@ const ENGINE_DEFAULTS = {
   worktreeCreateRetries: 1, // retry once on transient timeout/lock races
   worktreeRoot: '../worktrees',
   worktreeCountCacheTtl: 30000, // 30s — TTL for cached _countWorktrees() result in dashboard
+  workItemCreateDedupWindowMs: 15 * 60 * 1000, // 15min — collapse duplicate CC/API create races
   idleAlertMinutes: 15,
   fanOutTimeout: null, // falls back to agentTimeout
   restartGracePeriod: 1200000, // 20min

package/package.json

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