@yemi33/minions 0.1.2174 → 0.1.2175

package/engine/watches.js

@@ -150,7 +150,14 @@ function registerTargetType(type, spec) {
       throw new Error(`registerTargetType(${type}): absoluteConditions entry '${c}' is not in conditions[]`);
     }
   }
-  TARGET_TYPES[type] = { ...spec, absoluteConditions: absoluteSet };
+  // W-mqa63opd000ha836 — optional hook: returns true when the target has
+  // reached a state from which `condition` can never fire again (e.g. a
+  // PR's status is `merged` and we're watching `build-fail`). Default
+  // returns false (back-compat — current target types unchanged).
+  const terminalFn = typeof spec.isTerminalForCondition === 'function'
+    ? spec.isTerminalForCondition
+    : () => false;
+  TARGET_TYPES[type] = { ...spec, absoluteConditions: absoluteSet, isTerminalForCondition: terminalFn };
 }
 
 /** Returns the registered spec for a target type, or null. */
@@ -517,6 +524,40 @@ function checkWatches(config, state) {
           });
         }
 
+        // W-mqa63opd000ha836 — auto-expire watches whose target has reached a
+        // terminal state from which the watched condition can never fire again.
+        // Independent of the absolute-condition fire-once path above: covers the
+        // long-tail case where a `build-fail` (or similar) watch was armed on an
+        // active PR that subsequently merged without ever tripping its condition.
+        // Without this, the watch sits `active` forever, polling every interval.
+        //
+        // Guardrail: do NOT auto-expire until the watch has had a chance to fire
+        // on its first real check — `triggerCount > 0` covers post-fire watches;
+        // `prevState.status === entity.status` covers second-and-later checks
+        // (initial _captureState on tick-1 makes these equal, so a watch armed
+        // on an already-terminal target with `condition: merged` still fires
+        // once via the absolute-condition path before this branch expires it).
+        if (watch.status === WATCH_STATUS.ACTIVE) {
+          const _ttForTerm = TARGET_TYPES[watch.targetType];
+          if (_ttForTerm && typeof _ttForTerm.isTerminalForCondition === 'function') {
+            try {
+              const _entityForTerm = _ttForTerm.fetchEntity(watch.target, state || {});
+              if (_entityForTerm) {
+                const _hadShot = (watch.triggerCount || 0) > 0
+                  || (previousState && previousState.status !== undefined
+                      && previousState.status === _entityForTerm.status);
+                if (_hadShot && _ttForTerm.isTerminalForCondition(watch.condition, _entityForTerm, previousState)) {
+                  watch.status = WATCH_STATUS.EXPIRED;
+                  const _termStatus = _entityForTerm.status;
+                  log('info', `Watch auto-expired (terminal target state): ${watch.id} — ${watch.targetType} ${watch.target} is ${_termStatus}, condition ${watch.condition} cannot fire again`);
+                }
+              }
+            } catch (termErr) {
+              log('warn', `Watch terminal-state check error (${watch.id}): ${termErr.message}`);
+            }
+          }
+        }
+
         // Capture state for change detection on next check
         watch._lastState = _captureState(watch, state);
 
@@ -704,6 +745,36 @@ registerTargetType(WATCH_TARGET_TYPE.PR, {
     WATCH_CONDITION.MERGED, WATCH_CONDITION.BUILD_FAIL, WATCH_CONDITION.BUILD_PASS,
     WATCH_CONDITION.READY_FOR_MERGE,
   ],
+  // W-mqa63opd000ha836 — zombie-watch janitor: once a PR reaches a terminal
+  // status (merged / closed / abandoned), most PR conditions can never fire
+  // again so the watch should auto-expire instead of polling forever.
+  //
+  // Excluded from terminal-expire:
+  //   - merged          — already handled by the absoluteConditions fire-once
+  //                       path; including it here is redundant and risks
+  //                       expiring before the watch's one shot to fire.
+  //   - status-change   — could theoretically still fire on a status flip
+  //                       (e.g. closed→reopened on GitHub), even though rare.
+  //   - any             — same rationale as status-change.
+  //
+  // Build-fail / build-pass / vote-change / new-comments / head-commit-change /
+  // mergeable-flipped / behind-master / ready-for-merge / draft-flipped all
+  // mutate fields that are frozen the moment the PR is merged/closed/abandoned,
+  // so a fresh fire is impossible.
+  isTerminalForCondition: (condition, pr) => {
+    if (!pr || !pr.status) return false;
+    const status = pr.status;
+    const isTerminal = status === shared.PR_STATUS.MERGED
+      || status === shared.PR_STATUS.CLOSED
+      || status === shared.PR_STATUS.ABANDONED;
+    if (!isTerminal) return false;
+    if (condition === WATCH_CONDITION.MERGED
+        || condition === WATCH_CONDITION.STATUS_CHANGE
+        || condition === WATCH_CONDITION.ANY) {
+      return false;
+    }
+    return true;
+  },
   fetchEntity: (target, state) => findPrByTarget(state.pullRequests, target),
   captureState: (pr) => ({
     status: pr.status, buildStatus: pr.buildStatus, reviewStatus: pr.reviewStatus,

package/package.json

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