@yemi33/minions 0.1.2170 → 0.1.2172

package/dashboard.js

@@ -5145,13 +5145,11 @@ const server = http.createServer(async (req, res) => {
         const wiPath = shared.projectWorkItemsPath(project);
         let existingVerify = null;
         mutateWorkItems(wiPath, items => {
-          const v = items.find(w => w.sourcePlan === body.file && w.itemType === 'verify');
-          if (v && (v.status === 'done' || v.status === 'failed')) {
-            v.status = 'pending';
-            delete v.completedAt;
-            delete v.dispatched_to;
-            delete v.dispatched_at;
-            v._retryCount = 0;
+          const v = items.find(w => w.sourcePlan === body.file && w.itemType === WORK_TYPE.VERIFY);
+          if (v && (v.status === WI_STATUS.DONE || v.status === WI_STATUS.FAILED)) {
+            // BUG-M10: use shared.reopenWorkItem so re-verify resets mirror
+            // every other re-dispatch path (also sets _reopened=true).
+            reopenWorkItem(v);
             existingVerify = v;
           } else if (v) {
             existingVerify = v;
@@ -5176,7 +5174,7 @@ const server = http.createServer(async (req, res) => {
       if (project) {
         const wiPath = shared.projectWorkItemsPath(project);
         const items = safeJsonArr(wiPath);
-        const verify = items.find(w => w.sourcePlan === body.file && w.itemType === 'verify');
+        const verify = items.find(w => w.sourcePlan === body.file && w.itemType === WORK_TYPE.VERIFY);
         if (verify) {
           invalidateStatusCache();
           invalidatePlansCache();
@@ -5901,7 +5899,7 @@ const server = http.createServer(async (req, res) => {
               if (body.description !== undefined) wi.description = body.description;
               if (body.priority !== undefined) wi.priority = body.priority;
               if (body.estimated_complexity !== undefined) {
-                wi.type = body.estimated_complexity === 'large' ? 'implement:large' : 'implement';
+                wi.type = body.estimated_complexity === 'large' ? WORK_TYPE.IMPLEMENT_LARGE : WORK_TYPE.IMPLEMENT;
               }
               workItemSynced = true;
             }

package/engine/ado.js

@@ -1044,7 +1044,12 @@ async function forEachActivePr(config, token, callback) {
         }
         // Remove duplicates — prefer merged/abandoned over active
         const bestById = new Map();
-        const statusRank = { merged: 3, abandoned: 2, closed: 2, active: 1 };
+        const statusRank = {
+          [PR_STATUS.MERGED]: 3,
+          [PR_STATUS.ABANDONED]: 2,
+          [PR_STATUS.CLOSED]: 2,
+          [PR_STATUS.ACTIVE]: 1,
+        };
         for (const p of currentPrs) {
           const existing = bestById.get(p.id);
           if (!existing || (statusRank[p.status] || 0) > (statusRank[existing.status] || 0)) {
@@ -2046,7 +2051,7 @@ async function reconcilePrs(config) {
             agent: (linkedItem?.dispatched_to || adoPr.createdBy?.displayName || 'unknown').toLowerCase(),
             branch,
             reviewStatus: REVIEW_STATUS.PENDING,
-            status: 'active',
+            status: PR_STATUS.ACTIVE,
             created: adoPr.creationDate || ts(),
             url: prUrl,
             prdItems: [],
@@ -2072,7 +2077,7 @@ async function reconcilePrs(config) {
         agent: (linkedItem?.dispatched_to || adoPr.createdBy?.displayName || 'unknown').toLowerCase(),
         branch,
         reviewStatus: REVIEW_STATUS.PENDING,
-        status: 'active',
+        status: PR_STATUS.ACTIVE,
         created: adoPr.creationDate || ts(),
         url: prUrl,
         prdItems: [confirmedItemId],

package/engine/github.js

@@ -252,6 +252,33 @@ async function _resolveViewerLogin(slug) {
   }
 }
 
+// OQ-Y (P-oqy-viewer-fail-closed) — Fail-closed counter for null
+// `_resolveViewerLogin` results. When the viewer login can't be resolved,
+// `_isMinionsAuthoredComment` cannot tell minions posts apart from human
+// posts (the `viewerDidAuthor` gate stays false for everything), so the
+// comment classifier reclassifies every minions comment as human and
+// queues a spurious fix dispatch on every poll cycle. The downstream
+// `check-self-authored-review-comment` skill no-ops the dispatch, so this
+// is a slot/token tax rather than state corruption — but the frequency
+// data is worth tracking so future audits can prioritize a deeper fix
+// (e.g. a credentialed re-probe of the gh CLI). Global counter under
+// `_engine.viewerLoginResolutionFailures`; surfaced through the existing
+// engine metrics aggregation (`getMetrics()` in `engine/queries.js`).
+function _incrementViewerLoginResolutionFailures() {
+  try {
+    const metricsPath = path.join(MINIONS_DIR, 'engine', 'metrics.json');
+    mutateJsonFileLocked(metricsPath, (metrics) => {
+      metrics = metrics || {};
+      if (!metrics._engine) metrics._engine = {};
+      metrics._engine.viewerLoginResolutionFailures =
+        (metrics._engine.viewerLoginResolutionFailures || 0) + 1;
+      return metrics;
+    });
+  } catch (err) {
+    log('warn', `telemetry: viewerLoginResolutionFailures metric write failed: ${err?.message || err}`);
+  }
+}
+
 // Test hook: lets tests prime or clear a cached viewer login per account
 // without shelling out. Pass `(account, null)` to force a re-resolve.
 // W-mp76pw7a001da7c1: signature changed from `(login)` → `(account, login)`
@@ -536,7 +563,12 @@ async function forEachActiveGhPr(config, callback) {
         }
         // Remove duplicates — prefer merged/abandoned over active
         const bestById = new Map();
-        const statusRank = { merged: 3, abandoned: 2, closed: 2, active: 1 };
+        const statusRank = {
+          [PR_STATUS.MERGED]: 3,
+          [PR_STATUS.ABANDONED]: 2,
+          [PR_STATUS.CLOSED]: 2,
+          [PR_STATUS.ACTIVE]: 1,
+        };
         for (const p of currentPrs) {
           const existing = bestById.get(p.id);
           if (!existing || (statusRank[p.status] || 0) > (statusRank[existing.status] || 0)) {
@@ -1111,6 +1143,21 @@ async function pollPrHumanComments(config) {
   // account pay only the first shell-out.
   const totalUpdated = await forEachActiveGhPr(config, async (project, pr, prNum, slug) => {
     const viewerLogin = await _resolveViewerLogin(slug);
+    // OQ-Y (P-oqy-viewer-fail-closed) — Fail-closed when the viewer login
+    // can't be resolved. `_isMinionsAuthoredComment` gates on
+    // `c.viewerDidAuthor === true`, and `_backfillViewerDidAuthor` is a
+    // no-op when viewerLogin is null. Running the classifier without a
+    // login mass-misclassifies every minions comment as human and queues
+    // a redundant fix dispatch on every poll cycle (the downstream
+    // `check-self-authored-review-comment` skill no-ops them, so this is
+    // a slot/token tax — see audit OQ-Y, HIGH not CRITICAL). Skip the
+    // entire round instead. One log + one counter increment per affected
+    // PR per cycle (no per-comment fanout).
+    if (!viewerLogin) {
+      log('warn', `GitHub PR comment poll: skipping comment classification for ${pr.id} (slug=${slug || '<no-slug>'}) — viewer login unresolved`);
+      _incrementViewerLoginResolutionFailures();
+      return false;
+    }
     // Get issue comments (general PR comments)
     const comments = await ghApi(`/issues/${prNum}/comments`, slug);
     if (!comments || !Array.isArray(comments)) return false;
@@ -1392,7 +1439,7 @@ async function reconcilePrs(config) {
             agent: (linkedItem?.dispatched_to || ghPr.user?.login || 'unknown').toLowerCase(),
             branch,
             reviewStatus: REVIEW_STATUS.PENDING,
-            status: 'active',
+            status: PR_STATUS.ACTIVE,
             created: ghPr.created_at || ts(),
             url: prUrl,
             prdItems: [],
@@ -1418,7 +1465,7 @@ async function reconcilePrs(config) {
         agent: (linkedItem?.dispatched_to || ghPr.user?.login || 'unknown').toLowerCase(),
         branch,
         reviewStatus: REVIEW_STATUS.PENDING,
-        status: 'active',
+        status: PR_STATUS.ACTIVE,
         created: ghPr.created_at || ts(),
         url: prUrl,
         prdItems: [confirmedItemId],
@@ -1854,6 +1901,7 @@ module.exports = {
   _resolveViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
   _setCachedViewerLogin, // exported for testing (W-mp3bp0ha000997ab-b backfill)
   _backfillViewerDidAuthor, // exported for testing (W-mp3bp0ha000997ab-b backfill)
+  _incrementViewerLoginResolutionFailures, // exported for testing (P-oqy-viewer-fail-closed)
   _setExecAsyncForTest, // W-mp5trwh60008386d: test seam to mock `gh api` shell-outs
   _setShellSafeGhForTest, // P-f2-gh-shell (F2): test seam to mock argv-form gh api calls
   _setGhApiForTest, // P-f1ghstale: test seam to mock ghApi call sites for stale-signal branch coverage

package/engine/lifecycle.js

@@ -199,7 +199,7 @@ function checkPlanCompletion(meta, config) {
         if (workItems.some(w => w.sourcePlan === planFile && w.itemType === 'pr')) return workItems;
         workItems.push({
           id, title: `Create PR for plan: ${plan.plan_summary || planFile}`,
-          type: 'implement', priority: 'high',
+          type: WORK_TYPE.IMPLEMENT, priority: 'high',
           description: `All plan items from \`${planFile}\` are complete on branch \`${featureBranch}\`.\n\n**Branch:** \`${featureBranch}\`\n**Target:** \`${mainBranch}\`\n\n## Completed Items\n${itemSummary}`,
           status: WI_STATUS.PENDING, created: ts(), createdBy: 'engine:plan-completion',
           sourcePlan: planFile, itemType: 'pr',
@@ -246,7 +246,7 @@ function checkPlanCompletion(meta, config) {
       // Per-project existing verify lookup. Legacy single-WI plans may have
       // existingVerify.project unset; match those against the primary project name.
       const existingVerify = allWorkItems.find(w =>
-        w.sourcePlan === planFile && w.itemType === 'verify' &&
+        w.sourcePlan === planFile && w.itemType === WORK_TYPE.VERIFY &&
         (w.project === projName || (!w.project && projName === primaryProject.name)));
 
       if (isActiveVerify(existingVerify)) {
@@ -389,7 +389,7 @@ function checkPlanCompletion(meta, config) {
       let created = false;
       mutateWorkItems(vWiPath, workItems => {
         // Re-check under lock to prevent races
-        if (workItems.some(w => w.sourcePlan === planFile && w.itemType === 'verify' && (w.project === projName || (!w.project && projName === primaryProject.name)))) {
+        if (workItems.some(w => w.sourcePlan === planFile && w.itemType === WORK_TYPE.VERIFY && (w.project === projName || (!w.project && projName === primaryProject.name)))) {
           return workItems;
         }
         workItems.push({
@@ -397,7 +397,7 @@ function checkPlanCompletion(meta, config) {
           title: touchedProjects.length > 1
             ? `Verify plan (${projName}): ${(plan.plan_summary || planFile).slice(0, 70)}`
             : `Verify plan: ${(plan.plan_summary || planFile).slice(0, 80)}`,
-          type: 'verify',
+          type: WORK_TYPE.VERIFY,
           priority: 'high',
           description,
           status: WI_STATUS.PENDING,
@@ -3137,7 +3137,7 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config, runtimeN
           data = data || [];
           if (data.some(i => i.title === `Add skill: ${name}` && i.status !== WI_STATUS.FAILED)) return data;
           skillId = `SK${String(data.filter(i => i.id?.startsWith('SK')).length + 1).padStart(3, '0')}`;
-          data.push({ id: skillId, type: 'implement', title: `Add skill: ${name}`,
+          data.push({ id: skillId, type: WORK_TYPE.IMPLEMENT, title: `Add skill: ${name}`,
             description: `Create project-level skill \`${skillDirName}/SKILL.md\` in ${project}.\n\nWrite this file to \`${projectSkillPath}\` via a PR.\n\n## Skill Content\n\n\`\`\`\n${enrichedBlock}\n\`\`\``,
             priority: 'low', status: WI_STATUS.QUEUED, created: ts(), createdBy: `engine:skill-extraction:${agentName}` });
           return data;
@@ -4367,7 +4367,7 @@ function handleDecompositionResult(stdout, meta, config, runtimeName) {
         const childItem = {
           id: sub.id,
           title: sub.name || sub.title || `Sub-task of ${parentId}`,
-          type: (sub.estimated_complexity === 'large') ? 'implement:large' : 'implement',
+          type: (sub.estimated_complexity === 'large') ? WORK_TYPE.IMPLEMENT_LARGE : WORK_TYPE.IMPLEMENT,
           priority: sub.priority || p.priority || 'medium',
           description: sub.description || '',
           status: WI_STATUS.PENDING,

package/engine/playbook.js

@@ -755,7 +755,7 @@ function renderPlaybook(type, vars) {
           // type === 'review' keeps PR-82 header copy + meta.review.* outcome
           // guidance; everything else uses the generic header that points at
           // meta.skill.* in the completion report.
-          projectSkillsBlock = (type === 'review')
+          projectSkillsBlock = (type === WORK_TYPE.REVIEW)
             ? discover.renderReviewSkillsBlock(filtered)
             : discover.renderProjectSkillsBlock(filtered);
         }
@@ -1195,7 +1195,7 @@ function buildPrDispatch(agentId, config, project, pr, type, extraVars, taskLabe
     ...extraVars,
     task_id: dispatchId,
   };
-  const playbookName = type === 'test' ? 'build-and-test' : (type === 'review' ? 'review' : 'fix');
+  const playbookName = type === WORK_TYPE.TEST ? 'build-and-test' : (type === WORK_TYPE.REVIEW ? 'review' : 'fix');
   const prompt = renderPlaybook(playbookName, vars);
   if (!prompt) return null;
   return {

package/engine/queries.js

@@ -13,7 +13,7 @@ const steering = require('./steering');
 
 const { safeRead, safeReadDir, safeJson, safeWrite, getProjects, mutateJsonFileLocked,
   projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
-  WI_STATUS, DONE_STATUSES, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS } = shared;
+  WI_STATUS, DONE_STATUSES, WORK_TYPE, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS } = shared;
 
 // ─── Defensive PR enrichment cache (W-mq5uzmc6001d708f) ──────────────────────
 //
@@ -438,7 +438,12 @@ function getMetrics() {
     if (!agent || agent.startsWith('temp-')) continue;
     prCountByAgent[agent] = (prCountByAgent[agent] || 0) + 1;
     if (pr.reviewStatus === shared.REVIEW_STATUS.APPROVED || pr.status === shared.PR_STATUS.MERGED) prApprovedByAgent[agent] = (prApprovedByAgent[agent] || 0) + 1;
-    if (pr.reviewStatus === 'rejected') prRejectedByAgent[agent] = (prRejectedByAgent[agent] || 0) + 1;
+    // BUG-H13 / P-h13-rejected: this used to compare to the literal 'rejected',
+    // which never appears in pull-requests.json — the canonical enum value is
+    // REVIEW_STATUS.CHANGES_REQUESTED ('changes-requested'). The miscompare
+    // permanently zeroed prRejectedByAgent, and the snapshot then clobbered
+    // shared.trackReviewMetric()'s cumulative counter at the apply step below.
+    if (pr.reviewStatus === shared.REVIEW_STATUS.CHANGES_REQUESTED) prRejectedByAgent[agent] = (prRejectedByAgent[agent] || 0) + 1;
   }
 
   // Enrich agent runtime from completed dispatch entries
@@ -466,7 +471,14 @@ function getMetrics() {
     if (prCountByAgent[lower] !== undefined) {
       m.prsCreated = prCountByAgent[lower];
       m.prsApproved = prApprovedByAgent[lower] || 0;
-      m.prsRejected = prRejectedByAgent[lower] || 0;
+      // BUG-H13: shared.trackReviewMetric() increments prsRejected on every
+      // approved→changes-requested transition (cumulative, never decremented),
+      // while the snapshot bucket above is a point-in-time count of PRs still
+      // sitting at changes-requested. The two measure different things — a PR
+      // that was rejected once and then re-approved is gone from the snapshot
+      // but still counted in the transition tracker. Take the max so the
+      // snapshot enrichment cannot shadow a strictly larger history value.
+      m.prsRejected = Math.max(m.prsRejected || 0, prRejectedByAgent[lower] || 0);
     }
     if (runtimeByAgent[agentId]) {
       // Use dispatch history as source of truth — it has full history
@@ -1338,7 +1350,7 @@ function getWorkItems(config) {
   const dispatch = getDispatch();
   const activeByWiId = new Map((dispatch.active || []).map(d => [d.meta?.item?.id, d.agent]));
   for (const item of allItems) {
-    if (item.status === 'dispatched' && !item.dispatched_to && !item.agent) {
+    if (item.status === WI_STATUS.DISPATCHED && !item.dispatched_to && !item.agent) {
       const activeAgent = activeByWiId.get(item.id);
       if (activeAgent) item.dispatched_to = activeAgent;
     }
@@ -1666,7 +1678,7 @@ function getPrdInfo(config) {
     // resolves to, not raw itemIds.length: a PRD item + sibling review-followup
     // sub-WIs all resolve to one PRD item and must still render. (W-mpem52qn)
     const distinctPrdCount = countDistinctPrdItems(itemIds).size;
-    if (distinctPrdCount > 1 || pr?.itemType === 'verify' || pr?.title?.startsWith('[E2E]')) continue;
+    if (distinctPrdCount > 1 || pr?.itemType === WORK_TYPE.VERIFY || pr?.title?.startsWith('[E2E]')) continue;
     const url = buildPrUrlFromId(prId, pr, projects);
     for (const itemId of (itemIds || [])) {
       if (!prdToPr[itemId]) prdToPr[itemId] = [];

package/engine/scheduler.js

@@ -30,23 +30,167 @@ const { safeJson, safeWrite, mutateJsonFileLocked, mutateScheduleRuns, ts, dateS
 
 const SCHEDULE_RUNS_PATH = path.join(shared.MINIONS_DIR, 'engine', 'schedule-runs.json');
 
+/**
+ * Compute the ISO 8601 week of the year for `date` as `YYYY-Www` (e.g.
+ * 2026-W23). Uses the standard ISO algorithm: Thursday of the target week
+ * determines its calendar year; week 1 contains the first Thursday of the
+ * year. UTC-based so the value lines up with dateStamp().
+ */
+function isoWeek(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  // Day of week: Sunday=0..Saturday=6 → ISO Monday=1..Sunday=7.
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum); // shift to Thursday of this week
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNum = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+  return `${d.getUTCFullYear()}-W${String(weekNum).padStart(2, '0')}`;
+}
+
+/**
+ * Build the standard schedule-time template-var map. Vars are values that are
+ * KNOWN at schedule firing time (date, week, time, etc.) — not values that
+ * only become available later in the dispatch pipeline (project_name,
+ * branch_name, agent_id, etc.). Those still resolve in renderPlaybook.
+ *
+ * Caller-supplied `extraVars` override the time-based defaults so test
+ * harnesses can pin a specific date and so future callers can pass extras
+ * like `schedule_id`.
+ */
+function buildScheduleTemplateVars(extraVars) {
+  const now = new Date();
+  const iso = now.toISOString();
+  const vars = {
+    date: dateStamp(),               // 2026-06-11
+    year: iso.slice(0, 4),           // 2026
+    month: iso.slice(5, 7),          // 06
+    day: iso.slice(8, 10),           // 11
+    time: iso.slice(11, 16),         // HH:MM (UTC)
+    datetime: iso,                   // 2026-06-11T01:23:45.678Z
+    week: isoWeek(now),              // 2026-W24
+  };
+  if (extraVars && typeof extraVars === 'object') {
+    for (const [k, v] of Object.entries(extraVars)) {
+      if (v === undefined || v === null) continue;
+      vars[k] = String(v);
+    }
+  }
+  return vars;
+}
+
 /**
  * Substitute schedule-time template variables in a string.
- * Currently supports:
- *   {{date}} — today's date as YYYY-MM-DD (UTC, via dateStamp())
+ *
+ * Supported vars (BUG-H8 + BUG-H9 expansion of the original `{{date}}`-only
+ * helper):
+ *   {{date}}     — today's date as YYYY-MM-DD (UTC, via dateStamp())
+ *   {{year}}     — UTC year as YYYY
+ *   {{month}}    — UTC month as MM (zero-padded)
+ *   {{day}}      — UTC day of month as DD (zero-padded)
+ *   {{time}}     — UTC time as HH:MM
+ *   {{datetime}} — full ISO timestamp (UTC, ms precision)
+ *   {{week}}     — ISO 8601 week as YYYY-Www (UTC)
+ *
+ * Plus any caller-supplied `extraVars` (string-coerced). Callers should only
+ * pass vars known at schedule time — pipeline-time vars like {{project_name}}
+ * stay in engine/playbook.js where the dispatch context is available.
  *
  * Downstream playbook rendering (engine/playbook.js) is a single-pass replace,
- * so any {{date}} embedded in a schedule's title/description would survive
+ * so any {{var}} embedded in a schedule's title/description would survive
  * substitution of {{task_description}} and surface as an "unresolved template
- * variables: date" warning plus a literal "{{date}}" in agent filenames.
- * Resolve these fields at schedule time so the work item carries a concrete
- * date string from the moment it's created.
+ * variables: var" warning plus a literal "{{var}}" in agent filenames.
+ * Resolve these fields at schedule time so the work item carries concrete
+ * strings from the moment it's created.
+ *
+ * Unknown placeholders are left intact (renderPlaybook still warns on them).
  *
  * Safe on undefined/null/empty/non-string inputs — returns the input unchanged.
+ *
+ * @param {*} str
+ * @param {object} [extraVars] optional caller-supplied vars (e.g. { schedule_id }).
+ *                             Can also be a pre-built var map from
+ *                             buildScheduleTemplateVars() to share one
+ *                             "now" snapshot across a recursive walk.
  */
-function resolveScheduleTemplateVars(str) {
+function resolveScheduleTemplateVars(str, extraVars) {
   if (typeof str !== 'string' || str.length === 0) return str;
-  return str.replace(/\{\{date\}\}/g, dateStamp());
+  if (str.indexOf('{{') === -1) return str;
+  const vars = (extraVars && extraVars.__scheduleVars) ? extraVars : buildScheduleTemplateVars(extraVars);
+  return str.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return Object.prototype.hasOwnProperty.call(vars, key) ? vars[key] : match;
+  });
+}
+
+/**
+ * Recursively walk `obj` and substitute schedule-time template variables in
+ * every string-valued field in place. Returns `obj`.
+ *
+ * Walks own enumerable properties of plain objects and the items of plain
+ * arrays. Strings are replaced via resolveScheduleTemplateVars; null,
+ * primitives, Dates, RegExps, Buffers, Maps, Sets, functions, and any
+ * value with a custom prototype are left untouched.
+ *
+ * Cycle-safe: tracks visited objects so a self-referencing work-item field
+ * won't infinite-loop.
+ *
+ * Why a recursive walker exists (BUG-H8 + BUG-H9): scheduler's original fix
+ * only substituted `title` / `description` / `harness_rubric`. Other vars
+ * embedded in nested fields (e.g. `_harness.rubric`, `metadata.notes`,
+ * `references[].url`) survive untouched and surface as unresolved-template
+ * warnings or literal `{{var}}` strings in agent filenames. Apply this to
+ * each work item the scheduler hands off to dispatch.
+ *
+ * @param {*} obj  work item or nested object/array to walk in place
+ * @param {object} [extraVars] optional caller-supplied vars passed through to
+ *                             resolveScheduleTemplateVars. A single var snapshot
+ *                             is taken at the top of the walk so every field
+ *                             sees the same "now".
+ */
+function applyScheduleTemplateVarsRecursive(obj, extraVars) {
+  if (obj === null || typeof obj !== 'object') return obj;
+  // Take one snapshot of the var map so every field in the same walk sees
+  // an identical "now". Flag-mark it so resolveScheduleTemplateVars reuses
+  // it instead of rebuilding per call.
+  const vars = buildScheduleTemplateVars(extraVars);
+  Object.defineProperty(vars, '__scheduleVars', { value: true, enumerable: false });
+  const seen = new WeakSet();
+
+  function walk(node) {
+    if (node === null || typeof node !== 'object') return;
+    if (seen.has(node)) return;
+    seen.add(node);
+
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        const v = node[i];
+        if (typeof v === 'string') {
+          node[i] = resolveScheduleTemplateVars(v, vars);
+        } else if (v !== null && typeof v === 'object') {
+          // Only recurse into plain objects/arrays — leave Date, Buffer, etc. alone.
+          const proto = Object.getPrototypeOf(v);
+          if (proto === Object.prototype || proto === Array.prototype || proto === null) {
+            walk(v);
+          }
+        }
+      }
+      return;
+    }
+
+    // Plain object: walk own enumerable string-keyed props.
+    for (const key of Object.keys(node)) {
+      const v = node[key];
+      if (typeof v === 'string') {
+        node[key] = resolveScheduleTemplateVars(v, vars);
+      } else if (v !== null && typeof v === 'object') {
+        const proto = Object.getPrototypeOf(v);
+        if (proto === Object.prototype || proto === Array.prototype || proto === null) {
+          walk(v);
+        }
+      }
+    }
+  }
+
+  walk(obj);
+  return obj;
 }
 
 // Parse a single cron field into a matcher function.
@@ -171,12 +315,12 @@ function createScheduledWorkItem(sched) {
     throw new Error('schedule id and title are required');
   }
   const workItemId = `sched-${sched.id}-${Date.now()}`;
-  return {
+  const workItem = {
     id: workItemId,
-    title: resolveScheduleTemplateVars(sched.title),
+    title: sched.title,
     type: routing.normalizeWorkType(sched.type, WORK_TYPE.IMPLEMENT),
     priority: sched.priority || 'medium',
-    description: resolveScheduleTemplateVars(sched.description || sched.title),
+    description: sched.description || sched.title,
     status: WI_STATUS.PENDING,
     created: ts(),
     createdBy: 'scheduler',
@@ -185,6 +329,12 @@ function createScheduledWorkItem(sched) {
     project: sched.project || null,
     _scheduleId: sched.id,
   };
+  // Walk every string-valued field on the work item so vars embedded in
+  // nested fields (e.g. _harness.rubric added by callers, references[].url,
+  // ad-hoc metadata) all resolve before dispatch — not just title/description.
+  // Single-pass renderPlaybook can't reach into nested fields via
+  // {{task_description}} expansion (BUG-H8 + BUG-H9).
+  return applyScheduleTemplateVarsRecursive(workItem, { schedule_id: sched.id });
 }
 
 function writeScheduleRunEntry(runs, scheduleId, workItemId, extra) {
@@ -235,17 +385,26 @@ function discoverScheduledWork(config) {
           continue;
         }
         try {
-          // Resolve schedule-time template variables on the title/description
-          // BEFORE handing the schedule to the harness builder so subtask
-          // prompts inherit the same substitutions as regular schedules.
-          const resolvedSched = {
-            ...sched,
-            title: resolveScheduleTemplateVars(sched.title),
-            description: resolveScheduleTemplateVars(sched.description || sched.title),
-            harness_rubric: resolveScheduleTemplateVars(sched.harness_rubric),
-          };
+          // Resolve schedule-time template variables on the schedule fields
+          // BEFORE handing them to the harness builder so subtask prompts
+          // inherit the same substitutions. The recursive walker catches any
+          // string field — not just title / description / harness_rubric —
+          // so e.g. caller-added metadata also resolves (BUG-H8 + BUG-H9).
+          const resolvedSched = applyScheduleTemplateVarsRecursive(
+            { ...sched },
+            { schedule_id: sched.id },
+          );
+          if (typeof resolvedSched.description !== 'string' || resolvedSched.description.length === 0) {
+            resolvedSched.description = resolvedSched.title;
+          }
           const mission = harness.createTriAgentMission(resolvedSched);
-          for (const it of mission.items) work.push(it);
+          // Walk each generated harness work item too — _harness.rubric and
+          // other nested fields can carry surviving placeholders that the
+          // resolved-schedule step above doesn't reach.
+          for (const it of mission.items) {
+            applyScheduleTemplateVarsRecursive(it, { schedule_id: sched.id });
+            work.push(it);
+          }
           // Record the mission's planner id as lastWorkItemId for compatibility
           // with the existing schedule-runs shape, plus lastMissionId so the
           // dashboard and consolidation tooling can join across the trio.
@@ -288,5 +447,7 @@ module.exports = {
   recordScheduleRun,
   writeScheduleRunEntry,
   resolveScheduleTemplateVars,
+  applyScheduleTemplateVarsRecursive,
+  buildScheduleTemplateVars,
   SCHEDULE_RUNS_PATH,
 };

package/engine/shared.js

@@ -3629,13 +3629,13 @@ function mutateMetrics(mutator) {
 
 /** Update per-agent review metrics (prsApproved/prsRejected). Only writes for configured agents. */
 function trackReviewMetric(pr, newReviewStatus, config) {
-  if (newReviewStatus !== 'approved' && newReviewStatus !== 'changes-requested') return;
+  if (newReviewStatus !== REVIEW_STATUS.APPROVED && newReviewStatus !== REVIEW_STATUS.CHANGES_REQUESTED) return;
   const authorId = (pr.agent || '').toLowerCase();
   if (!authorId || !config?.agents?.[authorId]) return;
   try {
     mutateMetrics((metrics) => {
       if (!metrics[authorId]) metrics[authorId] = { ...DEFAULT_AGENT_METRICS };
-      if (newReviewStatus === 'approved') metrics[authorId].prsApproved = (metrics[authorId].prsApproved || 0) + 1;
+      if (newReviewStatus === REVIEW_STATUS.APPROVED) metrics[authorId].prsApproved = (metrics[authorId].prsApproved || 0) + 1;
       else metrics[authorId].prsRejected = (metrics[authorId].prsRejected || 0) + 1;
       return metrics;
     });
@@ -3659,7 +3659,7 @@ function queuePlanToPrd({ planFile, prdFile, title, description, project, create
   let item = null;
   mutateJsonFileLocked(centralWiPath, items => {
     if (!Array.isArray(items)) items = [];
-    const existing = items.find(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === planFile && (w.status === 'pending' || w.status === 'dispatched'));
+    const existing = items.find(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === planFile && (w.status === WI_STATUS.PENDING || w.status === WI_STATUS.DISPATCHED));
     if (existing) {
       id = existing.id;
       item = existing;
@@ -3671,7 +3671,7 @@ function queuePlanToPrd({ planFile, prdFile, title, description, project, create
       type: WORK_TYPE.PLAN_TO_PRD,
       priority: 'high',
       description,
-      status: 'pending',
+      status: WI_STATUS.PENDING,
       created: new Date().toISOString(),
       createdBy,
       project,

package/engine/watch-actions.js

@@ -26,6 +26,7 @@ const path = require('path');
 const fs = require('fs');
 const http = require('http');
 const https = require('https');
+const crypto = require('crypto');
 const { URL } = require('url');
 
 const shared = require('./shared');
@@ -33,6 +34,44 @@ const {
   WATCH_ACTION_TYPE, WI_STATUS, WORK_TYPE, DONE_STATUSES, PLAN_STATUS,
   log, ts, uid, mutateWorkItems, mutateJsonFileLocked, projectWorkItemsPath,
 } = shared;
+
+// BUG-H10 (P-h10-watch-flood): statuses that mean the dispatched WI is still
+// "live" — pending or in-flight — and should block a second dispatch for the
+// same watch+target+condition+action identity. Terminal statuses (done,
+// failed, cancelled, decomposed) DO NOT block; if the previous attempt
+// terminated, a retrigger is allowed to fire fresh work.
+const WATCH_DEDUP_ACTIVE_STATUSES = new Set([
+  WI_STATUS.PENDING,
+  WI_STATUS.DISPATCHED,
+  WI_STATUS.QUEUED,
+  WI_STATUS.PAUSED,
+]);
+
+// BUG-H10 — derive a deterministic dedup key for a dispatched-work-item action
+// invocation. Inputs are the stable identity of the trigger (watchId + target
+// + condition) plus the resolved WI shape (title/type/project/agent). The key
+// must NOT include Date.now()/uid()/triggerCount so the same logical work
+// produces the same key across ticks and engine restarts.
+//
+// Stored on the dispatched WI under `meta._watchDedupKey`; engine/watch-actions.js
+// scans existing pending+active WIs and skips the push if a match is found.
+function computeWatchDedupKey(watch, dispatchedItemShape) {
+  const stable = {
+    target: watch && watch.target != null ? String(watch.target) : '',
+    targetType: watch && watch.targetType != null ? String(watch.targetType) : '',
+    condition: watch && watch.condition != null ? String(watch.condition) : '',
+    title: dispatchedItemShape.title || '',
+    type: dispatchedItemShape.type || '',
+    project: dispatchedItemShape.project || '',
+    agent: dispatchedItemShape.agent || '',
+  };
+  const hash = crypto.createHash('sha256')
+    .update(JSON.stringify(stable))
+    .digest('hex')
+    .slice(0, 16);
+  const watchId = (watch && watch.id) ? String(watch.id) : 'unknown';
+  return `${watchId}-${hash}`;
+}
 // P-w7c5d8b3 — Phase 3.2: optional guard expressions on action steps.
 // safe-expr.evaluate() never throws and returns Boolean(...) on success or
 // `false` on parse/eval errors (with a `[safe-expr]` warn). That contract
@@ -384,11 +423,42 @@ registerActionType(WATCH_ACTION_TYPE.DISPATCH_WORK_ITEM, {
     if (project) item.project = project;
     if (p.agent) item.agent = String(p.agent);
 
+    // BUG-H10 — derive a stable dedup key (no Date.now/uid) and stamp it on
+    // meta._watchDedupKey so the in-mutator scan below can compare. A
+    // persistent watch condition (e.g. stuck-in-stage holding true for an
+    // hour at 1-tick-per-minute) would otherwise mint ~60 duplicate WIs.
+    const dedupKey = computeWatchDedupKey(watch, {
+      title,
+      type: item.type,
+      project,
+      agent: item.agent,
+    });
+    item.meta = Object.assign({}, item.meta, { _watchDedupKey: dedupKey });
+
     let appended = false;
+    let dedupedAgainstId = null;
     mutateWorkItems(wiPath, (items) => {
+      const existing = items.find(it =>
+        it
+        && it.meta
+        && it.meta._watchDedupKey === dedupKey
+        && WATCH_DEDUP_ACTIVE_STATUSES.has(it.status));
+      if (existing) {
+        dedupedAgainstId = existing.id;
+        return items;
+      }
       items.push(item);
       appended = true;
     });
+    if (dedupedAgainstId) {
+      log('info', `Watch ${watch.id} dispatch-work-item deduped against existing WI ${dedupedAgainstId} (key=${dedupKey})`);
+      return {
+        ok: true,
+        summary: `deduped against existing work item ${dedupedAgainstId}`,
+        dispatchedItemId: dedupedAgainstId,
+        deduped: true,
+      };
+    }
     if (!appended) return { ok: false, summary: 'dispatch-work-item: write failed' };
     log('info', `Watch ${watch.id} dispatched work item ${id} (${title})`);
     return { ok: true, summary: `dispatched work item ${id}`, dispatchedItemId: id };
@@ -1117,5 +1187,7 @@ module.exports = {
   buildTriggerContext,
   substituteTemplate,
   validateAction,
+  computeWatchDedupKey, // exported for testing (BUG-H10)
+  WATCH_DEDUP_ACTIVE_STATUSES, // exported for testing (BUG-H10)
   _ACTION_TYPES: ACTION_TYPES, // exported for testing
 };

package/engine/watches.js

@@ -722,7 +722,7 @@ registerTargetType(WATCH_TARGET_TYPE.PR, {
   evaluate: (condition, pr, prevState, target) => {
     switch (condition) {
       case WATCH_CONDITION.MERGED:
-        return { triggered: pr.status === 'merged', message: pr.status === 'merged' ? `PR ${target} was merged` : '' };
+        return { triggered: pr.status === shared.PR_STATUS.MERGED, message: pr.status === shared.PR_STATUS.MERGED ? `PR ${target} was merged` : '' };
       case WATCH_CONDITION.BUILD_FAIL:
         return { triggered: pr.buildStatus === shared.BUILD_STATUS.FAILING, message: pr.buildStatus === shared.BUILD_STATUS.FAILING ? `PR ${target} build is failing` : '' };
       case WATCH_CONDITION.BUILD_PASS:
@@ -910,7 +910,7 @@ registerTargetType(WATCH_TARGET_TYPE.WORK_ITEM, {
 });
 
 // Meeting — concluded (terminal status) / status-change / any
-const MEETING_TERMINAL = new Set(['completed', 'archived']);
+const MEETING_TERMINAL = new Set([shared.MEETING_STATUS.COMPLETED, shared.MEETING_STATUS.ARCHIVED]);
 registerTargetType(WATCH_TARGET_TYPE.MEETING, {
   label: 'Meeting',
   description: 'Watch a meeting for conclusion or status changes',
@@ -1123,7 +1123,7 @@ function _completedStageCount(run) {
   let n = 0;
   for (const st of Object.values(run.stages)) {
     const s = String((st && st.status) || '').toLowerCase();
-    if (s === 'completed' || s === 'failed' || s === 'stopped') n += 1;
+    if (s === shared.PIPELINE_STATUS.COMPLETED || s === shared.PIPELINE_STATUS.FAILED || s === shared.PIPELINE_STATUS.STOPPED) n += 1;
   }
   return n;
 }
@@ -1131,7 +1131,7 @@ function _completedStageCount(run) {
 // in run.stages iteration order. run.stages is built from pipeline.stages
 // in declaration order (engine/pipeline.js startRun ~line 84) so the first
 // non-terminal entry is the currently-executing or next-pending stage.
-const _PIPELINE_TERMINAL = new Set(['completed', 'failed', 'stopped']);
+const _PIPELINE_TERMINAL = new Set([shared.PIPELINE_STATUS.COMPLETED, shared.PIPELINE_STATUS.FAILED, shared.PIPELINE_STATUS.STOPPED]);
 function _currentPipelineStageId(run) {
   if (!run || !run.stages || typeof run.stages !== 'object') return null;
   for (const [stageId, st] of Object.entries(run.stages)) {
@@ -1237,7 +1237,7 @@ function _findDispatchEntry(target, state) {
   }
   return null;
 }
-const DISPATCH_TERMINAL = new Set(['done', 'completed', 'failed', 'cancelled']);
+const DISPATCH_TERMINAL = new Set([shared.WI_STATUS.DONE, shared.PIPELINE_STATUS.COMPLETED, shared.WI_STATUS.FAILED, shared.WI_STATUS.CANCELLED]);
 registerTargetType(WATCH_TARGET_TYPE.DISPATCH, {
   label: 'Dispatch',
   description: 'Watch a dispatch entry for terminal status or status changes',

package/engine.js

@@ -31,7 +31,7 @@ const path = require('path');
 const crypto = require('crypto');
 const shared = require('./engine/shared');
 const { exec, execAsync, execSilent, runFile, ts, ENGINE_DEFAULTS,
-  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, DISPATCH_RESULT, AGENT_STATUS,
+  WI_STATUS, DONE_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, REVIEW_STATUS, DISPATCH_RESULT, AGENT_STATUS,
   FAILURE_CLASS } = shared;
 const { resolveRuntime } = require('./engine/runtimes');
 const { assertStaleHeadOk } = require('./engine/spawn-agent');
@@ -1734,10 +1734,16 @@ async function spawnAgent(dispatchItem, config) {
   // (dispatch.js, meeting.js, cli.js, cleanup.js, timeout.js) can find the
   // dir via shared.dispatchPidCandidates / findDispatchPidFile. Best-effort —
   // backward-compat fallbacks still scan dispatch-<safeId>-* dirs by id.
+  //
+  // W-mq9b7lor (H1): must route through mutateDispatch (SQL writer) — a direct
+  // mutateJsonFileLocked on engine/dispatch.json is dropped on the next
+  // mutateDispatch call because engine/dispatch.js#mutateDispatch regenerates
+  // dispatch.json from SQL after every successful mutation (see
+  // engine/dispatch.js:98-101). Without the SQL write, the tmpDir pointer is
+  // lost and orphan-reap/kill/cleanup paths can't find the prompt directory.
   try {
     dispatchItem.tmpDir = dispatchTmpDir;
-    const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
-    mutateJsonFileLocked(dispatchPath, (dispatch) => {
+    mutateDispatch((dispatch) => {
       for (const queue of ['pending', 'active', 'completed']) {
         const arr = Array.isArray(dispatch?.[queue]) ? dispatch[queue] : null;
         if (!arr) continue;
@@ -1745,7 +1751,7 @@ async function spawnAgent(dispatchItem, config) {
         if (found) found.tmpDir = dispatchTmpDir;
       }
       return dispatch;
-    }, { defaultValue: { pending: [], active: [], completed: [] } });
+    });
   } catch (e) { log('warn', `spawnAgent: failed to persist tmpDir for ${id}: ${e.message}`); }
   const _cleanupPromptFiles = () => { shared.removeDispatchTmpDir(dispatchTmpDir); };
   // Convert a WORKTREE_NESTED_IN_PROJECT throw into a fail-fast non-retryable
@@ -4787,15 +4793,39 @@ function materializePlansAsWorkItems(config) {
     if (desiredFileName && desiredFileName.toLowerCase() !== String(fileName).toLowerCase()) {
       const fromPath = path.join(PRD_DIR, fileName);
       const desiredPath = shared.sanitizePath(desiredFileName, PRD_DIR);
-      const toPath = shared.uniquePath(desiredPath);
-      try {
-        fs.renameSync(fromPath, toPath);
-        nextFileName = path.basename(toPath);
-        const migrated = migratePrdFilenameReferences(fileName, nextFileName);
-        if (migrated > 0) log('info', `Plan project enforcement: migrated ${migrated} PRD reference(s) from ${fileName} to ${nextFileName}`);
-        changed = true;
-      } catch (e) {
-        log('warn', `Plan project enforcement: could not rename ${fileName} to ${path.basename(toPath)}: ${e.message}`);
+      // W-mq8qdai6 — refuse to rename into a name owned by an archived PRD.
+      // `shared.uniquePath` only scans the live `prd/` directory; without this
+      // guard, an archived PRD with the canonical "<project>-<date>.json" name
+      // would silently collide with the rename target. The dashboard joins
+      // work items to PRDs by basename (sourcePlan === <prd filename>), so a
+      // live↔archive name collision bleeds the archived PRD's done items,
+      // verify task, and PRs into the live PRD's view (the bug-fix-plan vs
+      // minions-opg-2026-06-10 incident).
+      const archiveBasenames = new Set(
+        safeReadDir(path.join(PRD_DIR, 'archive'))
+          .filter(f => f.endsWith('.json'))
+          .map(f => f.toLowerCase())
+      );
+      if (archiveBasenames.has(desiredFileName.toLowerCase())) {
+        log('warn', `Plan project enforcement: skipping rename of ${fileName} to ${desiredFileName} — would collide with archived PRD`);
+      } else {
+        const toPath = shared.uniquePath(desiredPath);
+        const toBasename = path.basename(toPath);
+        if (archiveBasenames.has(toBasename.toLowerCase())) {
+          // uniquePath bumped past a live conflict (e.g. <name>-2.json) but
+          // the bumped name itself is owned by an archived PRD — same risk.
+          log('warn', `Plan project enforcement: skipping rename of ${fileName} to ${toBasename} — would collide with archived PRD`);
+        } else {
+          try {
+            fs.renameSync(fromPath, toPath);
+            nextFileName = toBasename;
+            const migrated = migratePrdFilenameReferences(fileName, nextFileName);
+            if (migrated > 0) log('info', `Plan project enforcement: migrated ${migrated} PRD reference(s) from ${fileName} to ${nextFileName}`);
+            changed = true;
+          } catch (e) {
+            log('warn', `Plan project enforcement: could not rename ${fileName} to ${toBasename}: ${e.message}`);
+          }
+        }
       }
     }
     if (changed) log('info', `Plan project enforcement: preserved declared project "${declaredProject}" for ${nextFileName}`);
@@ -5492,11 +5522,11 @@ async function discoverFromPrs(config, project) {
     const prNumber = shared.getPrNumber(pr);
     // Use reviewStatus as single source of truth (synced from ADO/GitHub votes)
     // minionsReview tracks metadata (reviewer, note) but not the authoritative status
-    const reviewStatus = pr.reviewStatus || 'pending';
+    const reviewStatus = pr.reviewStatus || REVIEW_STATUS.PENDING;
 
     // Skip fix dispatch if a fix was recently submitted and awaiting re-review.
     // The poller holds reviewStatus at 'waiting' until the reviewer acts on the new code.
-    const awaitingReReview = reviewStatus === 'waiting' && !!pr.minionsReview?.fixedAt;
+    const awaitingReReview = reviewStatus === REVIEW_STATUS.WAITING && !!pr.minionsReview?.fixedAt;
 
     // F8 (P-f8firstdispatch): hoisted above the first-review block so a
     // successful initial-review dispatch suppresses downstream fix dispatches
@@ -5509,7 +5539,7 @@ async function discoverFromPrs(config, project) {
     const reviewEnabled = evalLoopEnabled && pollEnabled && autoReviewPrs;
     const reReviewEnabled = evalLoopEnabled && pollEnabled && autoReReviewPrs;
     const alreadyReviewed = pr.lastReviewedAt && (!pr.lastPushedAt || pr.lastPushedAt <= pr.lastReviewedAt);
-    const needsReview = reviewEnabled && reviewStatus === 'pending' && !alreadyReviewed;
+    const needsReview = reviewEnabled && reviewStatus === REVIEW_STATUS.PENDING && !alreadyReviewed;
     if (needsReview) {
       const key = getPrReviewCooldownKey('review', project, pr, prDisplayId);
       if (clearLegacyPrReviewCooldown('review', project, pr, prDisplayId, key)) {
@@ -5521,16 +5551,16 @@ async function discoverFromPrs(config, project) {
       try {
         const checkFn = project.repoHost === 'github' ? ghCheckLiveReview : adoCheckLiveReview;
         const liveStatus = await checkFn(pr, project);
-        if (liveStatus && liveStatus !== 'pending') {
+        if (liveStatus && liveStatus !== REVIEW_STATUS.PENDING) {
           log('info', `Pre-dispatch vote check: ${pr.id} is ${liveStatus} (cached was pending) — skipping review`);
           // Never downgrade from approved
-          if (pr.reviewStatus !== 'approved') pr.reviewStatus = liveStatus;
+          if (pr.reviewStatus !== REVIEW_STATUS.APPROVED) pr.reviewStatus = liveStatus;
           // Persist so next tick doesn't re-check
           try {
             mutateJsonFileLocked(projectPrPath(project), data => {
               if (!Array.isArray(data)) return data;
               const target = shared.findPrRecord(data, pr, project);
-              if (target && target.reviewStatus !== 'approved') target.reviewStatus = liveStatus;
+              if (target && target.reviewStatus !== REVIEW_STATUS.APPROVED) target.reviewStatus = liveStatus;
               return data;
             });
           } catch (e) { log('warn', `persist live vote-check for ${pr.id}: ${e.message}`); }
@@ -5711,7 +5741,7 @@ async function discoverFromPrs(config, project) {
     // 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 = reReviewEnabled && reviewStatus === 'waiting' &&
+    const needsReReview = reReviewEnabled && reviewStatus === REVIEW_STATUS.WAITING &&
       fixedAfterReview && !fixDispatched;
     if (needsReReview) {
       const key = getPrReviewCooldownKey('rereview', project, pr, prDisplayId);
@@ -5727,15 +5757,15 @@ async function discoverFromPrs(config, project) {
       try {
         const checkFn = project.repoHost === 'github' ? ghCheckLiveReview : adoCheckLiveReview;
         const liveStatus = await checkFn(pr, project);
-        const liveStatusBlocksReReview = liveStatus && liveStatus !== 'waiting' && liveStatus !== 'pending';
+        const liveStatusBlocksReReview = liveStatus && liveStatus !== REVIEW_STATUS.WAITING && liveStatus !== REVIEW_STATUS.PENDING;
         if (liveStatusBlocksReReview) {
           log('info', `Pre-dispatch vote check: ${pr.id} is ${liveStatus} (cached was waiting) — skipping re-review`);
-          if (pr.reviewStatus !== 'approved') pr.reviewStatus = liveStatus;
+          if (pr.reviewStatus !== REVIEW_STATUS.APPROVED) pr.reviewStatus = liveStatus;
           try {
             mutateJsonFileLocked(projectPrPath(project), data => {
               if (!Array.isArray(data)) return data;
               const target = shared.findPrRecord(data, pr, project);
-              if (target && target.reviewStatus !== 'approved') target.reviewStatus = liveStatus;
+              if (target && target.reviewStatus !== REVIEW_STATUS.APPROVED) target.reviewStatus = liveStatus;
               return data;
             });
           } catch (e) { log('warn', `persist live re-review vote-check for ${pr.id}: ${e.message}`); }
@@ -5776,7 +5806,7 @@ async function discoverFromPrs(config, project) {
 
     // PRs with changes requested → route back to author for fix.
     // Gate on evalLoopEnabled and provider polling — the review→fix cycle depends on fresh vote state.
-    if (evalLoopEnabled && pollEnabled && autoFixReviewFeedback && reviewStatus === 'changes-requested' && !awaitingReReview && !fixDispatched
+    if (evalLoopEnabled && pollEnabled && autoFixReviewFeedback && reviewStatus === REVIEW_STATUS.CHANGES_REQUESTED && !awaitingReReview && !fixDispatched
       && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.REVIEW_FEEDBACK)) {
       const reviewCauseKey = getPrAutomationCauseKey('review-feedback', pr);
       const key = getPrAutomationDispatchKey(`fix-${project?.name || 'default'}-${prDisplayId}`, reviewCauseKey);
@@ -6473,6 +6503,16 @@ function discoverFromWorkItems(config, project) {
 
   const root = project?.localPath ? path.resolve(project.localPath) : path.resolve(MINIONS_DIR, '..');
   const items = safeJsonArr(projectWorkItemsPath(project));
+  // W-mq9b7lor (H3): snapshot each item's serializable state BEFORE the
+  // discover loop runs so we can compute per-item field deltas at the end
+  // and apply them inside the mutateWorkItems lock — the prior
+  // `mutateWorkItems(..., () => items)` shape ignored the lock-supplied
+  // current state and overwrote any concurrent writes that landed while
+  // discoverWork was iterating (e.g. dashboard PATCHes, completion writes,
+  // sibling-project work-item store mutations sharing the same scope).
+  const _wiPreSnapshots = new Map(
+    items.map(it => [it.id, JSON.parse(JSON.stringify(it))])
+  );
   const cooldownMs = (src.cooldownMinutes || 0) * 60 * 1000;
   const newWork = [];
   // PRD sync for dispatched status deferred to spawnAgent success (#480)
@@ -6824,8 +6864,47 @@ function discoverFromWorkItems(config, project) {
   }
 
   // Write back updated statuses (pendingReason clears, checkpoint counts, decompose flags, etc.)
+  // W-mq9b7lor (H3): compute per-item field deltas from the pre-loop snapshot
+  // and apply them INSIDE the mutator against the lock-supplied `current`
+  // array, so concurrent writers (dashboard PATCHes, sibling discoverWork
+  // passes, completion writes routed through the same work-items store
+  // scope) that landed during the discover loop survive. The prior `() =>
+  // items` shape ignored `current` and committed the pre-lock snapshot,
+  // silently overwriting those concurrent changes.
   if (needsWrite) {
-    mutateWorkItems(projectWorkItemsPath(project), () => items);
+    const patches = new Map();
+    for (const item of items) {
+      const before = _wiPreSnapshots.get(item.id);
+      if (!before) continue; // safety: discover doesn't add new items
+      const setFields = {};
+      const deleteKeys = [];
+      const allKeys = new Set([...Object.keys(before), ...Object.keys(item)]);
+      for (const k of allKeys) {
+        const hasBefore = Object.prototype.hasOwnProperty.call(before, k);
+        const hasAfter = Object.prototype.hasOwnProperty.call(item, k);
+        if (hasAfter && !hasBefore) {
+          setFields[k] = item[k];
+        } else if (!hasAfter && hasBefore) {
+          deleteKeys.push(k);
+        } else if (JSON.stringify(before[k]) !== JSON.stringify(item[k])) {
+          setFields[k] = item[k];
+        }
+      }
+      if (Object.keys(setFields).length > 0 || deleteKeys.length > 0) {
+        patches.set(item.id, { setFields, deleteKeys });
+      }
+    }
+    if (patches.size > 0) {
+      mutateWorkItems(projectWorkItemsPath(project), (current) => {
+        for (const it of current) {
+          const patch = patches.get(it.id);
+          if (!patch) continue;
+          Object.assign(it, patch.setFields);
+          for (const k of patch.deleteKeys) delete it[k];
+        }
+        return current;
+      });
+    }
   }
 
   const skipTotal = skipped.gated + skipped.noAgent;
@@ -7054,11 +7133,11 @@ function materializeSpecsAsWorkItems(config, project) {
 
         existingItems.push({
           id: newId,
-          type: 'implement',
+          type: WORK_TYPE.IMPLEMENT,
           title: `Implement: ${info.title}`,
           description: `Implementation work from merged spec.\n\n**Spec:** \`${doc.file}\`\n**Source PR:** ${pr.id} — ${pr.title || ''}\n**PR URL:** ${pr.url || 'N/A'}\n\n## Summary\n\n${info.summary}\n\nRead the full spec at \`${doc.file}\` before starting.`,
           priority: info.priority,
-          status: 'queued',
+          status: WI_STATUS.QUEUED,
           created: ts(),
           createdBy: 'engine:spec-discovery',
           sourceSpec: doc.file,
@@ -8279,30 +8358,31 @@ async function tickInner() {
 
   try { pruneStalePrDispatches(config); } catch (e) { log('warn', 'prune stale PR dispatches: ' + e.message); }
 
-  // 3. Process pending dispatches before discovery. discoverWork() runs
+  // Process pending dispatches before discovery. discoverWork() runs
   // pre-dispatch LLM validation for newly found work; a slow validator must not
   // starve runnable entries that are already durable in dispatch.pending.
-  const dispatch = getDispatch();
-  const activeCount = (dispatch.active || []).length;
+  //
+  // W-mq9b7lor (H2): sort INSIDE the dispatch mutator so any concurrent
+  // completion / enqueue / queue-cleanup path that lands between the SQL read
+  // and our write isn't clobbered by writing a stale pre-lock snapshot back.
+  // Previously this site read dispatch, sorted pending in memory, then handed
+  // the pre-lock snapshot to the mutator callback — overwriting whatever the
+  // lock-held read had freshly loaded from SQL.
   const maxConcurrent = resolveMaxConcurrent(config);
-
-  const slotsAvailable = Math.max(0, maxConcurrent - activeCount);
-
-  // Priority dispatch: implement > fix/ask > review > test/verify > plan > other
   const typePriority = { 'implement:large': 0, implement: 0, fix: 1, ask: 1, review: 2, test: 3, verify: 3, plan: 4, 'plan-to-prd': 4 };
   const itemPriority = { high: 0, medium: 1, low: 2 };
-  dispatch.pending.sort((a, b) => {
-    const ta = typePriority[a.type] ?? 5, tb = typePriority[b.type] ?? 5;
-    if (ta !== tb) return ta - tb;
-    const pa = itemPriority[a.meta?.item?.priority] ?? 1, pb = itemPriority[b.meta?.item?.priority] ?? 1;
-    return pa - pb;
-  });
   if (_isTickStale(myGeneration)) return;
-  mutateDispatch((dp) => {
-    dp.pending = dispatch.pending;
-    dp.active = dispatch.active || dp.active;
+  const dispatch = mutateDispatch((dp) => {
+    dp.pending.sort((a, b) => {
+      const ta = typePriority[a.type] ?? 5, tb = typePriority[b.type] ?? 5;
+      if (ta !== tb) return ta - tb;
+      const pa = itemPriority[a.meta?.item?.priority] ?? 1, pb = itemPriority[b.meta?.item?.priority] ?? 1;
+      return pa - pb;
+    });
     return dp;
   });
+  const activeCount = (dispatch.active || []).length;
+  const slotsAvailable = Math.max(0, maxConcurrent - activeCount);
 
   // Build set of agents currently active (one task per agent at a time).
   const busyAgents = new Set((dispatch.active || []).map(d => d.agent));
@@ -8658,7 +8738,35 @@ async function tickInner() {
   }
   if (skipReasonChanged) {
     if (_isTickStale(myGeneration)) return;
-    mutateDispatch((dp) => { dp.pending = postDispatch.pending; return dp; });
+    // W-mq9b7lor (H2): apply per-item skipReason patches INSIDE the mutator
+    // so any concurrent completion / enqueue / queue-cleanup path landing
+    // between the postDispatch snapshot read above and our write isn't
+    // clobbered. Previously the mutator callback assigned dp.pending from the
+    // pre-lock postDispatch snapshot, overwriting any freshly loaded queue
+    // entries. Sentinel-undefined for _pendingReason / _agentBusySince
+    // mirrors the in-loop `delete` semantics — JSON serialization drops
+    // undefined-valued keys, so SQL → JSON mirror stays consistent.
+    const patches = new Map();
+    for (const item of (postDispatch.pending || [])) {
+      patches.set(item.id, {
+        skipReason: item.skipReason,
+        _pendingReason: item._pendingReason,
+        _agentBusySince: item._agentBusySince,
+      });
+    }
+    if (_isTickStale(myGeneration)) return;
+    mutateDispatch((dp) => {
+      for (const item of (dp.pending || [])) {
+        const patch = patches.get(item.id);
+        if (!patch) continue;
+        item.skipReason = patch.skipReason;
+        if (patch._pendingReason === undefined) delete item._pendingReason;
+        else item._pendingReason = patch._pendingReason;
+        if (patch._agentBusySince === undefined) delete item._agentBusySince;
+        else item._agentBusySince = patch._agentBusySince;
+      }
+      return dp;
+    });
   }
 
   // 4. Discover new work from sources. Newly discovered dispatches are eligible

package/package.json

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