@yemi33/minions 0.1.2044 → 0.1.2046

package/engine/queries.js

@@ -528,7 +528,7 @@ function getAgents(config) {
 
   return roster.map(a => {
     // Resolve which CLI runtime this agent dispatches to: per-agent override
-    // → engine.defaultCli → 'claude'. Surfaced so the dashboard can show a
+    // → engine.defaultCli → 'copilot'. Surfaced so the dashboard can show a
     // runtime tag next to the agent name.
     const runtime = shared.resolveAgentCli(a, config.engine || {});
     const inboxFiles = allInboxFiles.filter(f => f.includes(a.id));
@@ -1770,10 +1770,18 @@ function _projectGitStatusEqual(a, b) {
 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 entry = existing || { ts: 0, value: PROJECT_GIT_STATUS_PENDING, promise: null, refMtimes: null };
   const prevValue = entry.value;
+  // Snapshot ref mtimes BEFORE the probe so the next call compares against
+  // an exact baseline rather than a Date.now() timestamp. On Windows
+  // Date.now() can have ~15ms granularity while NTFS mtime is sub-ms, so
+  // a file written shortly before the probe could appear `mtimeMs > ts`
+  // even when nothing actually changed.
+  const probeStartTs = Date.now();
+  const probeStartRefMtimes = _snapshotProjectGitRefMtimes(localPath, configuredMainBranch);
   entry.promise = _probeProjectGitStatus(localPath, configuredMainBranch).then(value => {
-    entry.ts = Date.now();
+    entry.ts = probeStartTs;
+    entry.refMtimes = probeStartRefMtimes;
     entry.value = value;
     entry.promise = null;
     if (_onProjectGitStatusChanged && !_projectGitStatusEqual(prevValue, value)) {
@@ -1824,31 +1832,89 @@ function _resolveGitDir(localPath) {
   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) {
+// For a per-worktree gitdir, resolve the COMMON gitdir shared across all
+// linked worktrees of the same repo. Git writes per-worktree state
+// (HEAD, logs/HEAD, index) into the worktree-specific gitdir, but state
+// that's logically per-repo (objects, refs/remotes/, FETCH_HEAD) into
+// the common gitdir. The common location is recorded in
+// `<per-worktree-gitdir>/commondir`, a file containing either an
+// absolute path or a path relative to the per-worktree gitdir
+// (typically `../..` — resolves from `<main>/.git/worktrees/<name>` →
+// `<main>/.git`). For the main worktree there is no commondir file and
+// `gitDir` already IS the common gitdir, so this function returns
+// `gitDir` unchanged. Callers should track FETCH_HEAD and
+// refs/remotes/origin/<comparator> against the COMMON gitdir; logs/HEAD
+// must stay on the per-worktree gitdir so per-worktree HEAD moves still
+// register.
+function _resolveCommonGitDir(gitDir) {
+  if (!gitDir) return null;
+  const commondirPath = path.join(gitDir, 'commondir');
+  let raw = '';
+  try { raw = fs.readFileSync(commondirPath, { encoding: 'utf8', flag: 'r' }).trim(); }
+  catch { return gitDir; }
+  if (!raw) return gitDir;
+  return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
+}
+
+// Enumerate the per-project git ref files we watch for cache-busting:
+// logs/HEAD (per-worktree gitdir), FETCH_HEAD + refs/remotes/origin/* (common
+// gitdir for linked worktrees). Same paths as the fast-state mtime tracker
+// so callers see a coherent view across surfaces.
+function _projectGitRefFiles(localPath, configuredMainBranch) {
   const gitDir = _resolveGitDir(localPath);
-  if (!gitDir) return false;
-  const candidates = [
+  if (!gitDir) return null;
+  const commonGitDir = _resolveCommonGitDir(gitDir);
+  const files = [
     path.join(gitDir, 'logs', 'HEAD'),
-    path.join(gitDir, 'FETCH_HEAD'),
+    path.join(commonGitDir, 'FETCH_HEAD'),
   ];
   const comparator = configuredMainBranch && String(configuredMainBranch).trim();
   if (comparator) {
-    candidates.push(path.join(gitDir, 'refs', 'remotes', 'origin', comparator));
+    files.push(path.join(commonGitDir, '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 files;
+}
+
+// Snapshot mtimeMs for each ref file. Missing files record `null`. Used as
+// the baseline that the next `getProjectGitStatus` call compares against —
+// inequality, not threshold-vs-timestamp, so the result is precision-
+// independent (Windows `Date.now()` can be 15ms coarse while NTFS mtime is
+// sub-millisecond, which used to make threshold checks fire spuriously on
+// freshly-written files).
+function _snapshotProjectGitRefMtimes(localPath, configuredMainBranch) {
+  const files = _projectGitRefFiles(localPath, configuredMainBranch);
+  if (!files) return null;
+  const out = Object.create(null);
+  for (const f of files) {
+    try { out[f] = fs.statSync(f).mtimeMs; }
+    catch { out[f] = null; /* ENOENT recorded as null — flipping to present must bust */ }
+  }
+  return out;
+}
+
+// Return true when ANY tracked ref file's mtime (or existence) differs from
+// the snapshot captured during the last probe. Replaces the older threshold-
+// vs-cachedTs check that suffered from `Date.now()`/`mtimeMs` resolution
+// races on Windows. 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). Cost: 2-3 statSync per call —
+// well under the 'cheap' budget.
+function _projectGitRefsAdvancedSince(localPath, configuredMainBranch, snapshot) {
+  // No snapshot yet (legacy entry shape OR first call) — preserve the
+  // current cached value so the TTL-only fast-path still works. A real
+  // change still surfaces on the next /api/status because the fast-state
+  // mtime tracker watches the same files and will bust the upstream cache.
+  if (!snapshot) return false;
+  const current = _snapshotProjectGitRefMtimes(localPath, configuredMainBranch);
+  if (!current) return false;
+  for (const file of Object.keys(snapshot)) {
+    if (current[file] !== snapshot[file]) return true;
+  }
+  // Also catch a file that appeared since the snapshot (e.g. first `git
+  // fetch` materialises FETCH_HEAD).
+  for (const file of Object.keys(current)) {
+    if (!(file in snapshot)) return true;
   }
   return false;
 }
@@ -1865,7 +1931,7 @@ function getProjectGitStatus(localPath, configuredMainBranch = null) {
   // 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)) {
+      && !_projectGitRefsAdvancedSince(localPath, configuredMainBranch, cached.refMtimes)) {
     return cached.value;
   }
   // Cheap synchronous existsSync — short-circuits a path that just disappeared
@@ -2052,8 +2118,16 @@ function getStatusFastStateMtimePaths(config) {
     files.push(shared.projectPrPath(p));
     if (p && p.localPath) {
       const gitDir = _resolveGitDir(p.localPath) || path.join(p.localPath, '.git');
+      // logs/HEAD is per-worktree (HEAD moves, commits, checkouts).
+      // FETCH_HEAD lives in the COMMON gitdir — `git fetch` from a linked
+      // worktree writes to `<main>/.git/FETCH_HEAD`, not to the
+      // per-worktree subdir. Tracking only the per-worktree path here
+      // would leave linked-worktree projects stuck after `git fetch`
+      // (the file at `<main>/.git/worktrees/<name>/FETCH_HEAD` never
+      // exists — verified empirically).
+      const commonGitDir = _resolveCommonGitDir(gitDir);
       files.push(path.join(gitDir, 'logs', 'HEAD'));
-      files.push(path.join(gitDir, 'FETCH_HEAD'));
+      files.push(path.join(commonGitDir, 'FETCH_HEAD'));
     }
   }
   return files;
@@ -2100,9 +2174,25 @@ function getStatusFastStateMtimePaths(config) {
  * Files intentionally NOT tracked here:
  *   - version, autoMode, installId — change only on human/CLI edits, which
  *     already pop the slow-state via reloadConfig + the 60 s TTL.
- *   - project git state — already invalidated via the
- *     `_setOnProjectGitStatusChanged` callback into `invalidateStatusCache`
- *     (W-mpgrk5cy fix); also tracked in fast-state via `.git/logs/HEAD`.
+ *
+ * Per-project `.git/logs/HEAD` + `.git/FETCH_HEAD` ARE tracked here in
+ * addition to the fast-state tracker. The project payload (`projects:`
+ * with ahead/behind counts) lives in the slow-state slice, and
+ * `getProjectGitStatus` is called only from `_buildStatusSlowState`.
+ * Without tracking the git refs here, a fresh `git pull` busts
+ * fast-state but leaves slow-state cached for up to 60 s —
+ * `getProjectGitStatus` is never called, so the background probe never
+ * runs, so the `_setOnProjectGitStatusChanged` callback never fires,
+ * so the cache stays stale. Tracking the refs in BOTH tiers means any
+ * HEAD-moving / fetching git operation busts slow-state on the next
+ * poll, the rebuild calls `getProjectGitStatus` which then schedules
+ * the probe, and the probe's invalidation callback finishes the
+ * round-trip within ~1 poll cycle. `logs/HEAD` is resolved via
+ * `_resolveGitDir` (per-worktree); `FETCH_HEAD` is resolved via
+ * `_resolveCommonGitDir` (shared across all linked worktrees of the
+ * same repo — `git fetch` from a linked worktree writes to the main
+ * gitdir, not the per-worktree subdir, so tracking the per-worktree
+ * path would silently miss every fetch).
  *
  * NOTE: Detecting a change here busts the dashboard's slow-state cache, but
  * the inner per-source caches (`queries._skillsCache` 30 s, dashboard's
@@ -2170,6 +2260,22 @@ function getStatusSlowStateMtimePaths(config) {
     }
   }
 
+  // Per-project git refs — see the "Per-project .git/logs/HEAD" note in
+  // the header. Same pair the fast-state tracker watches; `logs/HEAD` is
+  // per-worktree (resolved via `_resolveGitDir`) while `FETCH_HEAD` lives
+  // in the COMMON gitdir (resolved via `_resolveCommonGitDir`) — git
+  // fetches from a linked worktree write to `<main>/.git/FETCH_HEAD`,
+  // not into the per-worktree subdir. For the main worktree both
+  // resolvers return the same gitdir, so the behavior collapses to the
+  // expected `<localPath>/.git/{logs/HEAD,FETCH_HEAD}` pair.
+  for (const project of projects) {
+    if (!project || !project.localPath) continue;
+    const gitDir = _resolveGitDir(project.localPath) || path.join(project.localPath, '.git');
+    const commonGitDir = _resolveCommonGitDir(gitDir);
+    files.push(path.join(gitDir, 'logs', 'HEAD'));
+    files.push(path.join(commonGitDir, 'FETCH_HEAD'));
+  }
+
   return files;
 }
 

package/engine/shared.js

@@ -1779,6 +1779,7 @@ const ENGINE_DEFAULTS = {
   autoReReviewPrs: true, // auto-dispatch review agents after a PR fix is pushed
   autoFixReviewFeedback: true, // auto-dispatch fix agents for minions review changes-requested verdicts
   autoFixHumanComments: true, // auto-dispatch fix agents for actionable human PR comments
+  autoConsolidateMemory: false, // opt-in: periodically spawn engine/kb-sweep-runner.js from the tick loop (4h cadence). Inbox→notes consolidation already runs every tick via consolidateInbox; this flag only controls the KB sweep.
   prNoOpFixPauseAttempts: 2, // pause one PR automation cause after repeated no-op fixes for unchanged evidence
   completionReportRetentionDays: 90, // retain completion report sidecars beyond capped dispatch history
   completionReportMaxFiles: 5000, // hard cap for completion report sidecars during cleanup
@@ -1787,6 +1788,7 @@ const ENGINE_DEFAULTS = {
   evalLoop: true, // enable review→fix loop after implementation completes
   evalMaxCost: null, // USD ceiling per work item across all eval iterations; null = no limit (gather baseline data first)
   maxRetries: 3, // max dispatch retries before marking work item as failed
+  maxRetriesPerAgent: 2, // W-mpmwxn1j — per-agent retry cap. When the SAME agent fails the same WI this many times, the next retry MUST reassign to a different eligible agent (consults routing.md + agent availability). Falls back to the same agent only when no alternate is available. Counted separately from `maxRetries` (which caps total retries across all agents) and tracked on the WI as `_retriesByAgent: { agentId: count }`. Hard-pinned agents bypass reassignment (operator intent wins).
   maxPhantomRetries: 3, // max retries for "phantom completion" (runtime crashed before emitting type:"result"); tracked separately from _retryCount so phantom retries don't pollute the normal PR-attachment retry budget. See engine/lifecycle.markMissingPrAttachment + detectNonTerminalResultSummary.
   minRetryGapMs: 120000, // 2min — minimum gap between retry dispatches for the same work item; prevents tight retry loops when an idempotent agent (e.g. review bailing out on a duplicate) cannot produce the expected output (#1770)
   pipelineApiRetries: 2, // max attempts for pipeline API calls
@@ -1854,7 +1856,7 @@ const ENGINE_DEFAULTS = {
   // Engine code MUST go through the resolveAgent*/resolveCc* helpers below;
   // never read these fields directly. New runtimes are added by registering
   // an adapter in engine/runtimes/index.js — these defaults stay stable.
-  defaultCli: 'claude',          // fleet-wide CLI runtime (must be a key in engine/runtimes/index.js)
+  defaultCli: 'copilot',         // fleet-wide CLI runtime (must be a key in engine/runtimes/index.js); flipped from 'claude' in W-mpmwxkk40007c995 — Copilot is now the primary runtime, Claude remains supported as an opt-in
   defaultModel: undefined,       // fleet-wide model; undefined = let the runtime adapter pick its own default
   ccCli: undefined,              // CC/doc-chat CLI override; undefined = inherit defaultCli (independent of agent path)
   ccModel: undefined,            // CC/doc-chat model override; undefined = inherit defaultModel
@@ -1877,6 +1879,7 @@ const ENGINE_DEFAULTS = {
   removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
   removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
   ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
+  ccTurnTimeoutMs: 300000, // W-mpmwxni2000c25c7-b: wall-clock cap per CC/doc-chat turn; on expiry the in-flight LLM call is aborted and the handler surfaces `{code:'cc-turn-timeout', retriable:true}` instead of hanging the UI
   docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
   ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls
   metricsFlushIntervalMs: 10000, // batch trackEngineUsage writes to metrics.json — flushed every 10s instead of per-call to cut lock contention and dashboard mtime churn
@@ -2082,7 +2085,7 @@ function _isMeaningful(v) {
  * Resolve the CLI runtime for a per-agent spawn. Priority:
  *   1. `agent.cli`              — per-agent override
  *   2. `engine.defaultCli`      — fleet default
- *   3. `ENGINE_DEFAULTS.defaultCli` ('claude') — hardcoded fallback
+ *   3. `ENGINE_DEFAULTS.defaultCli` ('copilot') — hardcoded fallback
  *
  * Does NOT fall through to `engine.ccCli`. CC and agents are independent paths.
  */
@@ -2096,7 +2099,7 @@ function resolveAgentCli(agent, engine) {
  * Resolve the CLI runtime for the Command Center / doc-chat. Priority:
  *   1. `engine.ccCli`           — CC-only override
  *   2. `engine.defaultCli`      — fleet default
- *   3. `ENGINE_DEFAULTS.defaultCli` ('claude') — hardcoded fallback
+ *   3. `ENGINE_DEFAULTS.defaultCli` ('copilot') — hardcoded fallback
  *
  * Does NOT inspect any agent overrides. CC has no notion of "which agent" —
  * it's a fleet-wide singleton.
@@ -4752,6 +4755,39 @@ function safeSlugComponent(text, maxLen = 80) {
   return `${base}-${hash}`.slice(0, maxLen);
 }
 
+// W-mpmwxn1j — Per-agent retry tracking. After the same agent has failed a WI
+// `ENGINE_DEFAULTS.maxRetriesPerAgent` times, the next dispatch must reassign
+// to a different eligible agent. The counter is stored on the WI itself
+// (`_retriesByAgent: { agentId: count }`) so engine restart preserves the
+// state. The counter is cleared on successful completion alongside
+// `_retryCount`. The caller passes a mutable WI object (inside a
+// `mutateWorkItems` / `mutateJsonFileLocked` callback) and the failed agent ID.
+// Anonymous failures (no resolvable agent) skip the bump — we'd corrupt the
+// shape with an `undefined` key. Returns the new per-agent count for logging.
+function bumpAgentRetryCount(wi, agentId) {
+  if (!wi || !agentId) return 0;
+  if (!wi._retriesByAgent || typeof wi._retriesByAgent !== 'object' || Array.isArray(wi._retriesByAgent)) {
+    wi._retriesByAgent = {};
+  }
+  const next = (Number(wi._retriesByAgent[agentId]) || 0) + 1;
+  wi._retriesByAgent[agentId] = next;
+  return next;
+}
+
+function getAgentRetryCount(wi, agentId) {
+  if (!wi || !agentId) return 0;
+  const map = wi._retriesByAgent;
+  if (!map || typeof map !== 'object' || Array.isArray(map)) return 0;
+  return Number(map[agentId]) || 0;
+}
+
+function resolveMaxRetriesPerAgent(config) {
+  const raw = config?.engine?.maxRetriesPerAgent;
+  const val = Number(raw);
+  if (Number.isFinite(val) && val > 0) return val;
+  return ENGINE_DEFAULTS.maxRetriesPerAgent;
+}
+
 const PR_AUTOMATION_CAUSE_LIMIT = 50;
 
 function getPrAutomationCauses(pr) {
@@ -4912,6 +4948,7 @@ module.exports = {
   tailTextBytes,
   appendTextTail,
   writeToInbox, parseNoteId,
+  bumpAgentRetryCount, getAgentRetryCount, resolveMaxRetriesPerAgent,
   exec,
   execAsync,
   execSilent,

package/engine/timeout.js

@@ -587,6 +587,10 @@ function checkTimeouts(config) {
             log('info', `Reconcile: work item ${item.id} agent died — auto-retry ${retries + 1}/${maxRetries}`);
             item.status = WI_STATUS.PENDING;
             item._retryCount = retries + 1;
+            // W-mpmwxn1j — bump per-agent retry count BEFORE deleting
+            // dispatched_to so the next dispatch can reassign away from the
+            // agent that died. Anonymous (no dispatched_to) failures don't bump.
+            if (item.dispatched_to) shared.bumpAgentRetryCount(item, item.dispatched_to);
             delete item.dispatched_at;
             delete item.dispatched_to;
             delete item._pendingReason;