@yemi33/minions 0.1.2033 → 0.1.2035

package/engine/queries.js

@@ -1798,13 +1798,76 @@ function _projectGitStatusCacheKey(localPath, configuredMainBranch) {
   return norm + '::' + (configuredMainBranch ? String(configuredMainBranch).trim() : '');
 }
 
+// Resolve the absolute `.git` directory for `localPath`, transparently
+// handling linked worktrees (where `<localPath>/.git` is a *file* whose
+// first line reads `gitdir: <abs path>`). Returns null when no valid git
+// linkage exists. Synchronous and cheap — one statSync + at most one
+// short readFileSync. Used by both `_projectGitRefsAdvancedSince` and the
+// fast-state mtime tracker so the same set of ref files is consulted in
+// both places, including for linked-worktree repos.
+function _resolveGitDir(localPath) {
+  if (!localPath) return null;
+  const gitPath = path.join(localPath, '.git');
+  let st;
+  try { st = fs.statSync(gitPath); }
+  catch { return null; }
+  if (st.isDirectory()) return gitPath;
+  if (st.isFile()) {
+    let head = '';
+    try { head = fs.readFileSync(gitPath, { encoding: 'utf8', flag: 'r' }).slice(0, 4096); }
+    catch { return null; }
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(head);
+    if (!m) return null;
+    const target = m[1];
+    return path.isAbsolute(target) ? target : path.resolve(localPath, target);
+  }
+  return null;
+}
+
+// Return true when any of the per-project git ref files (logs/HEAD,
+// FETCH_HEAD, refs/remotes/origin/<comparator>) have mtimeMs > cachedTs.
+// Lets `getProjectGitStatus` bypass its 15s TTL after `git pull`, `git
+// fetch`, `git checkout`, etc. so the next /api/status reflects the new
+// HEAD / ahead-behind within one SPA poll instead of waiting out the TTL
+// (W-mphdmr8c00030124). Tolerates ENOENT on FETCH_HEAD / refs (never-
+// fetched repos simply haven't moved those files yet). Cost ≤3 statSync
+// per project per /api/status build — well under the 'cheap' budget
+// called out in getStatusFastStateMtimePaths's docstring.
+function _projectGitRefsAdvancedSince(localPath, cachedTs, configuredMainBranch) {
+  const gitDir = _resolveGitDir(localPath);
+  if (!gitDir) return false;
+  const candidates = [
+    path.join(gitDir, 'logs', 'HEAD'),
+    path.join(gitDir, 'FETCH_HEAD'),
+  ];
+  const comparator = configuredMainBranch && String(configuredMainBranch).trim();
+  if (comparator) {
+    candidates.push(path.join(gitDir, 'refs', 'remotes', 'origin', comparator));
+  }
+  for (const file of candidates) {
+    try {
+      const st = fs.statSync(file);
+      if (st.mtimeMs > cachedTs) return true;
+    } catch { /* ENOENT / EPERM — file just hasn't moved */ }
+  }
+  return false;
+}
+
 function getProjectGitStatus(localPath, configuredMainBranch = null) {
   const norm = String(localPath || '').replace(/\\/g, '/');
   if (!norm) return PROJECT_GIT_STATUS_MISSING;
   const key = _projectGitStatusCacheKey(localPath, configuredMainBranch);
   const now = Date.now();
   const cached = _projectGitStatusCache.get(key);
-  if (cached && cached.ts && (now - cached.ts) < PROJECT_GIT_STATUS_TTL) return cached.value;
+  // Within TTL: short-circuit ONLY when no tracked git ref has advanced
+  // past cached.ts. Without the mtime gate, a freshly-pulled repo serves
+  // the pre-pull ahead/behind counts for up to 15s + one SPA poll (~19s
+  // user-visible lag) because the rebuilt fast-state still hits this
+  // cache and never schedules a refresh until the TTL itself expires.
+  if (cached && cached.ts && (now - cached.ts) < PROJECT_GIT_STATUS_TTL
+      && !_projectGitRefsAdvancedSince(localPath, cached.ts, configuredMainBranch)) {
+    return cached.value;
+  }
   // Cheap synchronous existsSync — short-circuits a path that just disappeared
   // (project removed) without scheduling a useless git probe.
   if (!fs.existsSync(localPath)) {
@@ -1881,6 +1944,17 @@ function resetProjectGitStatusCache() {
  *     directly, and the 10 s TTL covers CLI-driven control-file edits.
  *   - `engine/state.json` — surfaced via `getEngineState()` but changes
  *     only on engine startup / reconcile. Negligible benefit.
+ *   - `engine/metrics.json` — surfaced via `getMetrics()` but written by
+ *     `trackEngineUsage()` / `trackAgentMetric()` / the engine tick itself
+ *     (~10 s batched flush plus every per-agent metric event). Like
+ *     `log.json` and `control.json`, its mtime advances at noise-floor
+ *     cadence — every engine tick (~60 s) plus several per-agent writes
+ *     in between, so with multiple agents active it bumps every few
+ *     seconds and busts the ETag cache on /api/status before steady-state
+ *     304s can engage (W-mphejzct00065d8c). The engine-page metrics tile
+ *     is not the hot path and the 10 s `FAST_STATE_TTL` is plenty for
+ *     metric freshness; mutating handlers that need immediate metrics
+ *     visibility should call `invalidateStatusCache()` directly.
  *   - `engine/cooldowns.json`, `engine/pr-links.json`, `engine/pending-
  *     rebases.json`, `agents/<id>/managed-spawn.json` — not in the
  *     `/api/status` payload.
@@ -1902,11 +1976,15 @@ function resetProjectGitStatusCache() {
 function getStatusFastStateMtimePaths(config) {
   const projects = getProjects(config || getConfig());
   const files = [
-    // Engine-level state surfaced by getDispatchQueue / getMetrics.
-    // `control.json` and `log.json` are intentionally omitted — see the
-    // "Files intentionally NOT tracked" section above (W-mpg8aapw001d7e0c).
+    // Engine-level state surfaced by getDispatchQueue. `control.json`,
+    // `log.json`, and `metrics.json` are intentionally omitted — see the
+    // "Files intentionally NOT tracked" section above
+    // (W-mpg8aapw001d7e0c, W-mphejzct00065d8c). dispatch.json stays
+    // tracked because the home + engine sidebar activity dots and
+    // renderDispatch() consume dispatch transitions at sub-FAST_STATE_TTL
+    // cadence (active → completed flips must light up within one SPA
+    // poll, not wait up to 10 s for the periodic SSE backstop).
     DISPATCH_PATH,
-    path.join(ENGINE_DIR, 'metrics.json'),
     // Watches surfaced by watchesMod.getWatches() (W-mpftp7na000td0f4 fix).
     path.join(ENGINE_DIR, 'watches.json'),
     // Central work-items.json surfaced by getWorkItems().
@@ -1955,11 +2033,27 @@ function getStatusFastStateMtimePaths(config) {
   // 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).
+  //
+  // Per-project `.git/FETCH_HEAD` — bare `git fetch` advances FETCH_HEAD
+  // without touching `.git/logs/HEAD` (no HEAD move) or `.git/index` (no
+  // working-tree change). Without this entry, an external `git fetch`
+  // (or another tool background-fetching) leaves the dashboard's
+  // _statusCache and getProjectGitStatus's inner cache both serving the
+  // pre-fetch ahead/behind counts until BOTH the 10s FAST_STATE_TTL and
+  // the 15s probe TTL expire (W-mphdmr8c00030124).
+  //
+  // For linked worktrees (`<localPath>/.git` is a file pointing to
+  // `<main>/.git/worktrees/<name>/`), `_resolveGitDir` walks the pointer
+  // so logs/HEAD and FETCH_HEAD are tracked at the actual gitdir; the
+  // statSync in dashboard's `_getMtimes` tolerates ENOENT, so falling
+  // back to `<localPath>/.git/...` for non-linked-worktree repos is safe.
   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'));
+      const gitDir = _resolveGitDir(p.localPath) || path.join(p.localPath, '.git');
+      files.push(path.join(gitDir, 'logs', 'HEAD'));
+      files.push(path.join(gitDir, 'FETCH_HEAD'));
     }
   }
   return files;

package/package.json

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