@yemi33/minions 0.1.976 → 0.1.978

package/CHANGELOG.md

@@ -1,11 +1,13 @@
 # Changelog
 
-## 0.1.976 (2026-04-14)
+## 0.1.978 (2026-04-15)
 
 ### Features
+- free-form interval input + CC create-watch action
 -  flush queued CC messages as single combined request
 -  add quality standard reminder to all agent and CC prompts
 - surface in-flight tool calls in lastAction (#1064)
+- implement dashboard loop/watch management panel
 - reassign tasks when preferred agent is busy too long
 - wire agentBusyReassignMs into settings UI and persist
 -  ADO throttle detection, poll guards, and dashboard banner (#1051)
@@ -21,12 +23,15 @@
 -  doc-chat abort kills LLM process + queued messages auto-process
 - add /api/work-items/reopen endpoint and reopen-work-item CC action (#982)
 - CC tab unread dot + reopened badge on work items
-- fix dep re-merge failure on retry with existing commits (#977)
-- audit and harden log buffering implementation (#971)
 
 ### Fixes
+-  ENGINE_DEFAULTS undefined in tick + playbook empty-var false positives
+-  defer review setCooldown to post-gating in discoverWork
 -  move review verdict check before updateWorkItemStatus(DONE)
+-  address review feedback — move writeToInbox outside lock, add absolute condition auto-expire
+- fix watches feature gaps — human notifications, branch stub, status-change init, unique keys
 -  skip isAlreadyDispatched in needsReReview to allow re-review within 1hr
+- skip SessionStart hook settings test on CI
 -  loop queue flush so messages queued during combined send aren't orphaned
 -  set lastPushedAt on fix completion to unblock re-review without poller
 -  restore ADO throttle test functions deleted during merge conflict resolution
@@ -40,14 +45,11 @@
 - defer setCooldown to post-gating in discoverWork
 - fix CC queued message 'already processing' and thinking UX stacking
 - enforce --timeout 1 on all azureauth calls to prevent agent orphans (#1063)
-- cancel steering kill watcher on resume spawn (#1052) (#1062)
-- suppress warn for optional template variables (#1061)
-- skip SessionStart hook settings test on CI
-- fix boolean settings test and add agentBusyReassignMs to dashboard
-- fix ENGINE_DEFAULTS ref and derive boolean settings from defaults
 
 ### Other
+- refactor(watches): rename maxTriggers→stopAfter, add onNotMet per-poll action
 - refactor(dashboard): extract _releaseCCTab helper and CC_LOCK_WAIT_MS constant
+- merge: resolve conflicts with master on PR-1065
 - test(engine): add regression tests for autoFixConflicts flag and DEFAULTS alias
 - refactor(ado): simplify ado-status and extract build/review status helpers
 - refactor(ado): extract stripRefsHeads helper, deduplicate refs/heads/ stripping

package/dashboard/js/command-center.js

@@ -388,15 +388,14 @@ async function ccSend() {
   }
   var wasAborted = await _ccDoSend(message, false, originTabId);
 
-  // Flush all queued messages at once — combine into a single request.
-  // Loop in case user queues more messages while the combined flush is processing.
+  // Flush queued messages to the ORIGINAL tab, even if user switched tabs
   while (tab._queue && tab._queue.length > 0) {
     if (wasAborted) {
       await new Promise(function(r) { setTimeout(r, 1500); });
     }
-    var combined = tab._queue.splice(0);
+    var next = tab._queue.shift();
     _renderQueueIndicator();
-    wasAborted = await _ccDoSend(combined.join('\n\n'), false, originTabId);
+    wasAborted = await _ccDoSend(next, false, originTabId);
   }
 }
 

package/dashboard/js/refresh.js

@@ -88,6 +88,7 @@ function _processStatusUpdate(data) {
   if (_changed('skills', data.skills)) renderSkills(data.skills || []);
   if (_changed('mcpServers', data.mcpServers)) renderMcpServers(data.mcpServers || []);
   if (_changed('schedules', data.schedules)) renderSchedules(data.schedules || []);
+  if (_changed('watches', data.watches)) renderWatches(data.watches || []);
   if (_changed('meetings', data.meetings)) renderMeetings(data.meetings || []);
   if (_changed('pipelines', data.pipelines) && typeof renderPipelines === 'function') renderPipelines(data.pipelines || []);
   if (_changed('pinned', data.pinned)) renderPinned(data.pinned || []);

package/dashboard/js/render-watches.js

@@ -0,0 +1,310 @@
+// render-watches.js — Watch rendering and CRUD functions for the dashboard
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const _WATCH_STATUS_BADGES = {
+  active: '<span class="pr-badge approved">active</span>',
+  paused: '<span class="pr-badge rejected">paused</span>',
+  triggered: '<span class="pr-badge" style="background:rgba(210,153,34,0.15);color:var(--yellow);border-color:var(--yellow)">triggered</span>',
+  expired: '<span class="pr-badge" style="background:rgba(139,148,158,0.15);color:var(--muted);border-color:var(--muted)">expired</span>',
+};
+
+const _WATCH_TARGET_LABELS = {
+  pr: 'PR',
+  'work-item': 'Work Item',
+};
+
+const _WATCH_CONDITION_LABELS = {
+  merged: 'Merged',
+  'build-fail': 'Build Fail',
+  'build-pass': 'Build Pass',
+  completed: 'Completed',
+  failed: 'Failed',
+  'status-change': 'Status Change',
+  any: 'Any Change',
+};
+
+function _intervalToHuman(ms) {
+  if (!ms) return 'default';
+  const sec = Math.floor(ms / 1000);
+  if (sec < 60) return sec + 's';
+  const min = Math.floor(sec / 60);
+  if (min < 60) return min + 'm';
+  return Math.floor(min / 60) + 'h ' + (min % 60) + 'm';
+}
+
+// Parse human-friendly interval strings: "15m", "2h", "30s", "90000" (ms)
+function _parseIntervalStr(s) {
+  if (!s) return 300000;
+  s = String(s).trim().toLowerCase();
+  if (/^\d+$/.test(s)) {
+    const n = parseInt(s, 10);
+    return n >= 1000 ? n : n * 1000; // bare numbers: ≥1000 treated as ms, else seconds
+  }
+  const match = s.match(/^(\d+(?:\.\d+)?)\s*(s|sec|m|min|h|hr|hours?)$/);
+  if (!match) return 300000;
+  const n = parseFloat(match[1]);
+  const unit = match[2][0];
+  if (unit === 's') return Math.round(n * 1000);
+  if (unit === 'm') return Math.round(n * 60000);
+  if (unit === 'h') return Math.round(n * 3600000);
+  return 300000;
+}
+
+// ─── Rendering ──────────────────────────────────────────────────────────────
+
+let _watchPage = 0;
+const WATCH_PER_PAGE = 15;
+
+function renderWatches(watchesData) {
+  var watches = (watchesData || []).filter(function(w) { return !isDeleted('watch:' + w.id); });
+  var el = document.getElementById('watches-content');
+  var countEl = document.getElementById('watches-count');
+  if (!el) return;
+  if (countEl) countEl.textContent = watches.length;
+  window._lastWatches = watches;
+
+  if (!watches.length) {
+    el.innerHTML = '<p class="empty">No active watches. Create one to monitor PRs or work items.</p>';
+    return;
+  }
+
+  var totalPages = Math.ceil(watches.length / WATCH_PER_PAGE);
+  if (_watchPage >= totalPages) _watchPage = totalPages - 1;
+  var start = _watchPage * WATCH_PER_PAGE;
+  var pageItems = watches.slice(start, start + WATCH_PER_PAGE);
+
+  var html = '<div class="pr-table-wrap"><table class="pr-table"><thead><tr>' +
+    '<th>ID</th><th>Target</th><th>Type</th><th>Condition</th><th>Interval</th><th>Owner</th><th>Status</th><th>Triggers</th><th>Last Checked</th><th></th>' +
+    '</tr></thead><tbody>';
+
+  for (var i = 0; i < pageItems.length; i++) {
+    var w = pageItems[i];
+    var statusBadge = _WATCH_STATUS_BADGES[w.status] || escHtml(w.status || 'unknown');
+    var targetLabel = _WATCH_TARGET_LABELS[w.targetType] || escHtml(w.targetType || '');
+    var condLabel = _WATCH_CONDITION_LABELS[w.condition] || escHtml(w.condition || '');
+    var lastChecked = w.last_checked ? timeAgo(w.last_checked) : 'never';
+    var lastTriggered = w.last_triggered ? timeAgo(w.last_triggered) : 'never';
+    var triggerInfo = (w.triggerCount || 0) + (w.stopAfter > 0 ? '/' + w.stopAfter : '');
+
+    html += '<tr style="cursor:pointer" onclick="openWatchDetail(\'' + escHtml(w.id) + '\')">' +
+      '<td><span class="pr-id">' + escHtml(w.id) + '</span></td>' +
+      '<td style="max-width:180px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap" title="' + escHtml(w.description || w.target) + '">' + escHtml(w.target) + '</td>' +
+      '<td><span class="dispatch-type explore">' + escHtml(targetLabel) + '</span></td>' +
+      '<td><span style="font-size:11px;color:var(--blue)">' + escHtml(condLabel) + '</span></td>' +
+      '<td><span style="font-size:10px;color:var(--muted)">' + escHtml(_intervalToHuman(w.interval)) + '</span></td>' +
+      '<td><span class="pr-agent">' + escHtml(w.owner || 'human') + '</span></td>' +
+      '<td>' + statusBadge + '</td>' +
+      '<td title="Last triggered: ' + escHtml(lastTriggered) + '"><span style="font-size:11px">' + escHtml(triggerInfo) + '</span></td>' +
+      '<td><span class="pr-date">' + escHtml(lastChecked) + '</span></td>' +
+      '<td style="white-space:nowrap">';
+
+    // Pause/Resume button
+    if (w.status === 'active') {
+      html += '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--yellow);border-color:var(--yellow);margin-right:4px" onclick="event.stopPropagation();toggleWatchPause(\'' + escHtml(w.id) + '\',true)" title="Pause">&#x23F8;</button>';
+    } else if (w.status === 'paused') {
+      html += '<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();toggleWatchPause(\'' + escHtml(w.id) + '\',false)" title="Resume">&#x25B6;</button>';
+    }
+
+    // Delete button
+    html += '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--red);border-color:var(--red)" onclick="event.stopPropagation();deleteWatch(\'' + escHtml(w.id) + '\')" title="Delete">&#x2715;</button>';
+    html += '</td></tr>';
+  }
+
+  html += '</tbody></table></div>';
+
+  if (watches.length > WATCH_PER_PAGE) {
+    html += '<div class="pr-pager">' +
+      '<span class="pr-page-info">Showing ' + (start + 1) + ' to ' + Math.min(start + WATCH_PER_PAGE, watches.length) + ' of ' + watches.length + '</span>' +
+      '<div class="pr-pager-btns">' +
+        '<button class="pr-pager-btn ' + (_watchPage === 0 ? 'disabled' : '') + '" onclick="_watchPrev()">Prev</button>' +
+        '<button class="pr-pager-btn ' + (_watchPage >= totalPages - 1 ? 'disabled' : '') + '" onclick="_watchNext()">Next</button>' +
+      '</div>' +
+    '</div>';
+  }
+
+  el.innerHTML = html;
+}
+
+function _watchPrev() { if (_watchPage > 0) { _watchPage--; renderWatches(window._lastWatches || []); } }
+function _watchNext() { var tp = Math.ceil((window._lastWatches || []).length / WATCH_PER_PAGE); if (_watchPage < tp - 1) { _watchPage++; renderWatches(window._lastWatches || []); } }
+
+// ─── Detail Modal ───────────────────────────────────────────────────────────
+
+function openWatchDetail(id) {
+  var w = (window._lastWatches || []).find(function(x) { return x.id === id; });
+  if (!w) return;
+  var statusBadge = _WATCH_STATUS_BADGES[w.status] || escHtml(w.status || '');
+  var lastChecked = w.last_checked ? new Date(w.last_checked).toLocaleString() : 'never';
+  var lastTriggered = w.last_triggered ? new Date(w.last_triggered).toLocaleString() : 'never';
+  var createdAt = w.created_at ? new Date(w.created_at).toLocaleString() : 'unknown';
+  var targetLabel = _WATCH_TARGET_LABELS[w.targetType] || w.targetType;
+  var condLabel = _WATCH_CONDITION_LABELS[w.condition] || w.condition;
+
+  document.getElementById('modal-title').innerHTML = escHtml(w.description || w.target) +
+    ' <div style="display:flex;gap:4px;margin-top:4px">' +
+      (w.status === 'active' ? '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--yellow)" onclick="toggleWatchPause(\'' + escHtml(w.id) + '\',true);closeModal()">Pause</button>' : '') +
+      (w.status === 'paused' ? '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--green)" onclick="toggleWatchPause(\'' + escHtml(w.id) + '\',false);closeModal()">Resume</button>' : '') +
+      '<button class="pr-pager-btn" style="font-size:10px;padding:2px 10px;color:var(--red)" onclick="deleteWatch(\'' + escHtml(w.id) + '\');closeModal()">Delete</button>' +
+    '</div>';
+
+  var body = '<div style="display:flex;flex-direction:column;gap:10px;font-size:12px;line-height:1.6">' +
+    '<div><strong style="color:var(--muted)">ID:</strong> ' + escHtml(w.id) + '</div>' +
+    '<div><strong style="color:var(--muted)">Target:</strong> ' + escHtml(w.target) + '</div>' +
+    '<div><strong style="color:var(--muted)">Target Type:</strong> <span class="dispatch-type explore">' + escHtml(targetLabel) + '</span></div>' +
+    '<div><strong style="color:var(--muted)">Condition:</strong> <span style="color:var(--blue)">' + escHtml(condLabel) + '</span></div>' +
+    '<div><strong style="color:var(--muted)">Check Interval:</strong> ' + escHtml(_intervalToHuman(w.interval)) + '</div>' +
+    '<div><strong style="color:var(--muted)">Owner:</strong> ' + escHtml(w.owner || 'human') + '</div>' +
+    '<div><strong style="color:var(--muted)">Status:</strong> ' + statusBadge + '</div>' +
+    '<div><strong style="color:var(--muted)">Notify:</strong> ' + escHtml(w.notify || 'inbox') + '</div>' +
+    '<div><strong style="color:var(--muted)">Triggers:</strong> ' + (w.triggerCount || 0) + (w.stopAfter > 0 ? ' / ' + w.stopAfter + ' (expires after)' : ' (runs forever)') + '</div>' +
+    (w.onNotMet ? '<div><strong style="color:var(--muted)">On Each Poll (not met):</strong> ' + escHtml(w.onNotMet) + '</div>' : '') +
+    '<div><strong style="color:var(--muted)">Created:</strong> ' + escHtml(createdAt) + '</div>' +
+    '<div><strong style="color:var(--muted)">Last Checked:</strong> ' + escHtml(lastChecked) + '</div>' +
+    '<div><strong style="color:var(--muted)">Last Triggered:</strong> ' + escHtml(lastTriggered) + '</div>' +
+    (w._lastTriggerMessage ? '<div><strong style="color:var(--muted)">Last Trigger Message:</strong><div style="margin-top:4px;padding:8px;background:var(--surface2);border-radius:4px;font-size:11px">' + escHtml(w._lastTriggerMessage) + '</div></div>' : '') +
+    (w.project ? '<div><strong style="color:var(--muted)">Project:</strong> ' + escHtml(w.project) + '</div>' : '') +
+    (w.description ? '<div><strong style="color:var(--muted)">Description:</strong> ' + escHtml(w.description) + '</div>' : '') +
+  '</div>';
+
+  document.getElementById('modal-body').innerHTML = body;
+  document.getElementById('modal-body').style.whiteSpace = 'normal';
+  document.getElementById('modal-body').style.fontFamily = "'Segoe UI', system-ui, sans-serif";
+  document.getElementById('modal').classList.add('open');
+}
+
+// ─── CRUD Actions ───────────────────────────────────────────────────────────
+
+function toggleWatchPause(id, pause) {
+  var newStatus = pause ? 'paused' : 'active';
+  showToast('cmd-toast', (pause ? 'Pausing' : 'Resuming') + ' watch...', true);
+  fetch('/api/watches/update', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id: id, status: newStatus })
+  }).then(function(res) { return res.json(); }).then(function(data) {
+    if (data.error) showToast('cmd-toast', 'Error: ' + data.error, false);
+  }).catch(function(err) {
+    showToast('cmd-toast', 'Error: ' + err.message, false);
+  });
+}
+
+function deleteWatch(id) {
+  if (!confirm('Delete this watch?')) return;
+  markDeleted('watch:' + id);
+  showToast('cmd-toast', 'Deleting watch...', true);
+  fetch('/api/watches/delete', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ id: id })
+  }).then(function(res) { return res.json(); }).then(function(data) {
+    if (data.error) showToast('cmd-toast', 'Error: ' + data.error, false);
+    else renderWatches(window._lastWatches || []);
+  }).catch(function(err) {
+    showToast('cmd-toast', 'Error: ' + err.message, false);
+  });
+}
+
+// ─── Create Watch Modal ─────────────────────────────────────────────────────
+
+function _watchFormHtml() {
+  var inputStyle = 'display:block;width:100%;margin-top:4px;padding:6px 8px;background:var(--bg);border:1px solid var(--border);border-radius:var(--radius-sm);color:var(--text);font-size:var(--text-md);font-family:inherit';
+
+  var targetTypes = [
+    { value: 'pr', label: 'Pull Request' },
+    { value: 'work-item', label: 'Work Item' },
+  ];
+  var conditions = [
+    { value: 'merged', label: 'Merged' },
+    { value: 'build-fail', label: 'Build Fail' },
+    { value: 'build-pass', label: 'Build Pass' },
+    { value: 'completed', label: 'Completed' },
+    { value: 'failed', label: 'Failed' },
+    { value: 'status-change', label: 'Status Change' },
+    { value: 'any', label: 'Any Change' },
+  ];
+  var ttOpts = targetTypes.map(function(t) { return '<option value="' + t.value + '">' + t.label + '</option>'; }).join('');
+  var condOpts = conditions.map(function(c) { return '<option value="' + c.value + '">' + c.label + '</option>'; }).join('');
+  var agentOpts = '<option value="">human</option>' + (cmdAgents || []).map(function(a) { return '<option value="' + escHtml(a.id) + '">' + escHtml(a.name) + '</option>'; }).join('');
+  var projOpts = '<option value="">Any</option>' + (cmdProjects || []).map(function(p) { return '<option value="' + escHtml(p.name) + '">' + escHtml(p.name) + '</option>'; }).join('');
+
+  return '<div style="display:flex;flex-direction:column;gap:12px;font-family:inherit">' +
+    '<div id="watch-form-error" style="display:none;color:var(--red);font-size:12px;padding:6px 10px;background:rgba(255,50,50,0.1);border-radius:var(--radius-sm)"></div>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Target (PR number or Work Item ID)<input id="watch-edit-target" placeholder="e.g. 1057, W-abc123" style="' + inputStyle + '"></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Target Type<select id="watch-edit-target-type" style="' + inputStyle + '">' + ttOpts + '</select></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Condition<select id="watch-edit-condition" style="' + inputStyle + '">' + condOpts + '</select></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Check Interval <span style="font-size:10px;color:var(--muted)">(e.g. 5m, 15m, 1h — default 5m)</span><input id="watch-edit-interval" placeholder="5m" style="' + inputStyle + '"></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Owner (who gets notified)<select id="watch-edit-owner" style="' + inputStyle + '">' + agentOpts + '</select></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Project<select id="watch-edit-project" style="' + inputStyle + '">' + projOpts + '</select></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Description<input id="watch-edit-desc" placeholder="Optional description" style="' + inputStyle + '"></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Stop After N Triggers <span style="font-size:10px;color:var(--muted)">(0 = run forever, 1 = expire on first match)</span><input id="watch-edit-stop-after" type="number" value="0" min="0" style="' + inputStyle + '"></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">On Each Poll (if condition not met)<select id="watch-edit-on-not-met" style="' + inputStyle + '"><option value="">None — do nothing</option><option value="notify">Notify — write to inbox each poll</option></select></label>' +
+  '</div>';
+}
+
+function openCreateWatchModal() {
+  document.getElementById('modal-title').innerHTML = 'Create Watch' +
+    ' <button class="pr-pager-btn" style="font-size:10px;padding:2px 12px;color:var(--green);border-color:var(--green);margin-left:8px" onclick="submitWatch()">Create</button>';
+  document.getElementById('modal-body').innerHTML = _watchFormHtml();
+  document.getElementById('modal-body').style.whiteSpace = 'normal';
+  document.getElementById('modal-body').style.fontFamily = "'Segoe UI', system-ui, sans-serif";
+  document.getElementById('modal').classList.add('open');
+}
+
+function submitWatch() {
+  var target = (document.getElementById('watch-edit-target') || {}).value || '';
+  var targetType = (document.getElementById('watch-edit-target-type') || {}).value || 'pr';
+  var condition = (document.getElementById('watch-edit-condition') || {}).value || 'merged';
+  var interval = _parseIntervalStr((document.getElementById('watch-edit-interval') || {}).value);
+  var owner = (document.getElementById('watch-edit-owner') || {}).value || '';
+  var project = (document.getElementById('watch-edit-project') || {}).value || '';
+  var description = (document.getElementById('watch-edit-desc') || {}).value || '';
+  var stopAfter = parseInt((document.getElementById('watch-edit-stop-after') || {}).value, 10) || 0;
+  var onNotMet = (document.getElementById('watch-edit-on-not-met') || {}).value || '';
+
+  if (!target.trim()) {
+    var errEl = document.getElementById('watch-form-error');
+    if (errEl) { errEl.textContent = 'Target is required'; errEl.style.display = 'block'; }
+    return;
+  }
+
+  showToast('cmd-toast', 'Creating watch...', true);
+  fetch('/api/watches', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      target: target.trim(),
+      targetType: targetType,
+      condition: condition,
+      interval: interval,
+      owner: owner || 'human',
+      project: project || null,
+      description: description || null,
+      notify: 'inbox',
+      stopAfter: stopAfter,
+      onNotMet: onNotMet || null,
+    })
+  }).then(function(res) { return res.json(); }).then(function(data) {
+    if (data.error) {
+      showToast('cmd-toast', 'Error: ' + data.error, false);
+    } else {
+      showToast('cmd-toast', 'Watch created: ' + data.watch.id, true);
+      closeModal();
+    }
+  }).catch(function(err) {
+    showToast('cmd-toast', 'Error: ' + err.message, false);
+  });
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+window.MinionsWatches = {
+  renderWatches: renderWatches,
+  openCreateWatchModal: openCreateWatchModal,
+  openWatchDetail: openWatchDetail,
+  submitWatch: submitWatch,
+  toggleWatchPause: toggleWatchPause,
+  deleteWatch: deleteWatch,
+  _watchPrev: _watchPrev,
+  _watchNext: _watchNext,
+};

package/dashboard/layout.html

@@ -72,6 +72,7 @@
     <a class="sidebar-link" data-page="inbox" href="/inbox">Notes & KB</a>
     <a class="sidebar-link" data-page="tools" href="/tools">Skills & MCP</a>
     <a class="sidebar-link" data-page="schedule" href="/schedule" title="Cron-based recurring tasks (single task per schedule)">Schedules</a>
+    <a class="sidebar-link" data-page="watches" href="/watches" title="Persistent watches that monitor PRs, work items, and branches">Watches</a>
     <a class="sidebar-link" data-page="pipelines" href="/pipelines" title="Multi-stage workflows — chain tasks, meetings, plans with dependencies">Pipelines</a>
     <a class="sidebar-link" data-page="meetings" href="/meetings">Meetings</a>
     <a class="sidebar-link" data-page="engine" href="/engine">Engine</a>

package/dashboard/pages/watches.html

@@ -0,0 +1,7 @@
+      <section id="watches-section">
+        <h2>Watches <span class="count" id="watches-count">0</span>
+          <button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--green);border-color:var(--green);margin-left:8px" onclick="openCreateWatchModal()">+ New</button>
+          <span style="font-size:10px;color:var(--muted);font-weight:400;text-transform:none;letter-spacing:0">persistent watches that monitor PRs, work items, and branches for changes</span>
+        </h2>
+        <div id="watches-content"><p class="empty">No active watches. Create one to monitor PRs, work items, or branches.</p></div>
+      </section>

package/dashboard-build.js

@@ -20,7 +20,7 @@ function buildDashboardHtml() {
   const layout = safeRead(layoutPath);
   const css = safeRead(path.join(dashDir, 'styles.css'));
 
-  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'pipelines', 'meetings', 'engine'];
+  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'watches', 'pipelines', 'meetings', 'engine'];
   let pageHtml = '';
   for (const p of pages) {
     const content = safeRead(path.join(dashDir, 'pages', p + '.html'));
@@ -32,7 +32,7 @@ function buildDashboardHtml() {
     'utils', 'state', 'detail-panel', 'live-stream',
     'render-agents', 'render-dispatch', 'render-work-items', 'render-prd',
     'render-prs', 'render-plans', 'render-inbox', 'render-kb', 'render-skills',
-    'render-other', 'render-schedules', 'render-pipelines', 'render-meetings', 'render-pinned',
+    'render-other', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
     'command-parser', 'command-input', 'command-center', 'command-history',
     'modal', 'modal-qa', 'settings', 'refresh'
   ];

package/dashboard.js

@@ -23,6 +23,7 @@ const queries = require('./engine/queries');
 const teams = require('./engine/teams');
 const ado = require('./engine/ado');
 const gh = require('./engine/github');
+const watchesMod = require('./engine/watches');
 const os = require('os');
 
 const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, reopenWorkItem } = shared;
@@ -77,7 +78,7 @@ function buildDashboardHtml() {
   const css = safeRead(path.join(dashDir, 'styles.css'));
 
   // Assemble page fragments
-  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'pipelines', 'meetings', 'engine'];
+  const pages = ['home', 'work', 'prs', 'plans', 'inbox', 'tools', 'schedule', 'watches', 'pipelines', 'meetings', 'engine'];
   let pageHtml = '';
   for (const p of pages) {
     const content = safeRead(path.join(dashDir, 'pages', p + '.html'));
@@ -90,7 +91,7 @@ function buildDashboardHtml() {
     'utils', 'state', 'render-utils', 'detail-panel', 'live-stream',
     'render-agents', 'render-dispatch', 'render-work-items', 'render-prd',
     'render-prs', 'render-plans', 'render-inbox', 'render-kb', 'render-skills',
-    'render-other', 'render-schedules', 'render-pipelines', 'render-meetings', 'render-pinned',
+    'render-other', 'render-schedules', 'render-watches', 'render-pipelines', 'render-meetings', 'render-pinned',
     'command-parser', 'command-input', 'command-center', 'command-history',
     'modal', 'modal-qa', 'settings', 'refresh'
   ];
@@ -396,6 +397,7 @@ function getStatus() {
       const runs = shared.safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {};
       return scheds.map(s => ({ ...s, _lastRun: runs[s.id] || null }));
     })(),
+    watches: watchesMod.getWatches(),
     meetings: (() => { try { return require('./engine/meeting').getMeetings(); } catch { return []; } })(),
     pipelines: (() => { try { const pl = require('./engine/pipeline'); return pl.getPipelines().map(p => ({ ...p, runs: (pl.getPipelineRuns()[p.id] || []).slice(-5) })); } catch { return []; } })(),
     pinned: (() => { try { return parsePinnedEntries(safeRead(path.join(MINIONS_DIR, 'pinned.md'))); } catch { return []; } })(),
@@ -596,6 +598,18 @@ function parseCCActions(text) {
 // Actions are executed server-side so all clients (frontend, curl, Teams) get the same behavior.
 // The frontend still shows status toasts but no longer needs to fire the API calls.
 
+// Parse interval from CC action — accepts ms number, "15m", "1h", "30s", or null (default 5m).
+function _parseWatchInterval(val) {
+  if (!val) return 300000;
+  if (typeof val === 'number') return Math.max(60000, val);
+  const s = String(val).trim().toLowerCase();
+  if (/^\d+$/.test(s)) { const n = parseInt(s, 10); return Math.max(60000, n >= 1000 ? n : n * 1000); }
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*(s|sec|m|min|h|hr|hours?)$/);
+  if (!m) return 300000;
+  const n = parseFloat(m[1]), u = m[2][0];
+  return Math.max(60000, Math.round(u === 's' ? n * 1000 : u === 'm' ? n * 60000 : n * 3600000));
+}
+
 async function executeCCActions(actions) {
   const results = [];
   for (const action of actions) {
@@ -672,6 +686,23 @@ async function executeCCActions(actions) {
           results.push({ type: 'reopen-work-item', id: action.id, ...(reopenResult || { error: 'unexpected' }) });
           break;
         }
+        case 'create-watch': {
+          const intervalMs = _parseWatchInterval(action.interval);
+          const watch = watchesMod.createWatch({
+            target: action.target,
+            targetType: action.targetType || 'pr',
+            condition: action.condition || 'build-pass',
+            interval: intervalMs,
+            owner: action.owner || 'human',
+            description: action.description || null,
+            project: action.project || null,
+            notify: 'inbox',
+            stopAfter: Number(action.stopAfter) || 0,
+            onNotMet: action.onNotMet || null,
+          });
+          results.push({ type: 'create-watch', id: watch.id, ok: true });
+          break;
+        }
         default:
           // Server didn't handle — frontend must execute
           results.push({ type: action.type });
@@ -3745,6 +3776,49 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     }
   }
 
+  // ── Watches API Handlers ─────────────────────────────────────────────────
+
+  async function handleWatchesList(req, res) {
+    return jsonReply(res, 200, { watches: watchesMod.getWatches() });
+  }
+
+  async function handleWatchesCreate(req, res) {
+    const body = await readBody(req);
+    const { target, targetType, condition, interval, owner, description, project, notify, stopAfter, onNotMet } = body;
+    if (!target) return jsonReply(res, 400, { error: 'target is required' });
+    try {
+      const watch = watchesMod.createWatch({ target, targetType, condition, interval, owner, description, project, notify, stopAfter, onNotMet });
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, watch });
+    } catch (e) {
+      return jsonReply(res, 400, { error: e.message });
+    }
+  }
+
+  async function handleWatchesUpdate(req, res) {
+    const body = await readBody(req);
+    const { id, ...updates } = body;
+    if (!id) return jsonReply(res, 400, { error: 'id is required' });
+    try {
+      const watch = watchesMod.updateWatch(id, updates);
+      if (!watch) return jsonReply(res, 404, { error: 'Watch not found' });
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, watch });
+    } catch (e) {
+      return jsonReply(res, 400, { error: e.message });
+    }
+  }
+
+  async function handleWatchesDelete(req, res) {
+    const body = await readBody(req);
+    const { id } = body;
+    if (!id) return jsonReply(res, 400, { error: 'id is required' });
+    const deleted = watchesMod.deleteWatch(id);
+    if (!deleted) return jsonReply(res, 404, { error: 'Watch not found' });
+    invalidateStatusCache();
+    return jsonReply(res, 200, { ok: true });
+  }
+
   async function handleEngineRestart(req, res) {
     try {
       const newPid = restartEngine();
@@ -4442,6 +4516,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { 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 },
 
+    // Watches
+    { method: 'GET', path: '/api/watches', desc: 'List all watches', handler: handleWatchesList },
+    { method: 'POST', path: '/api/watches', desc: 'Create a new watch', params: 'target, targetType, condition, interval?, owner?, description?, project?, notify?, stopAfter?, onNotMet?', handler: handleWatchesCreate },
+    { method: 'POST', path: '/api/watches/update', desc: 'Update a watch (pause/resume/modify)', params: 'id, status?, interval?, description?, notify?, stopAfter?, onNotMet?, condition?', handler: handleWatchesUpdate },
+    { method: 'POST', path: '/api/watches/delete', desc: 'Delete a watch', params: 'id', handler: handleWatchesDelete },
+
     // Pipelines
     { method: 'GET', path: '/api/pipelines', desc: 'List all pipelines with runs', handler: async (req, res) => {
       const { getPipelines, getPipelineRuns } = require('./engine/pipeline');

package/engine/playbook.js

@@ -268,10 +268,32 @@ function validatePlaybookVars(playbookName, vars) {
   return { valid: missing.length === 0, missing };
 }
 
+// ─── Playbook Path Resolution ───────────────────────────────────────────────
+
+/**
+ * Resolve playbook file path, checking project-local override first.
+ * If projects/<projectName>/playbooks/<playbookType>.md exists, use it.
+ * Otherwise fall back to the global playbooks/<playbookType>.md.
+ * @param {string|null|undefined} projectName — project name (directory under projects/)
+ * @param {string} playbookType — playbook type name (e.g. 'implement', 'review')
+ * @returns {string} absolute path to the playbook file
+ */
+function resolvePlaybookPath(projectName, playbookType) {
+  if (projectName) {
+    const localPath = path.join(MINIONS_DIR, 'projects', projectName, 'playbooks', `${playbookType}.md`);
+    try {
+      fs.accessSync(localPath, fs.constants.R_OK);
+      return localPath;
+    } catch { /* no local override — fall through to global */ }
+  }
+  return path.join(PLAYBOOKS_DIR, `${playbookType}.md`);
+}
+
 // ─── Playbook Renderer ──────────────────────────────────────────────────────
 
 function renderPlaybook(type, vars) {
-  const pbPath = path.join(PLAYBOOKS_DIR, `${type}.md`);
+  const projectName = vars.project_name || null;
+  const pbPath = resolvePlaybookPath(projectName, type);
   let content;
   try { content = fs.readFileSync(pbPath, 'utf8'); } catch {
     log('warn', `Playbook not found: ${type}`);
@@ -361,6 +383,9 @@ function renderPlaybook(type, vars) {
     return null;
   }
 
+  // Capture which vars are actually referenced in the template before substitution
+  const referencedVars = new Set((content.match(/\{\{(\w+)\}\}/g) || []).map(m => m.slice(2, -2)));
+
   // Process conditional blocks: {{#key}}...{{/key}} — include block only if key is truthy
   content = content.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_, key, block) => {
     const val = allVars[key];
@@ -380,9 +405,9 @@ function renderPlaybook(type, vars) {
     log('warn', `Playbook "${type}": substituted values contain unresolved {{...}} patterns (potential self-reference): ${selfRefVars.join(', ')}`);
   }
 
-  // Warn on variables that resolved to empty string (skip known-optional vars)
+  // Warn on variables that resolved to empty string — only for vars actually used in the template
   const emptyVars = Object.entries(allVars)
-    .filter(([key, val]) => String(val) === '' && !PLAYBOOK_OPTIONAL_VARS.has(key))
+    .filter(([key, val]) => String(val) === '' && referencedVars.has(key) && !PLAYBOOK_OPTIONAL_VARS.has(key))
     .map(([key]) => key);
   if (emptyVars.length > 0) {
     log('warn', `Playbook "${type}": template variables resolved to empty string: ${emptyVars.join(', ')}`);
@@ -565,6 +590,7 @@ function buildPrDispatch(agentId, config, project, pr, type, extraVars, taskLabe
 
 module.exports = {
   renderPlaybook,
+  resolvePlaybookPath,
   validatePlaybookVars,
   PLAYBOOK_REQUIRED_VARS,
   PLAYBOOK_OPTIONAL_VARS,

package/engine/shared.js

@@ -613,6 +613,11 @@ const PR_STATUS = { ACTIVE: 'active', MERGED: 'merged', ABANDONED: 'abandoned',
 // PRs eligible for polling (status/build/comment checks) — excludes terminal statuses
 const PR_POLLABLE_STATUSES = new Set([PR_STATUS.ACTIVE, PR_STATUS.LINKED]);
 
+// Watch statuses — engine-level persistent watches that survive restarts
+const WATCH_STATUS = { ACTIVE: 'active', PAUSED: 'paused', TRIGGERED: 'triggered', EXPIRED: 'expired' };
+const WATCH_TARGET_TYPE = { PR: 'pr', WORK_ITEM: 'work-item' };
+const WATCH_CONDITION = { MERGED: 'merged', BUILD_FAIL: 'build-fail', BUILD_PASS: 'build-pass', COMPLETED: 'completed', FAILED: 'failed', STATUS_CHANGE: 'status-change', ANY: 'any' };
+
 /** Update per-agent review metrics (prsApproved/prsRejected). Only writes for configured agents. */
 function trackReviewMetric(pr, newReviewStatus, config) {
   if (newReviewStatus !== 'approved' && newReviewStatus !== 'changes-requested') return;
@@ -1138,6 +1143,7 @@ module.exports = {
   classifyInboxItem,
   ENGINE_DEFAULTS,
   WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
+  WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,
   FAILURE_CLASS, ESCALATION_POLICY, COMPLETION_FIELDS,
   DEFAULT_AGENT_METRICS,

package/engine/watches.js

@@ -0,0 +1,306 @@
+/**
+ * engine/watches.js -- Persistent watch jobs that survive engine restarts.
+ * Zero dependencies -- uses only Node.js built-ins + engine/shared.js.
+ *
+ * Watches monitor targets (PRs, work items, branches) for conditions (merged,
+ * build-fail, completed, etc.) and fire inbox notifications when triggered.
+ *
+ * State stored in engine/watches.json — concurrency-safe via mutateJsonFileLocked.
+ */
+
+const path = require('path');
+const shared = require('./shared');
+const { safeJson, mutateJsonFileLocked, ts, uid, log, writeToInbox,
+  WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS } = shared;
+
+// Dynamic path — respects MINIONS_TEST_DIR for test isolation
+function _watchesPath() { return path.join(shared.MINIONS_DIR, 'engine', 'watches.json'); }
+
+// Default check interval: 5 minutes (300000ms). Engine tick runs every 60s,
+// so watches are checked every N ticks where N = ceil(interval / tickInterval).
+const DEFAULT_WATCH_INTERVAL = 300000;
+
+/**
+ * Read all watches from disk.
+ * @returns {Array<object>}
+ */
+function getWatches() {
+  return safeJson(_watchesPath()) || [];
+}
+
+/**
+ * Create a new watch. Validates required fields and writes atomically.
+ * @param {object} opts - Watch definition
+ * @returns {object} - Created watch
+ */
+function createWatch({ target, targetType, condition, interval, owner, description, project, notify, stopAfter, onNotMet }) {
+  if (!target) throw new Error('target is required');
+  if (!targetType || !Object.values(WATCH_TARGET_TYPE).includes(targetType)) {
+    throw new Error(`targetType must be one of: ${Object.values(WATCH_TARGET_TYPE).join(', ')}`);
+  }
+  if (!condition || !Object.values(WATCH_CONDITION).includes(condition)) {
+    throw new Error(`condition must be one of: ${Object.values(WATCH_CONDITION).join(', ')}`);
+  }
+
+  const watch = {
+    id: 'watch-' + uid(),
+    target,
+    targetType,
+    condition,
+    interval: Math.max(60000, Number(interval) || DEFAULT_WATCH_INTERVAL),
+    owner: owner || 'human',
+    status: WATCH_STATUS.ACTIVE,
+    description: description || `Watch ${target} for ${condition}`,
+    project: project || null,
+    notify: notify || 'inbox',
+    stopAfter: Number(stopAfter) || 0,   // 0 = run forever; N = expire after N triggers
+    onNotMet: onNotMet || null,          // null | 'notify' — action per poll when condition not met
+    triggerCount: 0,
+    created_at: ts(),
+    last_checked: null,
+    last_triggered: null,
+  };
+
+  mutateJsonFileLocked(_watchesPath(), (watches) => {
+    if (!Array.isArray(watches)) watches = [];
+    watches.push(watch);
+    return watches;
+  }, { defaultValue: [] });
+
+  log('info', `Watch created: ${watch.id} → ${watch.target} (${watch.condition})`);
+  return watch;
+}
+
+/**
+ * Update a watch by ID. Only updates provided fields.
+ * @param {string} id - Watch ID
+ * @param {object} updates - Fields to update
+ * @returns {object|null} - Updated watch or null if not found
+ */
+function updateWatch(id, updates) {
+  if (!id) throw new Error('id is required');
+  // Validate status before entering the lock — reject early, never persist invalid values
+  if (updates.status !== undefined && !Object.values(WATCH_STATUS).includes(updates.status)) {
+    log('warn', `Invalid watch status: ${updates.status}`);
+    return null;
+  }
+  let found = null;
+  mutateJsonFileLocked(_watchesPath(), (watches) => {
+    if (!Array.isArray(watches)) return watches;
+    const watch = watches.find(w => w.id === id);
+    if (!watch) return watches;
+    // Only allow safe field updates
+    const allowed = ['status', 'interval', 'description', 'notify', 'stopAfter', 'onNotMet', 'condition'];
+    for (const key of allowed) {
+      if (updates[key] !== undefined) watch[key] = updates[key];
+    }
+    found = { ...watch };
+    return watches;
+  }, { defaultValue: [] });
+  return found;
+}
+
+/**
+ * Delete a watch by ID.
+ * @param {string} id
+ * @returns {boolean} - true if deleted
+ */
+function deleteWatch(id) {
+  if (!id) return false;
+  let deleted = false;
+  mutateJsonFileLocked(_watchesPath(), (watches) => {
+    if (!Array.isArray(watches)) return watches;
+    const idx = watches.findIndex(w => w.id === id);
+    if (idx >= 0) {
+      watches.splice(idx, 1);
+      deleted = true;
+    }
+    return watches;
+  }, { defaultValue: [] });
+  if (deleted) log('info', `Watch deleted: ${id}`);
+  return deleted;
+}
+
+/**
+ * Evaluate whether a watch condition is met given current state.
+ * @param {object} watch - The watch object
+ * @param {object} state - { pullRequests, workItems } current state
+ * @returns {{ triggered: boolean, message: string }}
+ */
+function evaluateWatch(watch, state) {
+  const { target, targetType, condition } = watch;
+
+  if (targetType === WATCH_TARGET_TYPE.PR) {
+    const pr = (state.pullRequests || []).find(p =>
+      String(p.prNumber) === String(target) || p.id === target
+    );
+    if (!pr) return { triggered: false, message: `PR ${target} not found` };
+
+    // Store previous state for status-change detection
+    const prevState = watch._lastState || {};
+
+    switch (condition) {
+      case WATCH_CONDITION.MERGED:
+        return { triggered: pr.status === 'merged', message: pr.status === 'merged' ? `PR ${target} was merged` : '' };
+      case WATCH_CONDITION.BUILD_FAIL:
+        return { triggered: pr.buildStatus === 'failing', message: pr.buildStatus === 'failing' ? `PR ${target} build is failing` : '' };
+      case WATCH_CONDITION.BUILD_PASS:
+        return { triggered: pr.buildStatus === 'passing', message: pr.buildStatus === 'passing' ? `PR ${target} build is passing` : '' };
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== pr.status;
+        return { triggered: changed, message: changed ? `PR ${target} status changed: ${prevState.status} → ${pr.status}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined && (
+          prevState.status !== pr.status ||
+          prevState.buildStatus !== pr.buildStatus ||
+          prevState.reviewStatus !== pr.reviewStatus
+        );
+        return { triggered: anyChanged, message: anyChanged ? `PR ${target} changed` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  }
+
+  if (targetType === WATCH_TARGET_TYPE.WORK_ITEM) {
+    const wi = (state.workItems || []).find(w => w.id === target);
+    if (!wi) return { triggered: false, message: `Work item ${target} not found` };
+
+    const prevState = watch._lastState || {};
+
+    switch (condition) {
+      case WATCH_CONDITION.COMPLETED:
+        return { triggered: shared.DONE_STATUSES.has(wi.status), message: shared.DONE_STATUSES.has(wi.status) ? `Work item ${target} completed (${wi.status})` : '' };
+      case WATCH_CONDITION.FAILED:
+        return { triggered: wi.status === shared.WI_STATUS.FAILED, message: wi.status === shared.WI_STATUS.FAILED ? `Work item ${target} failed` : '' };
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== wi.status;
+        return { triggered: changed, message: changed ? `Work item ${target} status: ${prevState.status} → ${wi.status}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined && prevState.status !== wi.status;
+        return { triggered: anyChanged, message: anyChanged ? `Work item ${target} changed (${wi.status})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  }
+
+  return { triggered: false, message: `Unknown target type: ${targetType}` };
+}
+
+/**
+ * Check all active watches against current state. Called from engine tick.
+ * @param {object} config - Engine config
+ * @param {object} state - { pullRequests, workItems } from queries
+ */
+function checkWatches(config, state) {
+  const now = Date.now();
+  // Collect notifications to fire AFTER lock is released — never do I/O inside the lock callback
+  const notifications = [];
+
+  mutateJsonFileLocked(_watchesPath(), (watches) => {
+    if (!Array.isArray(watches) || watches.length === 0) return watches;
+
+    for (const watch of watches) {
+      try {
+        if (watch.status !== WATCH_STATUS.ACTIVE) continue;
+
+        // Check interval — skip if checked too recently
+        if (watch.last_checked) {
+          const elapsed = now - new Date(watch.last_checked).getTime();
+          if (elapsed < watch.interval) continue;
+        }
+
+        watch.last_checked = ts();
+
+        // Initialize baseline state on first check for change-detection conditions.
+        // Without this, status-change/any conditions would have no previous state to compare.
+        if (!watch._lastState || Object.keys(watch._lastState).length === 0) {
+          watch._lastState = _captureState(watch, state);
+        }
+
+        const result = evaluateWatch(watch, state);
+        if (result.triggered) {
+          watch.triggerCount = (watch.triggerCount || 0) + 1;
+          watch.last_triggered = ts();
+          watch._lastTriggerMessage = result.message;
+
+          // Queue trigger notification — unique key per trigger to avoid overwriting previous messages
+          if (watch.notify === 'inbox' && watch.owner) {
+            notifications.push({
+              type: 'trigger', owner: watch.owner,
+              slug: `watch-${watch.id}-${watch.triggerCount}`,
+              body: `## Watch Triggered: ${watch.description}\n\n${result.message}\n\nWatch ID: ${watch.id} | Target: ${watch.target} | Condition: ${watch.condition}`,
+            });
+          }
+          log('info', `Watch triggered: ${watch.id} — ${result.message}`);
+
+          // Expire: absolute conditions auto-expire when stopAfter is 0 (fire-once semantics),
+          // change-based conditions (status-change, any) respect stopAfter literally (0 = run forever).
+          const isAbsolute = WATCH_ABSOLUTE_CONDITIONS.has(watch.condition);
+          if (watch.stopAfter > 0 && watch.triggerCount >= watch.stopAfter) {
+            watch.status = WATCH_STATUS.EXPIRED;
+            log('info', `Watch expired (stopAfter limit reached): ${watch.id}`);
+          } else if (isAbsolute && watch.stopAfter === 0) {
+            watch.status = WATCH_STATUS.EXPIRED;
+            log('info', `Watch expired (absolute condition auto-expire): ${watch.id}`);
+          }
+        } else if (watch.onNotMet === 'notify' && watch.owner) {
+          // Queue per-poll notification when condition is not yet met — unique key per poll
+          notifications.push({
+            type: 'poll', owner: watch.owner,
+            slug: `watch-poll-${watch.id}-${Date.now()}`,
+            body: `## Watch Polling: ${watch.description}\n\nCondition not yet met (${watch.condition}) — still watching.\n\nWatch ID: ${watch.id} | Target: ${watch.target} | Checks so far: ${watch.triggerCount || 0}`,
+          });
+        }
+
+        // Capture state for change detection on next check
+        watch._lastState = _captureState(watch, state);
+      } catch (err) {
+        log('warn', `Watch check error (${watch.id}): ${err.message}`);
+      }
+    }
+
+    return watches;
+  }, { defaultValue: [] });
+
+  // Fire notifications outside the lock — writeToInbox does disk I/O
+  for (const n of notifications) {
+    try {
+      writeToInbox(n.owner, n.slug, n.body);
+    } catch (err) {
+      log('warn', `Watch notification error: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Internal: capture state snapshot for a watch target.
+ */
+function _captureState(watch, state) {
+  if (watch.targetType === WATCH_TARGET_TYPE.PR) {
+    const pr = (state.pullRequests || []).find(p =>
+      String(p.prNumber) === String(watch.target) || p.id === watch.target
+    );
+    if (pr) return { status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus };
+  }
+  if (watch.targetType === WATCH_TARGET_TYPE.WORK_ITEM) {
+    const wi = (state.workItems || []).find(w => w.id === watch.target);
+    if (wi) return { status: wi.status };
+  }
+  return {};
+}
+
+module.exports = {
+  DEFAULT_WATCH_INTERVAL,
+  getWatches,
+  createWatch,
+  updateWatch,
+  deleteWatch,
+  evaluateWatch,
+  checkWatches,
+  _captureState,  // exported for testing
+  _watchesPath,   // exported for testing — dynamic, respects MINIONS_TEST_DIR
+};

package/engine.js

@@ -1984,46 +1984,6 @@ async function discoverFromPrs(config, project) {
       if (item) { newWork.push(item); }
     }
 
-    // Re-review after fix: only trigger when fixedAt > lastReviewedAt (not a broad !alreadyReviewed
-    // fallback — that caused infinite re-review loops on GitHub where self-approval is blocked)
-    const fixedAfterReview = !!(pr.minionsReview?.fixedAt &&
-      pr.lastReviewedAt && pr.minionsReview.fixedAt > pr.lastReviewedAt);
-    const needsReReview = autoReview && reviewStatus === 'waiting' &&
-      fixedAfterReview && !evalEscalated;
-    if (needsReReview) {
-      const key = `review-${project?.name || 'default'}-${pr.id}`;
-      // Skip isAlreadyDispatched — fixedAfterReview/alreadyReviewed already dedup; the 1hr
-      // completed-dispatch window would block legitimate re-reviews within the hour after a fix
-      if (isOnCooldown(key, cooldownMs)) continue;
-
-      // Pre-dispatch live vote check — cached 'waiting' may be stale if reviewer already acted
-      try {
-        const checkFn = project.repoHost === 'github' ? ghCheckLiveReview : adoCheckLiveReview;
-        const liveStatus = await checkFn(pr, project);
-        if (liveStatus && liveStatus !== 'waiting') {
-          log('info', `Pre-dispatch vote check: ${pr.id} is ${liveStatus} (cached was waiting) — skipping re-review`);
-          if (pr.reviewStatus !== 'approved') pr.reviewStatus = liveStatus;
-          try {
-            mutateJsonFileLocked(projectPrPath(project), data => {
-              if (!Array.isArray(data)) return data;
-              const target = data.find(p => p.id === pr.id);
-              if (target && target.reviewStatus !== 'approved') target.reviewStatus = liveStatus;
-              return data;
-            });
-          } catch {}
-          continue;
-        }
-      } catch (e) { log('warn', `Pre-dispatch vote check for ${pr.id}: ${e.message}`); }
-
-      const agentId = resolveAgent('review', config);
-      if (!agentId) continue;
-      const item = buildPrDispatch(agentId, config, project, pr, 'review', {
-        pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: pr.branch || '',
-        pr_author: pr.agent || '', pr_url: pr.url || '',
-      }, `Review ${pr.id}: ${pr.title}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
-      if (item) { newWork.push(item); setCooldown(key); }
-    }
-
     // PRs with changes requested → route back to author for fix
     let fixDispatched = false;
     if (reviewStatus === 'changes-requested' && !awaitingReReview && !evalEscalated) {
@@ -2037,7 +1997,7 @@ async function discoverFromPrs(config, project) {
         review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
       }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
       if (item) {
-        newWork.push(item); fixDispatched = true;
+        newWork.push(item); setCooldown(key); fixDispatched = true;
         // Increment review→fix cycle counter
         try {
           mutatePullRequests(projectPrPath(project), prs => {
@@ -2075,7 +2035,7 @@ async function discoverFromPrs(config, project) {
         reviewer: 'Human Reviewer',
         review_note: reviewNote,
       }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, source: 'pr-human-feedback', pr, branch: pr.branch, project: projMeta });
-      if (item) { newWork.push(item); fixDispatched = true; }
+      if (item) { newWork.push(item); setCooldown(key); fixDispatched = true; }
     }
 
     // PRs with build failures — route to author (has session context from implementing)
@@ -2124,7 +2084,7 @@ async function discoverFromPrs(config, project) {
         review_note: reviewNote,
       }, `Fix build failure on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
       if (item) {
-        newWork.push(item);
+        newWork.push(item); setCooldown(key);
         // Increment build fix attempts counter
         try {
           const prPath = projectPrPath(project);
@@ -2181,6 +2141,7 @@ async function discoverFromPrs(config, project) {
           }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
           if (item) {
             newWork.push(item);
+            setCooldown(key);
             // Record dispatch timestamp so re-dispatch is suppressed during ADO lag window
             try {
               mutatePullRequests(projectPrPath(project), prs => {
@@ -3166,6 +3127,24 @@ async function tickInner() {
     safe('runCleanup', () => runCleanup(config));
   }
 
+  // 2.55. Check persistent watches (every 3 ticks = ~3 minutes)
+  if (tickCount % 3 === 0) {
+    safe('checkWatches', () => {
+      const { checkWatches } = require('./engine/watches');
+      const pullRequests = PROJECTS.flatMap(p => {
+        const prPath = path.join(MINIONS_DIR, 'projects', p.name, 'pull-requests.json');
+        return safeJson(prPath) || [];
+      });
+      const workItems = PROJECTS.flatMap(p => {
+        const wiPath = path.join(MINIONS_DIR, 'projects', p.name, 'work-items.json');
+        return safeJson(wiPath) || [];
+      });
+      // Also include central work items
+      const centralWi = safeJson(path.join(MINIONS_DIR, 'work-items.json')) || [];
+      checkWatches(config, { pullRequests, workItems: [...workItems, ...centralWi] });
+    });
+  }
+
   const adoPollEnabled = config.engine?.adoPollEnabled ?? DEFAULTS.adoPollEnabled;
   const ghPollEnabled = config.engine?.ghPollEnabled ?? DEFAULTS.ghPollEnabled;
   const adoPollStatusEvery = Math.max(1, Number(config.engine?.adoPollStatusEvery) || DEFAULTS.adoPollStatusEvery);
@@ -3372,7 +3351,7 @@ async function tickInner() {
     if (busyAgents.has(item.agent)) {
       // Agent busy reassignment: if item has been waiting on a busy agent past the threshold,
       // try to find an alternative agent via routing. Skip explicitly assigned items.
-      const reassignMs = config.engine?.agentBusyReassignMs ?? ENGINE_DEFAULTS.agentBusyReassignMs;
+      const reassignMs = config.engine?.agentBusyReassignMs ?? DEFAULTS.agentBusyReassignMs;
       const isExplicitReassign = !!item.meta?.item?.agent;
       if (!isExplicitReassign && reassignMs > 0 && item._agentBusySince) {
         const busySinceMs = new Date(item._agentBusySince).getTime();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.976",
+  "version": "0.1.978",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"

package/prompts/cc-system.md

@@ -82,6 +82,9 @@ Additional actions (all take `id` or `file` as primary key):
 - Meetings: add-meeting-note (id, note), advance-meeting (id), end-meeting (id), archive-meeting (id), unarchive-meeting (id), delete-meeting (id)
 - Work item ops: delete-work-item (id, source), archive-work-item (id), work-item-feedback (id, rating: up/down, comment), reopen-work-item (id, project[, description] — reopen a done/failed item back to pending)
 - PRD ops: edit-prd-item, remove-prd-item, reopen-prd-item (id, file — re-dispatches on existing branch)
+- **create-watch**: target, targetType (pr/work-item/branch), condition (merged/build-fail/build-pass/completed/failed/status-change/any), interval ("15m", "1h", "30s" — default "5m"), owner (agent id or "human"), description, project, stopAfter (0=run forever, 1=expire on first match, N=expire after N matches), onNotMet (null=do nothing, "notify"=write to inbox each poll while condition not met)
+  Example: user says "check PR 1065 build every 15 min until green" → `{"type":"create-watch","target":"1065","targetType":"pr","condition":"build-pass","interval":"15m","stopAfter":1,"description":"Watch PR 1065 build until green"}`
+  Example: user says "ping me every 15 min while build is still failing" → `{"type":"create-watch","target":"1065","targetType":"pr","condition":"build-pass","interval":"15m","stopAfter":1,"onNotMet":"notify","description":"Watch PR 1065 build — notify each poll"}`
 - KB/Inbox: promote-to-kb (file, category), kb-sweep, toggle-kb-pin (key)
 - Plan lifecycle: revise-plan (file, feedback — dispatches agent to revise)
 - Pipeline: continue-pipeline (id — resume past wait stage)