@yemi33/minions 0.1.2022 → 0.1.2024

package/dashboard/js/refresh.js

@@ -49,7 +49,7 @@ const RENDER_VERSIONS = {
   prd: 1,
   prs: 1,
   archivedPrds: 1,
-  engine: 1,
+  engine: 2,
   version: 1,
   adoThrottle: 1,
   ghThrottle: 1,
@@ -153,7 +153,7 @@ function _processStatusUpdate(data) {
   if (_prsChanged) renderPrs(data.pullRequests || []);
   if (_changed('archivedPrds', data.archivedPrds)) renderArchiveButtons(data.archivedPrds || []);
   if (_changed('engine', data.engine)) {
-    renderEngineStatus(data.engine);
+    if (data.engine) renderEngineStatus(data.engine);
     var qs = document.getElementById('engine-quick-stats');
     if (qs && data.engine) {
       var wt = data.engine.worktreeCount != null ? data.engine.worktreeCount : '-';

package/dashboard/js/render-dispatch.js

@@ -39,13 +39,12 @@ function _resetEngineRestartStateForTest() {
 function renderEngineStatus(engine) {
   const badge = document.getElementById('engine-badge');
   let state = engine?.state || 'stopped';
-  let staleMs = 0;
-
-  // Detect stale engine — says running but heartbeat is old (>2 min)
-  if (state === 'running' && engine?.heartbeat) {
-    staleMs = Date.now() - engine.heartbeat;
-    if (staleMs > 120000) state = 'stale';
-  }
+  // Server stamps engine.heartbeatStale + heartbeatAgeMs at snapshot build time
+  // (dashboard.js _buildStatusFastState). Avoids client-side wall-clock math
+  // against a possibly-cached heartbeat — the bug pattern that produced false-
+  // positive STALE banners after control.json was dropped from the mtime tracker.
+  const staleMs = engine?.heartbeatAgeMs || 0;
+  if (state === 'running' && engine?.heartbeatStale) state = 'stale';
 
   // Clear restart grace as soon as the engine reports a fresh heartbeat — the
   // new engine has caught up, so STALE/restart banners should vanish.

package/dashboard/js/state.js

@@ -170,8 +170,20 @@ window.addEventListener('beforeunload', function() { _sendDashboardPresence(true
 // guaranteed) and can resurrect a just-deleted entry with visibility:"hidden".
 // Hidden tabs naturally expire via the 45s presence window; foreground returns
 // re-fire visibilitychange so we still get a fresh heartbeat when the user comes back.
+//
+// Also kick a refresh() so the SPA recovers from background-tab throttling.
+// Chromium throttles setInterval to ~1/min on backgrounded tabs, which stretches
+// our 4 s poll cadence to 60 s. A backgrounded tab that re-focuses after the
+// engine paused / restarted / heartbeat advanced can otherwise sit on stale
+// state (including a stuck "Engine heartbeat is stale" banner) until the next
+// throttled tick fires. Triggering refresh() inline on becoming-visible
+// closes that window to <1 s. refresh() is single-flight-gated by
+// _refreshInFlight (see refresh.js), so concurrent calls collapse to one fetch.
 document.addEventListener('visibilitychange', function() {
-  if (document.visibilityState === 'visible') _sendDashboardPresence(false);
+  if (document.visibilityState === 'visible') {
+    _sendDashboardPresence(false);
+    try { if (typeof refresh === 'function') refresh(); } catch {}
+  }
 });
 
 function rerenderPrdFromCache() {

package/dashboard.js

@@ -127,6 +127,19 @@ function warmProjectGitStatusCache() {
 }
 warmProjectGitStatusCache();
 
+// Wire the queries.js → dashboard.js cache-invalidation hook. When a
+// background project-git-status probe lands with a NEW value (branch
+// changed, dirty flipped, ahead/behind shifted), pop the /api/status
+// cache immediately so the next SPA poll (≤4 s away) carries the fresh
+// value. The `projects:` slice lives in the SLOW-state cache (60 s TTL),
+// so the invalidation must include slow — otherwise the freshly-probed
+// inner-cache value sits behind a stale 60 s slow-state snapshot.
+try {
+  queries._setOnProjectGitStatusChanged(() => {
+    try { invalidateStatusCache({ includeSlow: true }); } catch { /* status cache may not be initialized yet */ }
+  });
+} catch { /* defensive — wiring is best-effort, queries probes still work without it */ }
+
 function resolveScheduleProjectValue(project, projects = PROJECTS) {
   if (project === undefined) return { project: undefined };
   const target = shared.resolveConfiguredProject(project, projects);
@@ -1505,6 +1518,11 @@ const FAST_STATE_TTL = 10000; // 10s — dispatch, agents, metrics, work items,
 let _slowState = null;
 let _slowStateTs = 0;
 const SLOW_STATE_TTL = 60000; // 60s — skills, PRDs, pinned, version, projects, etc.
+// Heartbeat staleness threshold. Computed server-side at snapshot build time so
+// the client renders off a boolean instead of doing wall-clock math against a
+// possibly-cached heartbeat (which produced false-positive STALE banners after
+// control.json was dropped from the mtime tracker in W-mpg8aapw001d7e0c).
+const ENGINE_HEARTBEAT_STALE_MS = 120000;
 let _statusCache = null;
 let _statusCacheJson = null; // cached JSON.stringify(_statusCache) — avoids double-serialization for SSE
 let _statusCacheGzip = null; // pre-computed gzip of _statusCacheJson — avoids per-request gzipSync
@@ -1626,12 +1644,22 @@ function invalidateStatusCache(opts) {
 function _buildStatusFastState() {
   // reloadConfig is called by both sync and async callers before this — kept
   // outside so the async path can yield between reload and rebuild.
+  const engineState = getEngineState();
+  const hbAge = engineState.heartbeat ? Date.now() - engineState.heartbeat : 0;
   return {
     agents: getAgents(),
     inbox: getInbox(),
     notes: getNotesWithMeta(),
     pullRequests: getPullRequests(),
-    engine: { ...getEngineState(), worktreeCount: _countWorktrees() },
+    engine: {
+      ...engineState,
+      worktreeCount: _countWorktrees(),
+      // Snapshot-time staleness. Frozen with the snapshot; the client renders
+      // off these instead of recomputing Date.now() - heartbeat against a
+      // possibly-cached payload (false-positive banner regression #2754).
+      heartbeatAgeMs: engineState.heartbeat ? hbAge : null,
+      heartbeatStale: !!(engineState.heartbeat && hbAge > ENGINE_HEARTBEAT_STALE_MS),
+    },
     adoThrottle: ado.getAdoThrottleState(),
     ghThrottle: gh.getGhThrottleState(),
     dispatch: getDispatchQueue(),

package/docs/auto-discovery.md

@@ -1,6 +1,6 @@
 # Auto-Discovery & Execution Pipeline
 
-> Last verified: 2026-05-17 against `engine.js` `tickInner()` (lines 5360-5993).
+> Last verified: 2026-05-22 against `engine.js` `tickInner()` (lines 6068-6425).
 
 How the minions engine finds work and dispatches agents automatically.
 

package/docs/pr-review-fix-loop.md

@@ -39,7 +39,7 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 ### A. Human comments (`humanFeedback.pendingFix`)
 
 - Gate: `pendingFix || coalescedFeedback` + not already dispatched/on cooldown
-- Agent comments filtered out via `/\bMinions\s*\(/i` regex on comment body
+- Agent comments filtered out via `_isNonActionableComment()` (`engine/github.js`, `engine/ado.js`) — composes preview/bot body checks and the structural Minions-author check from `engine/comment-classifier.js`. The structural check matches the `<!-- minions:agent=<id> kind=<kind> -->` HTML marker on the body's first line (`hasMinionsMarker`); on GitHub it must combine with `viewerDidAuthor === true` (anti-spoof), on ADO with a `config.engine.minionsAdoIdentities` author match. Marker presence alone never classifies a comment as agent-authored on either platform.
 - Coalesces multiple comments arriving during cooldown into single fix
 - Routes to author
 - Fix agents must treat human comments as claims to verify, not commands. They inspect or reproduce each claimed issue, make the smallest correct fix only when the claim is valid, and otherwise reply with evidence-backed rationale.
@@ -108,6 +108,7 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 | `engine/lifecycle.js` | `syncPrsFromOutput()`, `updatePrAfterReview()`, `updatePrAfterFix()` |
 | `engine/github.js` | `pollPrStatus()`, `pollPrHumanComments()`, `fetchGhBuildErrorLog()` |
 | `engine/ado.js` | `pollPrStatus()`, `pollPrHumanComments()`, `fetchAdoBuildErrorLog()` |
+| `engine/comment-classifier.js` | Host-agnostic body-only predicates (`isPreviewStatusBody`, `hasMinionsMarker`, `hasVerdictPrefix`) shared by GH + ADO pollers (extracted in F2+F3+F4) |
 | `engine/dispatch.js` | `addToDispatch()` — dedup by work item ID and dispatchKey |
 | `engine/cooldown.js` | `isBranchActive()`, cooldown management |
 | `playbooks/review.md` | Reviewer playbook |

package/docs/self-improvement.md

@@ -174,10 +174,10 @@ Human comments on PR with "@minions fix the error handling here"
 
 ### How it works
 
-- **Trigger:** If you're the only human commenter, **any** comment triggers a fix. If multiple humans are commenting, `@minions` keyword is required to avoid noise
-- **Agent detection:** Comments matching `/\bMinions\s*\(/i` are skipped (agent signature pattern)
+- **Trigger:** Any human comment newer than the per-PR cutoff that survives `_isNonActionableComment()` (preview/CI/Minions-author filter) flips `pr.humanFeedback.pendingFix = true` and queues a fix. There is no "@minions keyword required" gate — `@minions` mentions are merely stripped from `feedbackContent` before it is handed to the fix agent.
+- **Agent detection:** Comments are filtered via `_isNonActionableComment()` in `engine/github.js` / `engine/ado.js`, which composes the body-only predicates from `engine/comment-classifier.js` (`isPreviewStatusBody`, `hasMinionsMarker`) with an identity gate (`viewerDidAuthor === true` on GitHub, `config.engine.minionsAdoIdentities` author match on ADO). Marker presence alone never classifies a comment as agent-authored on either platform.
 - **Dedup:** Only comments newer than `pr.humanFeedback.lastProcessedCommentDate` are processed
-- **Multiple comments:** All new `@minions` comments are concatenated into a single fix task
+- **Multiple comments:** All new actionable comments since the cutoff are concatenated chronologically into a single fix task (each body individually fenced in `<UNTRUSTED-INPUT>` per F5 / W-mpeklod3000we69c)
 - **After fix:** `pendingFix` is cleared; PR re-enters normal review cycle
 
 ## 5. Quality Metrics

package/docs/watches.md

@@ -49,7 +49,7 @@ When `stopAfter === 0`, these are **fire-once** — the engine flips the watch t
 > **Per-target override (W-mp7hg58e000b5212):** the global `WATCH_ABSOLUTE_CONDITIONS` set is the legacy fallback. Each target type now declares its own `absoluteConditions: [...]` array in its spec; `registerTargetType` normalizes that into a `Set` that takes precedence at evaluation time. The plugin contract (see below) uses this to keep absolute-vs-change semantics local to each target type. Plugins that omit `absoluteConditions` get an empty set (all change-based).
 
 ### Change-based conditions
-`status-change`, `any`, `new-comments`, `vote-change`, `stage-complete`, `ran`, `enabled`, `disabled`, `activity-change`, plus the predicate conditions added under P-w4e2f6a1 / P-w5b8d2c9 for the `pr`, `work-item`, `plan`, and `pipeline` target types (`head-commit-change`, `mergeable-flipped`, `behind-master`, `draft-flipped`, `stalled`, `dependency-met`, `stage-advanced`, `stuck-in-stage`). See `engine/shared.js:1891-1929` for the canonical enum.
+`status-change`, `any`, `new-comments`, `vote-change`, `stage-complete`, `ran`, `enabled`, `disabled`, `activity-change`, plus the predicate conditions added under P-w4e2f6a1 / P-w5b8d2c9 for the `pr`, `work-item`, `plan`, and `pipeline` target types (`head-commit-change`, `mergeable-flipped`, `behind-master`, `draft-flipped`, `stalled`, `dependency-met`, `stage-advanced`, `stuck-in-stage`). See `engine/shared.js:2422-2460` for the canonical enum.
 
 These compare the live entity against the watch's `_lastState` snapshot and run forever when `stopAfter === 0`. Baseline `_lastState` is captured on the first check so the very next change triggers the watch *(source: `engine/watches.js:434, 520`)*.
 
@@ -89,7 +89,7 @@ Canonical example: `watches.d/http.js` (W-mp7i22mu00191b07) — a generic HTTP p
 
 ### Built-in target types
 
-The eight built-ins are registered at module load *(source: `engine/watches.js:672-1311`)*. Constants live at `engine/shared.js:1881-1890` (`WATCH_TARGET_TYPE`).
+The eight built-ins are registered at module load *(source: `engine/watches.js:672-1313`)*. Constants live at `engine/shared.js:2412-2421` (`WATCH_TARGET_TYPE`).
 
 | `targetType`  | Target value                         | Conditions                                                                 | Notes |
 |---------------|--------------------------------------|----------------------------------------------------------------------------|-------|
@@ -174,7 +174,7 @@ I/O happens **outside the lock**: notifications via `writeToInbox`, follow-up ac
 | `archive-plan`         | Set PRD `status="archived"` + `archivedAt`                                                    |
 | `resume-plan`          | Set PRD `status=PLAN_STATUS.ACTIVE` and clear `planStale`                                     |
 
-Constants live in `WATCH_ACTION_TYPE` (`engine/shared.js:1960`); handlers in `engine/watch-actions.js`.
+Constants live in `WATCH_ACTION_TYPE` (`engine/shared.js:2491`); handlers in `engine/watch-actions.js`.
 
 ### Templating
 
@@ -245,7 +245,7 @@ Absolute conditions firing under `stopAfter === 0` flip `status` to `expired`; `
 
 ## See Also
 
-- `engine/shared.js:1875-1960` — `WATCH_STATUS`, `WATCH_TARGET_TYPE`, `WATCH_CONDITION`, `WATCH_ABSOLUTE_CONDITIONS`, `WATCH_ACTION_TYPE` constants
+- `engine/shared.js:2406-2500` — `WATCH_STATUS`, `WATCH_TARGET_TYPE`, `WATCH_CONDITION`, `WATCH_ABSOLUTE_CONDITIONS`, `WATCH_ACTION_TYPE` constants
 - `engine/watches.js` — registry, lifecycle, tick integration, `watches.d/` plugin loader
 - `engine/watch-actions.js` — action registry and built-in handlers (including `minions-api`)
 - `watches.d/http.js` — canonical user-extensible target type plugin

package/engine/ado.js

@@ -998,6 +998,7 @@ async function pollPrStatus(config) {
     else if (prData.status === 'active') newStatus = PR_STATUS.ACTIVE;
 
     if (pr.status !== newStatus) {
+      const oldStatus = pr.status;
       log('info', `PR ${pr.id} status: ${pr.status} → ${newStatus}`);
       pr.status = newStatus;
       updated = true;
@@ -1030,12 +1031,41 @@ async function pollPrStatus(config) {
           delete pr._buildStatusDetail;
           delete pr.buildFixAttempts;
         }
+        // F6 (P-f6commentedit): drop the comment-edit dedup map on merge/abandon
+        // — no further re-dispatch path can fire from this PR, so keeping it
+        // around would only bloat pull-requests.json.
+        if (pr.humanFeedback && pr.humanFeedback.editsSeen) {
+          delete pr.humanFeedback.editsSeen;
+        }
         // Cancel any pending review/fix dispatches — they're stale now that the PR is closed
         try {
           dispatchModule().cancelPendingDispatchesForPr(pr.id);
         } catch (e) { log('warn', `Cancel dispatches for ${pr.id}: ${e.message}`); }
         await engine().handlePostMerge(pr, project, config, newStatus);
       }
+
+      // P-f5reopenreset: reopen transient-state reset.
+      // On reopen (abandoned→active), the prior review session is no longer
+      // authoritative for the now-active PR — wipe transient state that
+      // references it. Invariant #14 ('approved is permanent terminal') is
+      // preserved: we keep reviewStatus when it was 'approved' rather than
+      // carving a wasReopened exception into the 8+ guard sites in
+      // engine/lifecycle.js, engine.js, engine/github.js, and engine/ado.js.
+      // Re-review safety on new commits is handled by the pre-existing
+      // pr.lastPushedAt > pr.lastReviewedAt path (engine.js alreadyReviewed
+      // gate) plus the changes-requested override in lifecycle.js.
+      if (oldStatus === PR_STATUS.ABANDONED && newStatus === PR_STATUS.ACTIVE) {
+        pr.minionsReview = null;
+        pr._lastDispatchByCause = {};
+        pr.humanFeedback = { ...(pr.humanFeedback || {}), lastSeenAt: null, lastSeenCommentId: null };
+        // F6 (P-f6commentedit): drop the comment-edit dedup map on reopen so a
+        // re-edited comment after reopen still re-dispatches. Safe no-op when
+        // F6 not yet shipped (field absent).
+        delete pr.humanFeedback.editsSeen;
+        pr.fixDispatched = false;
+        if (pr.reviewStatus !== 'approved') pr.reviewStatus = 'pending';
+        log('info', `PR ${pr.id} reopened — reset transient state (reviewStatus=${pr.reviewStatus})`);
+      }
     }
 
     // Track head commit changes to detect new pushes (used for review re-dispatch gating)
@@ -1490,6 +1520,14 @@ async function pollPrHumanComments(config) {
     const newHumanComments = [];
     const allCommentDates = [];
     const ignoredAuthors = (config.engine?.ignoredCommentAuthors || []).map(a => a.toLowerCase());
+    // F6 (P-f6commentedit): collect every non-system comment for the edit-dedup
+    // map. ADO `lastUpdatedDate` is inconsistent (sometimes `+00:00`, sometimes
+    // naive) — shared.normalizeIsoTimestamp normalizes via `new Date(raw).toISOString()`
+    // before string comparison.
+    const editsInput = [];
+    // Threads-by-id index used by the F6 path to recover threadId when a
+    // pre-cutoff edited comment is routed into newHumanComments.
+    const threadIdByComment = new Map();
 
     // P-f23classifier (F3, security note): ADO has no `viewerDidAuthor`
     // equivalent. A human pasting our `<!-- minions:agent=... -->` marker
@@ -1531,6 +1569,14 @@ async function pollPrHumanComments(config) {
         // Track date for cutoff BEFORE author/body filters so bot/CI/ignored
         // comments still advance the cutoff.
         if (comment.publishedDate) allCommentDates.push(comment.publishedDate);
+        if (comment.id != null) {
+          threadIdByComment.set(String(comment.id), thread.id);
+          editsInput.push({
+            id: comment.id,
+            createdRaw: comment.publishedDate,
+            updatedRaw: comment.lastUpdatedDate,
+          });
+        }
         // Skip explicitly ignored authors.
         const authorName = (comment.author?.displayName || '').toLowerCase();
         if (ignoredAuthors.some(a => authorName.includes(a))) continue;
@@ -1575,14 +1621,44 @@ async function pollPrHumanComments(config) {
       }
     }
 
+    // F6 (P-f6commentedit): TZ-normalized per-comment edit dedup map. Comments
+    // that were EDITED (lastUpdatedDate > publishedDate) but whose normalized
+    // edit timestamp differs from what we already saw queue as new feedback
+    // (re-dispatch). First-seen comments and re-polls of already-seen edits
+    // do NOT route through this path.
+    const prevEditsSeen = (pr.humanFeedback && pr.humanFeedback.editsSeen) || {};
+    editsInput.sort((a, b) => String(a.updatedRaw || '').localeCompare(String(b.updatedRaw || '')));
+    const { editsSeen, newlyEditedIds, changed: editsSeenChanged } =
+      shared.buildEditsSeen(editsInput, prevEditsSeen);
+
+    // F6: promote pre-cutoff comments that were newly edited into newHumanComments
+    // (agent-authored edits do NOT re-dispatch — vote path handles agent reviews).
+    const seenNewCommentIds = new Set(newHumanComments.map(c => String(c.commentId)));
+    for (const entry of allHumanComments) {
+      if (entry._isAgent) continue;
+      const id = String(entry.commentId);
+      if (seenNewCommentIds.has(id)) continue;
+      if (!newlyEditedIds.has(id)) continue;
+      newHumanComments.push({ ...entry, date: editsSeen[id] || entry.date, _isEditedRedispatch: true });
+      seenNewCommentIds.add(id);
+    }
+
     // Persist cutoff unconditionally for any new comment we observed — even
     // if every new comment was bot/CI/ignored/agent. Mirrors GitHub poller.
     const allNewDates = allCommentDates.filter(d => (new Date(d).getTime() || 0) > cutoffMs);
     if (allNewDates.length > 0 && newHumanComments.length === 0) {
       pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: allNewDates.sort().pop() };
+      if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
       return true;
     }
-    if (newHumanComments.length === 0) return false;
+    if (newHumanComments.length === 0) {
+      // F6: persist pruned/updated editsSeen map even when no dispatch is queued.
+      if (editsSeenChanged) {
+        pr.humanFeedback = { ...(pr.humanFeedback || {}), editsSeen };
+        return true;
+      }
+      return false;
+    }
 
     // Sort all comments chronologically and build full context for the fix agent.
     // Cutoff advances to the latest of ALL new comment dates (so newer agent/CI
@@ -1614,12 +1690,14 @@ async function pollPrHumanComments(config) {
       })
       .join('\n\n---\n\n');
 
+    const latestNewHuman = newHumanComments[newHumanComments.length - 1];
     pr.humanFeedback = {
       lastProcessedCommentDate: latestDate,
-      lastProcessedCommentId: String(newHumanComments[newHumanComments.length - 1].commentId),
-      lastProcessedCommentKey: `${newHumanComments[newHumanComments.length - 1].threadId}:${newHumanComments[newHumanComments.length - 1].commentId}`,
+      lastProcessedCommentId: String(latestNewHuman.commentId),
+      lastProcessedCommentKey: `${latestNewHuman.threadId || threadIdByComment.get(String(latestNewHuman.commentId)) || ''}:${latestNewHuman.commentId}`,
       pendingFix: true,
-      feedbackContent
+      feedbackContent,
+      editsSeen,
     };
 
     log('info', `PR ${pr.id}: ${newHumanComments.length} new comment(s), ${allHumanComments.length} total — full thread context provided`);

package/engine/github.js

@@ -765,6 +765,7 @@ async function pollPrStatus(config) {
     }
 
     if (pr.status !== newStatus) {
+      const oldStatus = pr.status;
       log('info', `PR ${pr.id} status: ${pr.status} → ${newStatus}`);
       pr.status = newStatus;
       updated = true;
@@ -795,12 +796,41 @@ async function pollPrStatus(config) {
           delete pr._buildFailNotified;
           delete pr.buildFixAttempts;
         }
+        // F6 (P-f6commentedit): drop the comment-edit dedup map on merge/abandon
+        // — no further re-dispatch path can fire from this PR, so keeping it
+        // around would only bloat pull-requests.json.
+        if (pr.humanFeedback && pr.humanFeedback.editsSeen) {
+          delete pr.humanFeedback.editsSeen;
+        }
         // Cancel any pending review/fix dispatches — they're stale now that the PR is closed
         try {
           dispatchModule().cancelPendingDispatchesForPr(pr.id);
         } catch (e) { log('warn', `Cancel dispatches for ${pr.id}: ${e.message}`); }
         await engine().handlePostMerge(pr, project, config, newStatus);
       }
+
+      // P-f5reopenreset: reopen transient-state reset.
+      // On reopen (abandoned→active), the prior review session is no longer
+      // authoritative for the now-active PR — wipe transient state that
+      // references it. Invariant #14 ('approved is permanent terminal') is
+      // preserved: we keep reviewStatus when it was 'approved' rather than
+      // carving a wasReopened exception into the 8+ guard sites in
+      // engine/lifecycle.js, engine.js, engine/github.js, and engine/ado.js.
+      // Re-review safety on new commits is handled by the pre-existing
+      // pr.lastPushedAt > pr.lastReviewedAt path (engine.js alreadyReviewed
+      // gate) plus the changes-requested override in lifecycle.js.
+      if (oldStatus === PR_STATUS.ABANDONED && newStatus === PR_STATUS.ACTIVE) {
+        pr.minionsReview = null;
+        pr._lastDispatchByCause = {};
+        pr.humanFeedback = { ...(pr.humanFeedback || {}), lastSeenAt: null, lastSeenCommentId: null };
+        // F6 (P-f6commentedit): drop the comment-edit dedup map on reopen so a
+        // re-edited comment after reopen still re-dispatches. Safe no-op when
+        // F6 not yet shipped (field absent).
+        delete pr.humanFeedback.editsSeen;
+        pr.fixDispatched = false;
+        if (pr.reviewStatus !== 'approved') pr.reviewStatus = 'pending';
+        log('info', `PR ${pr.id} reopened — reset transient state (reviewStatus=${pr.reviewStatus})`);
+      }
     }
 
     // Review status from GitHub reviews
@@ -1006,12 +1036,30 @@ async function pollPrHumanComments(config) {
     const cutoffStr = pr.humanFeedback?.lastProcessedCommentDate || pr.created || pr._attachedAt || '1970-01-01';
     const cutoffMs = new Date(cutoffStr).getTime() || 0;
 
+    // F6 (P-f6commentedit): TZ-normalized per-comment edit dedup map. Comments
+    // that were EDITED (updated_at > created_at) but whose normalized edit
+    // timestamp differs from what we already saw are queued as new feedback so
+    // a follow-up fix re-dispatches. First-seen comments and re-polls of
+    // already-seen edits do NOT route through this path.
+    const prevEditsSeen = (pr.humanFeedback && pr.humanFeedback.editsSeen) || {};
+    const editsInput = allComments.map(c => ({
+      id: c.id,
+      createdRaw: c.created_at,
+      updatedRaw: c.updated_at,
+    }));
+    // Sort chronologically by updated timestamp so FIFO cap eviction keeps the
+    // most-recently-edited entries (the ones most likely to be re-edited).
+    editsInput.sort((a, b) => String(a.updatedRaw || '').localeCompare(String(b.updatedRaw || '')));
+    const { editsSeen, newlyEditedIds, changed: editsSeenChanged } =
+      shared.buildEditsSeen(editsInput, prevEditsSeen);
+
     // Collect comments that should advance the cutoff separately from comments
     // that should dispatch a fix. Informational bot/status comments and
     // Minions-authored triage comments should be seen once, then ignored.
     const allCommentDates = [];
     const allCommentEntries = [];
     const newComments = [];
+    const seenInNewComments = new Set();
 
     for (const c of allComments) {
       const date = c.created_at || c.updated_at || '';
@@ -1035,6 +1083,13 @@ async function pollPrHumanComments(config) {
 
       if (dateMs && dateMs > cutoffMs) {
         newComments.push(entry);
+        seenInNewComments.add(String(c.id));
+      } else if (c.id != null && newlyEditedIds.has(String(c.id))) {
+        // F6: pre-cutoff comment that was newly edited — route into newComments
+        // so a fresh fix dispatches, but tag with the edit timestamp so the
+        // fix-agent prompt context flags it as new.
+        newComments.push({ ...entry, date: editsSeen[String(c.id)] || date, _isEditedRedispatch: true });
+        seenInNewComments.add(String(c.id));
       }
     }
 
@@ -1042,9 +1097,17 @@ async function pollPrHumanComments(config) {
     const allNewDates = allCommentDates.filter(date => (new Date(date).getTime() || 0) > cutoffMs);
     if (allNewDates.length > 0 && newComments.length === 0) {
       pr.humanFeedback = { ...(pr.humanFeedback || {}), lastProcessedCommentDate: allNewDates.sort().pop() };
+      if (editsSeenChanged) pr.humanFeedback.editsSeen = editsSeen;
       return true; // non-actionable comments only — persist cutoff without triggering fix
     }
-    if (newComments.length === 0) return false;
+    if (newComments.length === 0) {
+      // F6: persist pruned/updated editsSeen map even when no dispatch is queued.
+      if (editsSeenChanged) {
+        pr.humanFeedback = { ...(pr.humanFeedback || {}), editsSeen };
+        return true;
+      }
+      return false;
+    }
 
     // Sort all comments chronologically and build full context for the fix agent
     allCommentEntries.sort((a, b) => a.date.localeCompare(b.date));
@@ -1075,7 +1138,8 @@ async function pollPrHumanComments(config) {
       lastProcessedCommentId: String(newComments[newComments.length - 1].commentId),
       lastProcessedCommentKey: String(newComments[newComments.length - 1].commentId),
       pendingFix: true,
-      feedbackContent
+      feedbackContent,
+      editsSeen,
     };
 
     log('info', `PR ${pr.id}: ${newComments.length} new comment(s), ${allCommentEntries.length} total — full thread context provided`);

package/engine/queries.js

@@ -1736,14 +1736,50 @@ async function _probeProjectGitStatus(localPath, configuredMainBranch) {
   }
 }
 
+// Hook fired when a background git-status probe lands with a value that
+// DIFFERS from the previously-cached entry. Lets dashboard.js wire its
+// `invalidateStatusCache()` here so a freshly-detected branch change /
+// dirty flip / ahead/behind shift pops the /api/status cache immediately
+// instead of waiting out its independent 10 s fast-state TTL. Without
+// this, even adding `.git/logs/HEAD` to the mtime tracker only buys you
+// the FIRST rebuild (which still returns the stale cached value while
+// the background probe is in flight); the rebuild that actually carries
+// the fresh value has to wait for the next mtime advance or TTL expiry,
+// adding another 10 s.
+let _onProjectGitStatusChanged = null;
+function _setOnProjectGitStatusChanged(fn) {
+  _onProjectGitStatusChanged = typeof fn === 'function' ? fn : null;
+}
+// Cheap shallow equality for the PROJECT_GIT_STATUS_* shape. Enumerates
+// the known fields explicitly so a new field added to the shape requires
+// updating both the producer and this comparator.
+function _projectGitStatusEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return (
+    a.gitBranch === b.gitBranch
+    && a.gitDetached === b.gitDetached
+    && a.gitDirty === b.gitDirty
+    && a.gitState === b.gitState
+    && a.remoteDefaultBranch === b.remoteDefaultBranch
+    && a.ahead === b.ahead
+    && a.behind === b.behind
+  );
+}
+
 function _scheduleProjectGitStatusRefresh(localPath, key, configuredMainBranch) {
   const existing = _projectGitStatusCache.get(key);
   if (existing && existing.promise) return existing.promise;
   const entry = existing || { ts: 0, value: PROJECT_GIT_STATUS_PENDING, promise: null };
+  const prevValue = entry.value;
   entry.promise = _probeProjectGitStatus(localPath, configuredMainBranch).then(value => {
     entry.ts = Date.now();
     entry.value = value;
     entry.promise = null;
+    if (_onProjectGitStatusChanged && !_projectGitStatusEqual(prevValue, value)) {
+      try { _onProjectGitStatusChanged(key, value, prevValue); }
+      catch { /* hook must never break the probe */ }
+    }
     return value;
   }, () => {
     entry.promise = null;
@@ -1877,9 +1913,21 @@ function getStatusFastStateMtimePaths(config) {
   // original tracked list — PR status flips (running → passing, waiting →
   // approved) were waiting on the 10 s SSE backstop instead of the next
   // 4 s SPA poll.
+  //
+  // Per-project `.git/logs/HEAD` (the reflog) — added to cut the project-
+  // branch-state lag (was 15–25 s typical). The reflog is appended on every
+  // HEAD-changing operation (checkout, commit, reset, merge, rebase), so
+  // its mtime is a perfect signal that getProjectGitStatus's cached value
+  // is stale. Unlike control.json (intentionally excluded above), it is
+  // NOT advanced on a timer — it only moves on user-initiated git
+  // operations, so it can't dominate legitimate state changes. Cheap (one
+  // statSync per project per cache miss).
   for (const p of projects) {
     files.push(shared.projectWorkItemsPath(p));
     files.push(shared.projectPrPath(p));
+    if (p && p.localPath) {
+      files.push(path.join(p.localPath, '.git', 'logs', 'HEAD'));
+    }
   }
   return files;
 }
@@ -1901,6 +1949,7 @@ module.exports = {
   getProjectGitStatus,
   warmProjectGitStatus,
   _awaitPendingProjectGitStatusProbes,
+  _setOnProjectGitStatusChanged,
   // W-mpftp7na000td0f4 — engine→dashboard cache-invalidation registry
   getStatusFastStateMtimePaths,
 

package/engine/shared.js

@@ -83,6 +83,92 @@ function ts() { return new Date().toISOString(); }
 function logTs() { return new Date().toLocaleTimeString(); }
 function dateStamp() { return new Date().toISOString().slice(0, 10); }
 
+// ── F6 (P-f6commentedit): Comment-edit dedup helpers ────────────────────────
+// Shared by engine/github.js + engine/ado.js pollPrHumanComments so a comment
+// EDITED after first observation triggers a single re-dispatch (and only one).
+// MANDATORY TZ NORMALIZATION: GH `updated_at` is always UTC (Z-suffix), but
+// ADO `lastUpdatedDate` is inconsistent — sometimes `+00:00`, sometimes naive
+// (no offset). Without normalizeIsoTimestamp() string comparison silently
+// no-ops on the offset-variant case and re-dispatch never fires for ADO edits.
+
+const EDITS_SEEN_CAP = 200;
+
+function normalizeIsoTimestamp(raw) {
+  if (!raw) return null;
+  const d = new Date(raw);
+  const t = d.getTime();
+  return Number.isFinite(t) ? d.toISOString() : null;
+}
+
+/**
+ * Build the F6 editsSeen dedup map for a single poll cycle.
+ *
+ * @param {Array<{id: any, createdRaw: any, updatedRaw: any}>} comments
+ *   Current poll's comment list (callers normalize per-host shape into this
+ *   tuple — GH: c.id/c.created_at/c.updated_at; ADO: c.id/c.publishedDate/
+ *   c.lastUpdatedDate).
+ * @param {Object} prev - prior pr.humanFeedback.editsSeen map (or empty).
+ * @param {number} [cap=200] - hard cap; entries beyond cap are evicted
+ *   FIFO over insertion order (the comments array's iteration order, which
+ *   callers should pass chronologically ascending).
+ * @returns {{ editsSeen: Object, newlyEditedIds: Set<string>, changed: boolean }}
+ *
+ * Semantics:
+ *   - For each comment with `updatedRaw > createdRaw` (an actual edit, not
+ *     a first-seen comment) record `editsSeen[id] = normalizedUpdatedAt`.
+ *   - Comments absent from `comments` are dropped from the map (pruning rule).
+ *   - `newlyEditedIds` contains comment ids whose normalized updatedAt differs
+ *     from `prev[id]` (or had no prior entry). Callers route these into the
+ *     re-dispatch path.
+ *   - `changed` indicates whether the resulting map differs from `prev` so
+ *     callers can skip a needless persistence write.
+ */
+function buildEditsSeen(comments, prev, cap) {
+  const safePrev = (prev && typeof prev === 'object') ? prev : {};
+  const safeCap = Number.isInteger(cap) && cap > 0 ? cap : EDITS_SEEN_CAP;
+  const editsSeen = {};
+  const newlyEditedIds = new Set();
+
+  for (const c of comments || []) {
+    if (c == null || c.id == null) continue;
+    const key = String(c.id);
+    const createdNorm = normalizeIsoTimestamp(c.createdRaw);
+    const updatedNorm = normalizeIsoTimestamp(c.updatedRaw);
+    if (!updatedNorm || !createdNorm) continue;
+    // Only "edited" — first-seen comments (updated === created) must NOT
+    // route through this re-dispatch path.
+    if (updatedNorm <= createdNorm) continue;
+    editsSeen[key] = updatedNorm;
+    if (safePrev[key] !== updatedNorm) newlyEditedIds.add(key);
+  }
+
+  // FIFO eviction at cap — drop earliest insertion-order entries.
+  const keys = Object.keys(editsSeen);
+  let trimmed = editsSeen;
+  if (keys.length > safeCap) {
+    trimmed = {};
+    for (const k of keys.slice(keys.length - safeCap)) trimmed[k] = editsSeen[k];
+    // Newly-edited ids that were evicted no longer need a re-dispatch trigger
+    // (the map can't remember them anyway — they would re-trigger every poll).
+    for (const id of [...newlyEditedIds]) {
+      if (!Object.prototype.hasOwnProperty.call(trimmed, id)) newlyEditedIds.delete(id);
+    }
+  }
+
+  // Cheap shape diff — avoids JSON.stringify and stable across key ordering.
+  let changed = false;
+  const prevKeys = Object.keys(safePrev);
+  const newKeys = Object.keys(trimmed);
+  if (prevKeys.length !== newKeys.length) changed = true;
+  else {
+    for (const k of newKeys) {
+      if (safePrev[k] !== trimmed[k]) { changed = true; break; }
+    }
+  }
+
+  return { editsSeen: trimmed, newlyEditedIds, changed };
+}
+
 // ── Secret Redaction (SEC-09) ──────────────────────────────────────────────
 // Pure, side-effect-free redactor applied to every entry on the log write path
 // so ADO tokens, JWTs, and azureauth stdout dumps never land in engine/log.json
@@ -4749,6 +4835,9 @@ module.exports = {
   CONSTELLATION_BRIDGE_MARKER_SCHEMA_VERSION,
   currentLogPath: _currentLogPath,
   ts,
+  normalizeIsoTimestamp, // F6 (P-f6commentedit)
+  buildEditsSeen, // F6 (P-f6commentedit)
+  EDITS_SEEN_CAP, // F6 (P-f6commentedit)
   logTs,
   dateStamp,
   log,

package/package.json

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