@yemi33/minions 0.1.1852 → 0.1.1853

package/CHANGELOG.md

@@ -1,8 +1,16 @@
 # Changelog
 
-## 0.1.1852 (2026-05-10)
+## 0.1.1853 (2026-05-10)
+
+### Features
+- generalize watches infra to support arbitrary target types (#2322)
+- use safeJsonArr in engine/watches.js loadWatches (footgun #2) (#2320)
 
 ### Fixes
+- use safeJsonObj in engine/teams.js (footgun #2) (#2318)
+- use safeJsonArr in engine/github.js PR poller (#2317)
+- guard empty projects[] in cli.js dispatch helpers (#2316)
+- use safeJsonArr in engine/ado.js PR poller (#2315)
 - use DONE_STATUSES constant in getAgents lastAction (#2314)
 
 ## 0.1.1851 (2026-05-10)

package/dashboard/js/render-watches.js

@@ -9,9 +9,23 @@ const _WATCH_STATUS_BADGES = {
   expired: '<span class="pr-badge" style="background:rgba(139,148,158,0.15);color:var(--muted);border-color:var(--muted)">expired</span>',
 };
 
+// Cache of target types fetched from /api/watches/target-types. Populated on
+// first modal open and refreshed per modal show. Each entry:
+//   { value, label, conditions: [...], description }
+let _watchTargetTypesCache = null;
+
+// Built-in fallback labels — used when the API response hasn't loaded yet, or
+// for legacy targetTypes/conditions that may appear on stored watches but not
+// in the live registry. The registry from the API is authoritative when present.
 const _WATCH_TARGET_LABELS = {
-  pr: 'PR',
+  pr: 'Pull Request',
   'work-item': 'Work Item',
+  meeting: 'Meeting',
+  plan: 'Plan / PRD',
+  schedule: 'Schedule',
+  pipeline: 'Pipeline',
+  dispatch: 'Dispatch',
+  agent: 'Agent',
 };
 
 const _WATCH_CONDITION_LABELS = {
@@ -24,8 +38,30 @@ const _WATCH_CONDITION_LABELS = {
   any: 'Any Change',
   'new-comments': 'New Comments',
   'vote-change': 'Vote Change',
+  concluded: 'Concluded',
+  approved: 'Approved',
+  rejected: 'Rejected',
+  'stage-complete': 'Stage Complete',
+  ran: 'Ran',
+  enabled: 'Enabled',
+  disabled: 'Disabled',
+  'activity-change': 'Activity Change',
 };
 
+function _conditionLabel(cond) {
+  if (_WATCH_CONDITION_LABELS[cond]) return _WATCH_CONDITION_LABELS[cond];
+  // Title-case unknown conditions for graceful fallback
+  return String(cond || '').replace(/[-_]+/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+
+function _targetTypeLabel(type) {
+  if (_watchTargetTypesCache) {
+    const hit = _watchTargetTypesCache.find(t => t.value === type);
+    if (hit) return hit.label;
+  }
+  return _WATCH_TARGET_LABELS[type] || (type || '');
+}
+
 function _intervalToHuman(ms) {
   if (!ms) return 'default';
   const sec = Math.floor(ms / 1000);
@@ -83,8 +119,8 @@ function renderWatches(watchesData) {
   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 targetLabel = escHtml(_targetTypeLabel(w.targetType));
+    var condLabel = escHtml(_conditionLabel(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 : '');
@@ -140,8 +176,8 @@ function openWatchDetail(id) {
   var lastChecked = w.last_checked ? formatLocalDateTime(w.last_checked) : 'never';
   var lastTriggered = w.last_triggered ? formatLocalDateTime(w.last_triggered) : 'never';
   var createdAt = w.created_at ? formatLocalDateTime(w.created_at) : 'unknown';
-  var targetLabel = _WATCH_TARGET_LABELS[w.targetType] || w.targetType;
-  var condLabel = _WATCH_CONDITION_LABELS[w.condition] || w.condition;
+  var targetLabel = _targetTypeLabel(w.targetType);
+  var condLabel = _conditionLabel(w.condition);
 
   document.getElementById('modal-title').innerHTML = escHtml(w.description || w.target) +
     ' <div style="display:flex;gap:4px;margin-top:4px">' +
@@ -220,33 +256,33 @@ function deleteWatch(id) {
 
 // ─── Create Watch Modal ─────────────────────────────────────────────────────
 
+// Build the form HTML using the (cached) target-type registry. Target type
+// and condition options come from the live registry — no hardcoded list — so
+// new types registered server-side appear here without UI changes.
 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' },
-    { value: 'new-comments', label: 'New Comments' },
-    { value: 'vote-change', label: 'Vote 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 targetTypes = _watchTargetTypesCache && _watchTargetTypesCache.length
+    ? _watchTargetTypesCache
+    : [{ value: 'pr', label: 'Pull Request', conditions: ['merged','build-fail','build-pass','status-change','any','new-comments','vote-change'] }];
+
+  var ttOpts = targetTypes.map(function(t) {
+    return '<option value="' + escHtml(t.value) + '">' + escHtml(t.label) + '</option>';
+  }).join('');
+
+  // Condition options for the initially-selected target type (first entry).
+  var initialConds = (targetTypes[0] && targetTypes[0].conditions) || [];
+  var condOpts = initialConds.map(function(c) {
+    return '<option value="' + escHtml(c) + '">' + escHtml(_conditionLabel(c)) + '</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)">Target (e.g. PR number, work item ID, meeting/plan/schedule/pipeline/dispatch/agent ID)<input id="watch-edit-target" placeholder="e.g. 1057, W-abc123, M-xyz, schedule-42" style="' + inputStyle + '"></label>' +
+    '<label style="color:var(--text);font-size:var(--text-md)">Target Type<select id="watch-edit-target-type" style="' + inputStyle + '" onchange="_updateWatchConditionOptions()">' + 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>' +
@@ -257,7 +293,19 @@ function _watchFormHtml() {
   '</div>';
 }
 
-function openCreateWatchModal() {
+// Refresh the condition <select> based on the currently selected target type.
+function _updateWatchConditionOptions() {
+  var ttSel = document.getElementById('watch-edit-target-type');
+  var condSel = document.getElementById('watch-edit-condition');
+  if (!ttSel || !condSel || !_watchTargetTypesCache) return;
+  var entry = _watchTargetTypesCache.find(function(t) { return t.value === ttSel.value; });
+  var conditions = (entry && entry.conditions) || [];
+  condSel.innerHTML = conditions.map(function(c) {
+    return '<option value="' + escHtml(c) + '">' + escHtml(_conditionLabel(c)) + '</option>';
+  }).join('');
+}
+
+function _renderCreateWatchModal() {
   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();
@@ -266,6 +314,23 @@ function openCreateWatchModal() {
   document.getElementById('modal').classList.add('open');
 }
 
+function openCreateWatchModal() {
+  // Render an initial form immediately (uses cached target types if present).
+  _renderCreateWatchModal();
+  // Fetch the live registry and re-render so newly registered target types
+  // appear without requiring a page reload.
+  fetch('/api/watches/target-types').then(function(res) { return res.json(); }).then(function(data) {
+    if (data && Array.isArray(data.targetTypes) && data.targetTypes.length > 0) {
+      _watchTargetTypesCache = data.targetTypes;
+      // Only re-render if the modal is still showing the create-watch form
+      var titleEl = document.getElementById('modal-title');
+      if (titleEl && titleEl.textContent.indexOf('Create Watch') === 0) {
+        _renderCreateWatchModal();
+      }
+    }
+  }).catch(function() { /* fall back to baked-in defaults */ });
+}
+
 function submitWatch() {
   var target = (document.getElementById('watch-edit-target') || {}).value || '';
   var targetType = (document.getElementById('watch-edit-target-type') || {}).value || 'pr';
@@ -324,4 +389,5 @@ window.MinionsWatches = {
   deleteWatch: deleteWatch,
   _watchPrev: _watchPrev,
   _watchNext: _watchNext,
+  _updateWatchConditionOptions: _updateWatchConditionOptions,
 };

package/dashboard.js

@@ -6301,6 +6301,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     return jsonReply(res, 200, { watches: watchesMod.getWatches() });
   }
 
+  async function handleWatchesTargetTypes(req, res) {
+    return jsonReply(res, 200, { targetTypes: watchesMod.listTargetTypes() });
+  }
+
   async function handleWatchesCreate(req, res) {
     const body = await readBody(req);
     const { target, targetType, condition, interval, owner, description, project, notify, stopAfter, onNotMet } = body;
@@ -7313,6 +7317,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // Watches
     { method: 'GET', path: '/api/watches', desc: 'List all watches', handler: handleWatchesList },
+    { method: 'GET', path: '/api/watches/target-types', desc: 'List registered watch target types and their valid conditions', handler: handleWatchesTargetTypes },
     { 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 },

package/engine/ado.js

@@ -1128,7 +1128,7 @@ async function reconcilePrs(config) {
     if (adoPrs.length === 0) continue;
 
     const prPath = shared.projectPrPath(project);
-    const existingPrs = shared.safeJson(prPath) || [];
+    const existingPrs = shared.safeJsonArr(prPath);
     shared.normalizePrRecords(existingPrs, project);
     const existingIds = new Set(existingPrs.map(p => p.id));
     let projectAdded = 0;
@@ -1136,9 +1136,9 @@ async function reconcilePrs(config) {
 
     // Load work items to match branches to work item IDs
     const wiPath = shared.projectWorkItemsPath(project);
-    const workItems = shared.safeJson(wiPath) || [];
+    const workItems = shared.safeJsonArr(wiPath);
     const centralWiPath = path.join(shared.MINIONS_DIR, 'work-items.json');
-    const centralItems = shared.safeJson(centralWiPath) || [];
+    const centralItems = shared.safeJsonArr(centralWiPath);
     const allItems = [...workItems, ...centralItems];
 
     let projectUpdated = 0;

package/engine/cli.js

@@ -1164,7 +1164,7 @@ const commands = {
       console.log(target.error);
       return;
     }
-    const targetProject = target?.project || projects[0];
+    const targetProject = target?.project || (projects.length > 0 ? projects[0] : null);
     const wiPath = projectWorkItemsPath(targetProject);
     let item;
     mutateWorkItems(wiPath, items => {
@@ -1212,7 +1212,7 @@ const commands = {
       console.log(target.error);
       return;
     }
-    const targetProject = target?.project || projects[0];
+    const targetProject = target?.project || (projects.length > 0 ? projects[0] : null);
 
     if (!targetProject) {
       console.log('No projects configured. Run: minions add <dir>');

package/engine/github.js

@@ -5,7 +5,7 @@
  */
 
 const shared = require('./shared');
-const { exec, execAsync, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeWrite, mutateJsonFileLocked, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, createThrottleTracker, getProjectOrg } = shared;
+const { exec, execAsync, getProjects, projectPrPath, projectWorkItemsPath, safeJson, safeJsonArr, safeWrite, mutateJsonFileLocked, MINIONS_DIR, getPrLinks, backfillPrPrdItems, log, ts, dateStamp, PR_STATUS, PR_POLLABLE_STATUSES, createThrottleTracker, getProjectOrg } = shared;
 const { getPrs } = require('./queries');
 const path = require('path');
 
@@ -320,7 +320,7 @@ async function forEachActiveGhPr(config, callback) {
 
   // Also poll manually-linked PRs from central pull-requests.json (extract slug from URL)
   const centralPath = path.join(MINIONS_DIR, 'pull-requests.json');
-  const centralPrs = safeJson(centralPath) || [];
+  const centralPrs = safeJsonArr(centralPath);
   const activeCentral = centralPrs.filter(pr => PR_POLLABLE_STATUSES.has(pr.status) && pr.url);
   let centralUpdated = 0;
   const updatedCentralRecords = [];
@@ -727,7 +727,7 @@ async function reconcilePrs(config) {
     if (existingPrs.length === 0) {
       try {
         const wiPath = projectWorkItemsPath(project);
-        const wis = safeJson(wiPath) || [];
+        const wis = safeJsonArr(wiPath);
         if (wis.length === 0) continue;
       } catch { continue; }
     }
@@ -748,7 +748,7 @@ async function reconcilePrs(config) {
     if (ghPrs.length === 0) continue;
 
     const prPath = projectPrPath(project);
-    const currentPrs = safeJson(prPath) || [];
+    const currentPrs = safeJsonArr(prPath);
     shared.normalizePrRecords(currentPrs, project);
     const existingIds = new Set(currentPrs.map(p => p.id));
     let metadataUpdated = 0;
@@ -756,9 +756,9 @@ async function reconcilePrs(config) {
 
     // Load work items to match branches
     const wiPath = projectWorkItemsPath(project);
-    const workItems = safeJson(wiPath) || [];
+    const workItems = safeJsonArr(wiPath);
     const centralWiPath = path.join(MINIONS_DIR, 'work-items.json');
-    const centralItems = safeJson(centralWiPath) || [];
+    const centralItems = safeJsonArr(centralWiPath);
     const allItems = [...workItems, ...centralItems];
 
     for (const ghPr of ghPrs) {

package/engine/shared.js

@@ -1553,13 +1553,47 @@ const PR_PENDING_REASON = {
 
 // 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', NEW_COMMENTS: 'new-comments', VOTE_CHANGE: 'vote-change' };
+// Built-in target types. Additional types may be registered at runtime via
+// engine/watches.registerTargetType — this object lists the types shipped in
+// the engine for use in switch statements and constants comparisons. The
+// actual allowlist for createWatch/dashboard validation is the registry in
+// engine/watches.js (see getTargetTypes()).
+const WATCH_TARGET_TYPE = {
+  PR: 'pr',
+  WORK_ITEM: 'work-item',
+  MEETING: 'meeting',
+  PLAN: 'plan',
+  SCHEDULE: 'schedule',
+  PIPELINE: 'pipeline',
+  DISPATCH: 'dispatch',
+  AGENT: 'agent',
+};
+const WATCH_CONDITION = {
+  MERGED: 'merged',
+  BUILD_FAIL: 'build-fail',
+  BUILD_PASS: 'build-pass',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  STATUS_CHANGE: 'status-change',
+  ANY: 'any',
+  NEW_COMMENTS: 'new-comments',
+  VOTE_CHANGE: 'vote-change',
+  // ── Generalized target-type conditions ────────────────────────────────────
+  CONCLUDED: 'concluded',           // meeting reached terminal status (completed/archived)
+  APPROVED: 'approved',             // plan/PRD approved
+  REJECTED: 'rejected',             // plan/PRD rejected
+  STAGE_COMPLETE: 'stage-complete', // pipeline run finished a stage (any new stage flipped to terminal)
+  RAN: 'ran',                       // schedule lastRun changed
+  ENABLED: 'enabled',               // schedule enabled
+  DISABLED: 'disabled',             // schedule disabled
+  ACTIVITY_CHANGE: 'activity-change', // agent transitioned status (e.g. idle → working)
+};
 // Absolute conditions auto-expire on first trigger when stopAfter=0 (fire-once semantics).
-// Change-based conditions (status-change, any) run forever when stopAfter=0.
+// Change-based conditions (status-change, any, *-change) run forever when stopAfter=0.
 const WATCH_ABSOLUTE_CONDITIONS = new Set([
   WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
   WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
+  WATCH_CONDITION.CONCLUDED, WATCH_CONDITION.APPROVED, WATCH_CONDITION.REJECTED,
 ]);
 
 /** Update per-agent review metrics (prsApproved/prsRejected). Only writes for configured agents. */

package/engine/teams.js

@@ -8,7 +8,7 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { log, safeRead, safeJson, mutateJsonFileLocked, ENGINE_DEFAULTS } = shared;
+const { log, safeRead, safeJson, safeJsonObj, mutateJsonFileLocked, ENGINE_DEFAULTS } = shared;
 const { ENGINE_DIR, getConfig } = queries;
 const cards = require('./teams-cards');
 
@@ -150,7 +150,7 @@ function saveConversationRef(key, ref) {
  */
 function getConversationRef(key) {
   if (!key) return null;
-  const state = safeJson(TEAMS_STATE_PATH) || {};
+  const state = safeJsonObj(TEAMS_STATE_PATH);
   return state.conversations?.[key]?.ref || null;
 }
 
@@ -466,7 +466,7 @@ async function teamsPostCCResponse(userMessage, ccResponse) {
   const card = cards.buildCCResponseCard(userMessage, ccResponse);
 
   // Find first available conversation ref
-  const state = safeJson(TEAMS_STATE_PATH) || {};
+  const state = safeJsonObj(TEAMS_STATE_PATH);
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) {
     log('info', 'Teams CC mirror skipped — no conversation refs stored');
@@ -498,7 +498,7 @@ async function teamsNotifyCompletion(dispatchItem, result, agentId) {
   const card = cards.buildCompletionCard(agentId, item, result, prUrl || undefined);
 
   // Find first available conversation ref
-  const state = safeJson(TEAMS_STATE_PATH) || {};
+  const state = safeJsonObj(TEAMS_STATE_PATH);
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) return;
 
@@ -531,7 +531,7 @@ async function teamsNotifyPrEvent(pr, event, project, prFilePath) {
   const card = cards.buildPrCard(pr, event, project);
 
   // Find first available conversation ref
-  const state = safeJson(TEAMS_STATE_PATH) || {};
+  const state = safeJsonObj(TEAMS_STATE_PATH);
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) return;
 
@@ -593,7 +593,7 @@ async function teamsNotifyPlanEvent(planInfo, event) {
   const planName = planInfo.name || planInfo.file || 'Unknown plan';
   const card = cards.buildPlanCard(planInfo, event);
 
-  const state = safeJson(TEAMS_STATE_PATH) || {};
+  const state = safeJsonObj(TEAMS_STATE_PATH);
   const convKeys = Object.keys(state.conversations || {});
   if (convKeys.length === 0) return;
 

package/engine/watches.js

@@ -2,15 +2,28 @@
  * 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.
+ * Watches monitor targets (PRs, work items, meetings, plans, schedules,
+ * pipelines, dispatches, agents, ...) for conditions (merged, build-fail,
+ * completed, concluded, approved, etc.) and fire inbox notifications when
+ * triggered.
+ *
+ * Target-type behavior is data-driven via a registry — see TARGET_TYPES below.
+ * Each registered target type provides:
+ *   - label:        human-friendly name shown in dashboard pickers
+ *   - conditions:   array of condition keys this target type accepts
+ *   - fetchEntity:  (target, state) => entity-or-null lookup
+ *   - captureState: (entity) => snapshot for change-detection diffing
+ *   - evaluate:     (condition, entity, prevState, target) => { triggered, message }
+ *
+ * Built-in types: pr, work-item, meeting, plan, schedule, pipeline, dispatch,
+ * agent. Additional types can be added at runtime via registerTargetType().
  *
  * 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,
+const { safeJsonArr, 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
@@ -28,12 +41,57 @@ function findPrByTarget(pullRequests, target) {
   );
 }
 
+// ── Target type registry ─────────────────────────────────────────────────────
+// Built-in target types are registered at module load (see bottom of file).
+// Additional types can be added at runtime via registerTargetType(). The
+// registry IS the allowlist for createWatch / dashboard validation — the old
+// hardcoded "pr or work-item" check is gone.
+const TARGET_TYPES = {};
+
+/**
+ * Register a watch target type.
+ * @param {string} type - Unique key (e.g. 'pr', 'meeting', 'custom-thing')
+ * @param {object} spec - { label, conditions, fetchEntity, captureState, evaluate }
+ *   - label:        string shown in dashboard pickers
+ *   - conditions:   array of condition strings the type accepts
+ *   - fetchEntity:  (target, state) => entity-or-null
+ *   - captureState: (entity) => snapshot object
+ *   - evaluate:     (condition, entity, prevState, target) => { triggered, message }
+ */
+function registerTargetType(type, spec) {
+  if (!type || typeof type !== 'string') throw new Error('registerTargetType: type must be a non-empty string');
+  if (!spec || typeof spec !== 'object') throw new Error('registerTargetType: spec must be an object');
+  for (const k of ['label', 'conditions', 'fetchEntity', 'captureState', 'evaluate']) {
+    if (spec[k] === undefined) throw new Error(`registerTargetType(${type}): spec.${k} is required`);
+  }
+  if (!Array.isArray(spec.conditions) || spec.conditions.length === 0) {
+    throw new Error(`registerTargetType(${type}): spec.conditions must be a non-empty array`);
+  }
+  TARGET_TYPES[type] = spec;
+}
+
+/** Returns the registered spec for a target type, or null. */
+function getTargetType(type) { return TARGET_TYPES[type] || null; }
+
+/**
+ * Returns the list of registered target types as a serializable array
+ * suitable for `GET /api/watches/target-types` and dashboard pickers.
+ */
+function listTargetTypes() {
+  return Object.keys(TARGET_TYPES).sort().map(key => ({
+    value: key,
+    label: TARGET_TYPES[key].label,
+    conditions: [...TARGET_TYPES[key].conditions],
+    description: TARGET_TYPES[key].description || '',
+  }));
+}
+
 /**
  * Read all watches from disk.
  * @returns {Array<object>}
  */
 function getWatches() {
-  return safeJson(_watchesPath()) || [];
+  return safeJsonArr(_watchesPath());
 }
 
 /**
@@ -43,11 +101,12 @@ function getWatches() {
  */
 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 (!targetType || !TARGET_TYPES[targetType]) {
+    throw new Error(`targetType must be one of: ${Object.keys(TARGET_TYPES).sort().join(', ')}`);
   }
-  if (!condition || !Object.values(WATCH_CONDITION).includes(condition)) {
-    throw new Error(`condition must be one of: ${Object.values(WATCH_CONDITION).join(', ')}`);
+  const tt = TARGET_TYPES[targetType];
+  if (!condition || !tt.conditions.includes(condition)) {
+    throw new Error(`condition must be one of: ${tt.conditions.join(', ')} (for targetType ${targetType})`);
   }
 
   const watch = {
@@ -131,79 +190,27 @@ function deleteWatch(id) {
 
 /**
  * Evaluate whether a watch condition is met given current state.
+ * Dispatches to the registered target type's evaluator.
  * @param {object} watch - The watch object
- * @param {object} state - { pullRequests, workItems } current state
+ * @param {object} state - { pullRequests, workItems, meetings?, plans?, schedules?, scheduleRuns?, pipelineRuns?, dispatch?, agents?, config? }
  * @returns {{ triggered: boolean, message: string }}
  */
 function evaluateWatch(watch, state) {
   const { target, targetType, condition } = watch;
-
-  if (targetType === WATCH_TARGET_TYPE.PR) {
-    const pr = findPrByTarget(state.pullRequests, 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` : '' };
-      }
-      case WATCH_CONDITION.NEW_COMMENTS: {
-        const lastCommentDate = pr.humanFeedback?.lastProcessedCommentDate || null;
-        const prevCommentDate = prevState.lastCommentDate || null;
-        const hasNew = lastCommentDate && lastCommentDate !== prevCommentDate;
-        return { triggered: !!hasNew, message: hasNew ? `PR ${target} has a new comment (${lastCommentDate})` : '' };
-      }
-      case WATCH_CONDITION.VOTE_CHANGE: {
-        const changed = prevState.reviewStatus !== undefined && prevState.reviewStatus !== pr.reviewStatus;
-        return { triggered: changed, message: changed ? `PR ${target} vote changed: ${prevState.reviewStatus} → ${pr.reviewStatus}` : '' };
-      }
-      default:
-        return { triggered: false, message: `Unknown condition: ${condition}` };
-    }
+  const tt = TARGET_TYPES[targetType];
+  if (!tt) return { triggered: false, message: `Unknown target type: ${targetType}` };
+  if (!tt.conditions.includes(condition)) return { triggered: false, message: `Unknown condition: ${condition}` };
+
+  const entity = tt.fetchEntity(target, state || {});
+  if (!entity) return { triggered: false, message: `${tt.label} ${target} not found` };
+
+  const prevState = watch._lastState || {};
+  try {
+    return tt.evaluate(condition, entity, prevState, target) || { triggered: false, message: '' };
+  } catch (err) {
+    log('warn', `evaluateWatch ${targetType}/${condition}: ${err.message}`);
+    return { triggered: false, message: `evaluator error: ${err.message}` };
   }
-
-  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}` };
 }
 
 /**
@@ -293,18 +300,374 @@ function checkWatches(config, state) {
 
 /**
  * Internal: capture state snapshot for a watch target.
+ * Dispatches to the registered target type's captureState.
  */
 function _captureState(watch, state) {
-  if (watch.targetType === WATCH_TARGET_TYPE.PR) {
-    const pr = findPrByTarget(state.pullRequests, watch.target);
-    if (pr) return { status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus, lastCommentDate: pr.humanFeedback?.lastProcessedCommentDate || null };
+  const tt = TARGET_TYPES[watch.targetType];
+  if (!tt) return {};
+  const entity = tt.fetchEntity(watch.target, state || {});
+  if (!entity) return {};
+  try {
+    return tt.captureState(entity) || {};
+  } catch (err) {
+    log('warn', `_captureState ${watch.targetType}: ${err.message}`);
+    return {};
   }
-  if (watch.targetType === WATCH_TARGET_TYPE.WORK_ITEM) {
-    const wi = (state.workItems || []).find(w => w.id === watch.target);
-    if (wi) return { status: wi.status };
+}
+
+// ── Built-in target type registrations ───────────────────────────────────────
+
+// PR — pull request status / build / comments / votes
+registerTargetType(WATCH_TARGET_TYPE.PR, {
+  label: 'Pull Request',
+  description: 'Watch a pull request for merge, build, comment, or vote changes',
+  conditions: [
+    WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+    WATCH_CONDITION.NEW_COMMENTS, WATCH_CONDITION.VOTE_CHANGE,
+  ],
+  fetchEntity: (target, state) => findPrByTarget(state.pullRequests, target),
+  captureState: (pr) => ({
+    status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus,
+    lastCommentDate: pr.humanFeedback?.lastProcessedCommentDate || null,
+  }),
+  evaluate: (condition, pr, prevState, target) => {
+    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` : '' };
+      }
+      case WATCH_CONDITION.NEW_COMMENTS: {
+        const lastCommentDate = pr.humanFeedback?.lastProcessedCommentDate || null;
+        const prevCommentDate = prevState.lastCommentDate || null;
+        const hasNew = lastCommentDate && lastCommentDate !== prevCommentDate;
+        return { triggered: !!hasNew, message: hasNew ? `PR ${target} has a new comment (${lastCommentDate})` : '' };
+      }
+      case WATCH_CONDITION.VOTE_CHANGE: {
+        const changed = prevState.reviewStatus !== undefined && prevState.reviewStatus !== pr.reviewStatus;
+        return { triggered: changed, message: changed ? `PR ${target} vote changed: ${prevState.reviewStatus} → ${pr.reviewStatus}` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Work item — completed/failed/status-change
+registerTargetType(WATCH_TARGET_TYPE.WORK_ITEM, {
+  label: 'Work Item',
+  description: 'Watch a work item for completion, failure, or status changes',
+  conditions: [
+    WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: (target, state) => (state.workItems || []).find(w => w.id === target) || null,
+  captureState: (wi) => ({ status: wi.status }),
+  evaluate: (condition, wi, prevState, target) => {
+    switch (condition) {
+      case WATCH_CONDITION.COMPLETED: {
+        const done = shared.DONE_STATUSES.has(wi.status);
+        return { triggered: done, message: done ? `Work item ${target} completed (${wi.status})` : '' };
+      }
+      case WATCH_CONDITION.FAILED: {
+        const failed = wi.status === shared.WI_STATUS.FAILED;
+        return { triggered: failed, message: 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}` };
+    }
+  },
+});
+
+// Meeting — concluded (terminal status) / status-change / any
+const MEETING_TERMINAL = new Set(['completed', 'archived']);
+registerTargetType(WATCH_TARGET_TYPE.MEETING, {
+  label: 'Meeting',
+  description: 'Watch a meeting for conclusion or status changes',
+  conditions: [WATCH_CONDITION.CONCLUDED, WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY],
+  fetchEntity: (target, state) => (state.meetings || []).find(m => m && m.id === target) || null,
+  captureState: (m) => ({ status: m.status }),
+  evaluate: (condition, m, prevState, target) => {
+    switch (condition) {
+      case WATCH_CONDITION.CONCLUDED: {
+        const concluded = MEETING_TERMINAL.has(String(m.status || '').toLowerCase());
+        return { triggered: concluded, message: concluded ? `Meeting ${target} concluded (${m.status})` : '' };
+      }
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== m.status;
+        return { triggered: changed, message: changed ? `Meeting ${target} status: ${prevState.status} → ${m.status}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined && prevState.status !== m.status;
+        return { triggered: anyChanged, message: anyChanged ? `Meeting ${target} changed (${m.status})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Plan / PRD — approved/rejected/completed/status-change/any
+function _findPlan(target, state) {
+  const t = String(target);
+  return (state.plans || []).find(p => {
+    if (!p) return false;
+    if (p._source === t || p._source === t + '.json') return true;
+    if (p._sourcePlan === t || p._sourcePlan === t + '.md') return true;
+    if (p.id === t) return true;
+    return false;
+  }) || null;
+}
+registerTargetType(WATCH_TARGET_TYPE.PLAN, {
+  label: 'Plan / PRD',
+  description: 'Watch a plan/PRD for approval, rejection, completion, or status changes',
+  conditions: [
+    WATCH_CONDITION.APPROVED, WATCH_CONDITION.REJECTED, WATCH_CONDITION.COMPLETED,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: _findPlan,
+  captureState: (p) => ({ status: p.status, planStale: !!p.planStale }),
+  evaluate: (condition, p, prevState, target) => {
+    const status = String(p.status || '').toLowerCase();
+    switch (condition) {
+      case WATCH_CONDITION.APPROVED:
+        return { triggered: status === shared.PLAN_STATUS.APPROVED, message: status === shared.PLAN_STATUS.APPROVED ? `Plan ${target} approved` : '' };
+      case WATCH_CONDITION.REJECTED:
+        return { triggered: status === shared.PLAN_STATUS.REJECTED, message: status === shared.PLAN_STATUS.REJECTED ? `Plan ${target} rejected` : '' };
+      case WATCH_CONDITION.COMPLETED:
+        return { triggered: status === shared.PLAN_STATUS.COMPLETED, message: status === shared.PLAN_STATUS.COMPLETED ? `Plan ${target} completed` : '' };
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== p.status;
+        return { triggered: changed, message: changed ? `Plan ${target} status: ${prevState.status} → ${p.status}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined &&
+          (prevState.status !== p.status || prevState.planStale !== !!p.planStale);
+        return { triggered: anyChanged, message: anyChanged ? `Plan ${target} changed (${p.status})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Schedule — ran (lastRun changed) / enabled / disabled / status-change / any
+function _findSchedule(target, state) {
+  const schedules = (state.config?.schedules) || state.schedules || [];
+  const sched = schedules.find(s => s && s.id === target) || null;
+  if (!sched) return null;
+  const runEntry = (state.scheduleRuns || {})[target];
+  const lastRun = runEntry && typeof runEntry === 'object' ? runEntry.lastRun : (typeof runEntry === 'string' ? runEntry : null);
+  // Synthesize an entity that combines schedule config + run state
+  return { ...sched, _lastRun: lastRun || null };
+}
+registerTargetType(WATCH_TARGET_TYPE.SCHEDULE, {
+  label: 'Schedule',
+  description: 'Watch a scheduled task for runs or enable/disable changes',
+  conditions: [
+    WATCH_CONDITION.RAN, WATCH_CONDITION.ENABLED, WATCH_CONDITION.DISABLED,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: _findSchedule,
+  captureState: (s) => ({ lastRun: s._lastRun || null, enabled: s.enabled !== false }),
+  evaluate: (condition, s, prevState, target) => {
+    const enabled = s.enabled !== false;
+    const lastRun = s._lastRun || null;
+    switch (condition) {
+      case WATCH_CONDITION.RAN: {
+        const ran = !!lastRun && lastRun !== (prevState.lastRun || null);
+        return { triggered: ran, message: ran ? `Schedule ${target} ran (${lastRun})` : '' };
+      }
+      case WATCH_CONDITION.ENABLED: {
+        const flipped = prevState.enabled === false && enabled === true;
+        return { triggered: flipped, message: flipped ? `Schedule ${target} was enabled` : '' };
+      }
+      case WATCH_CONDITION.DISABLED: {
+        const flipped = prevState.enabled === true && enabled === false;
+        return { triggered: flipped, message: flipped ? `Schedule ${target} was disabled` : '' };
+      }
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.enabled !== undefined && prevState.enabled !== enabled;
+        return { triggered: changed, message: changed ? `Schedule ${target} enabled changed: ${prevState.enabled} → ${enabled}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.enabled !== undefined &&
+          (prevState.enabled !== enabled || prevState.lastRun !== lastRun);
+        return { triggered: anyChanged, message: anyChanged ? `Schedule ${target} changed` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Pipeline — completed/failed/stage-complete/status-change/any. Target is
+// the pipeline ID; we track the latest run.
+function _findPipelineLatestRun(target, state) {
+  const runsByPipeline = state.pipelineRuns || {};
+  const list = runsByPipeline[target];
+  if (!Array.isArray(list) || list.length === 0) return null;
+  // The latest run is the last entry (startRun pushes; cleanup keeps last 10).
+  return { ...list[list.length - 1], _pipelineId: target };
+}
+function _completedStageCount(run) {
+  if (!run || !run.stages) return 0;
+  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;
   }
-  return {};
+  return n;
 }
+registerTargetType(WATCH_TARGET_TYPE.PIPELINE, {
+  label: 'Pipeline',
+  description: 'Watch the latest run of a pipeline for completion, failure, or stage progress',
+  conditions: [
+    WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED, WATCH_CONDITION.STAGE_COMPLETE,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: _findPipelineLatestRun,
+  captureState: (run) => ({
+    runId: run.runId || null, status: run.status || null,
+    completedStages: _completedStageCount(run),
+  }),
+  evaluate: (condition, run, prevState, target) => {
+    switch (condition) {
+      case WATCH_CONDITION.COMPLETED: {
+        const done = run.status === shared.PIPELINE_STATUS.COMPLETED;
+        return { triggered: done, message: done ? `Pipeline ${target} completed (run ${run.runId})` : '' };
+      }
+      case WATCH_CONDITION.FAILED: {
+        const failed = run.status === shared.PIPELINE_STATUS.FAILED || run.status === shared.PIPELINE_STATUS.STOPPED;
+        return { triggered: failed, message: failed ? `Pipeline ${target} failed (${run.status}, run ${run.runId})` : '' };
+      }
+      case WATCH_CONDITION.STAGE_COMPLETE: {
+        const cur = _completedStageCount(run);
+        const prev = prevState.completedStages || 0;
+        const advanced = prevState.completedStages !== undefined && cur > prev && (prevState.runId === run.runId);
+        return { triggered: advanced, message: advanced ? `Pipeline ${target} stage progress: ${prev} → ${cur}` : '' };
+      }
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== run.status;
+        return { triggered: changed, message: changed ? `Pipeline ${target} status: ${prevState.status} → ${run.status}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined &&
+          (prevState.status !== run.status || prevState.runId !== run.runId ||
+            (prevState.completedStages || 0) !== _completedStageCount(run));
+        return { triggered: anyChanged, message: anyChanged ? `Pipeline ${target} changed (${run.status})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Dispatch — completed/failed/status-change/any. Target is dispatch entry id.
+function _findDispatchEntry(target, state) {
+  const d = state.dispatch || {};
+  for (const list of ['active', 'pending', 'completed']) {
+    const entry = (d[list] || []).find(e => e && e.id === target);
+    if (entry) return { ...entry, _list: list };
+  }
+  return null;
+}
+const DISPATCH_TERMINAL = new Set(['done', 'completed', 'failed', 'cancelled']);
+registerTargetType(WATCH_TARGET_TYPE.DISPATCH, {
+  label: 'Dispatch',
+  description: 'Watch a dispatch entry for terminal status or status changes',
+  conditions: [
+    WATCH_CONDITION.COMPLETED, WATCH_CONDITION.FAILED,
+    WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: _findDispatchEntry,
+  captureState: (e) => ({ status: e.status || e._list || null, list: e._list || null }),
+  evaluate: (condition, e, prevState, target) => {
+    const status = String(e.status || '').toLowerCase();
+    const list = e._list || null;
+    switch (condition) {
+      case WATCH_CONDITION.COMPLETED: {
+        const done = list === 'completed' && (status === '' || (DISPATCH_TERMINAL.has(status) && status !== 'failed'));
+        return { triggered: done, message: done ? `Dispatch ${target} completed` : '' };
+      }
+      case WATCH_CONDITION.FAILED: {
+        const failed = status === 'failed' || status === 'error';
+        return { triggered: failed, message: failed ? `Dispatch ${target} failed` : '' };
+      }
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== (e.status || list);
+        return { triggered: changed, message: changed ? `Dispatch ${target} status: ${prevState.status} → ${e.status || list}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const cur = e.status || list;
+        const anyChanged = prevState.status !== undefined &&
+          (prevState.status !== cur || prevState.list !== list);
+        return { triggered: anyChanged, message: anyChanged ? `Dispatch ${target} changed (${cur})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
+
+// Agent — activity-change / status-change / any. State.agents must be an
+// array of agent objects (id + status), as produced by queries.getAgents.
+function _findAgent(target, state) {
+  return (state.agents || []).find(a => a && a.id === target) || null;
+}
+registerTargetType(WATCH_TARGET_TYPE.AGENT, {
+  label: 'Agent',
+  description: 'Watch an agent for activity transitions (idle ↔ working) or status changes',
+  conditions: [
+    WATCH_CONDITION.ACTIVITY_CHANGE, WATCH_CONDITION.STATUS_CHANGE, WATCH_CONDITION.ANY,
+  ],
+  fetchEntity: _findAgent,
+  captureState: (a) => ({ status: a.status || null }),
+  evaluate: (condition, a, prevState, target) => {
+    const cur = a.status || null;
+    switch (condition) {
+      case WATCH_CONDITION.ACTIVITY_CHANGE: {
+        // Triggers on transitions involving the 'working' status
+        const wasWorking = prevState.status === 'working';
+        const nowWorking = cur === 'working';
+        const changed = prevState.status !== undefined && wasWorking !== nowWorking;
+        return { triggered: changed, message: changed ? `Agent ${target} activity: ${prevState.status} → ${cur}` : '' };
+      }
+      case WATCH_CONDITION.STATUS_CHANGE: {
+        const changed = prevState.status !== undefined && prevState.status !== cur;
+        return { triggered: changed, message: changed ? `Agent ${target} status: ${prevState.status} → ${cur}` : '' };
+      }
+      case WATCH_CONDITION.ANY: {
+        const anyChanged = prevState.status !== undefined && prevState.status !== cur;
+        return { triggered: anyChanged, message: anyChanged ? `Agent ${target} changed (${cur})` : '' };
+      }
+      default:
+        return { triggered: false, message: `Unknown condition: ${condition}` };
+    }
+  },
+});
 
 module.exports = {
   DEFAULT_WATCH_INTERVAL,
@@ -314,6 +677,10 @@ module.exports = {
   deleteWatch,
   evaluateWatch,
   checkWatches,
+  registerTargetType,
+  getTargetType,
+  listTargetTypes,
   _captureState,  // exported for testing
   _watchesPath,   // exported for testing — dynamic, respects MINIONS_TEST_DIR
+  _TARGET_TYPES: TARGET_TYPES, // exported for testing — direct registry access
 };

package/engine.js

@@ -4419,7 +4419,46 @@ async function tickInner() {
       });
       // Also include central work items
       const centralWi = safeJson(path.join(MINIONS_DIR, 'work-items.json')) || [];
-      checkWatches(config, { pullRequests, workItems: [...workItems, ...centralWi] });
+
+      // Gather state for the new generalized target types. Each block is
+      // best-effort — if a module/file is missing the watch evaluator will
+      // simply report "not found" rather than crashing the tick.
+      let meetings = [];
+      try { meetings = require('./engine/meeting').getMeetings(); } catch { /* optional */ }
+
+      // Plans/PRDs — read PRD JSON files directly so plan-level watches see
+      // status transitions (approved/rejected/completed/etc.). Each entry
+      // carries its filename in _source for target lookup.
+      const plans = [];
+      try {
+        const prdDir = path.join(MINIONS_DIR, 'prd');
+        for (const dir of [prdDir, path.join(prdDir, 'archive')]) {
+          if (!fs.existsSync(dir)) continue;
+          for (const f of fs.readdirSync(dir).filter(x => x.endsWith('.json'))) {
+            const plan = safeJson(path.join(dir, f));
+            if (plan) plans.push({ ...plan, _source: f, _sourcePlan: plan.source_plan || '' });
+          }
+        }
+      } catch { /* optional */ }
+
+      let scheduleRuns = {};
+      try { scheduleRuns = safeJson(path.join(MINIONS_DIR, 'engine', 'schedule-runs.json')) || {}; } catch { /* optional */ }
+
+      let pipelineRuns = {};
+      try { pipelineRuns = require('./engine/pipeline').getPipelineRuns(); } catch { /* optional */ }
+
+      let dispatch = { pending: [], active: [], completed: [] };
+      try { dispatch = queries.getDispatch() || dispatch; } catch { /* optional */ }
+
+      let agents = [];
+      try { agents = queries.getAgents(config) || []; } catch { /* optional */ }
+
+      checkWatches(config, {
+        pullRequests,
+        workItems: [...workItems, ...centralWi],
+        meetings, plans, scheduleRuns, pipelineRuns, dispatch, agents,
+        config,
+      });
     });
   }
 

package/package.json

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