@yemi33/minions 0.1.2253 → 0.1.2255

package/engine/cleanup.js

@@ -425,6 +425,39 @@ function _killProcessInWorktree(dir, activeProcesses, activeIds) {
   } catch {} // tmp dir may not exist
 }
 
+// Agent scratch (`.agent-temp` under the worktree root) holds throwaway git
+// repos written by dispatched agents + the test-suite-run-by-agents. Nothing
+// owns its lifecycle, so it accumulates unboundedly (observed: 26k+ dirs). The
+// worktree sweeps now SKIP it (shared.isWorktreeRootInfraEntry), so the pile no
+// longer stalls the tick loop — but it still needs bounded hygiene. This reaps
+// entries whose mtime is older than the TTL via plain fs deletion (NOT
+// removeWorktree — these are standalone repos, not worktrees). Bounded per pass
+// so the reaper itself can never stall the tick on a huge backlog; it drains
+// across cleanup cycles.
+const AGENT_SCRATCH_TTL_MS = 6 * 60 * 60 * 1000; // 6h — comfortably > agentTimeout (5h), so only dead-dispatch scratch is reaped
+const AGENT_SCRATCH_MAX_SCAN_PER_CLEANUP = 2000;
+
+function reapAgentScratch(worktreeRoot) {
+  const scratchDir = path.join(worktreeRoot, shared.WORKTREE_SCRATCH_DIR_NAME);
+  let names;
+  try { names = fs.readdirSync(scratchDir); } catch { return 0; } // no scratch dir → nothing to do
+  const cutoff = Date.now() - AGENT_SCRATCH_TTL_MS;
+  let reaped = 0;
+  const limit = Math.min(names.length, AGENT_SCRATCH_MAX_SCAN_PER_CLEANUP);
+  for (let i = 0; i < limit; i++) {
+    const full = path.join(scratchDir, names[i]);
+    let stat;
+    try { stat = fs.statSync(full); } catch { continue; }
+    if (stat.mtimeMs >= cutoff) continue; // recent — may belong to a live dispatch
+    try { fs.rmSync(full, { recursive: true, force: true }); reaped++; }
+    catch { /* locked / in use — leave it for a later pass */ }
+  }
+  if (reaped > 0) {
+    log('info', `Reaped ${reaped} stale agent-scratch entries (>${Math.round(AGENT_SCRATCH_TTL_MS / 3600000)}h) from ${scratchDir}`);
+  }
+  return reaped;
+}
+
 // ─── Cleanup Orchestrator ────────────────────────────────────────────────────
 
 async function runCleanup(config, verbose = false) {
@@ -685,6 +718,8 @@ async function runCleanup(config, verbose = false) {
 
   // 3. Clean git worktrees for merged/abandoned PRs
   const _attemptedWorktreePaths = new Set(); // dedup across projects sharing a worktreeRoot
+  const _reapedScratchRoots = new Set();     // reap each worktree root's .agent-temp once per cleanup
+  cleaned.agentScratch = 0;
   for (const project of projects) {
     const root = project.localPath ? path.resolve(project.localPath) : null;
     if (!root || !fs.existsSync(root)) continue;
@@ -698,6 +733,14 @@ async function runCleanup(config, verbose = false) {
 
     for (const worktreeRoot of worktreeRoots) {
 
+    // Bounded TTL reaper for the agent-scratch dir under this worktree root
+    // (once per unique root). Plain fs deletion — these are standalone repos,
+    // not worktrees, so removeWorktree (correctly) refuses them.
+    if (!_reapedScratchRoots.has(worktreeRoot)) {
+      _reapedScratchRoots.add(worktreeRoot);
+      try { cleaned.agentScratch += reapAgentScratch(worktreeRoot); } catch (_e) { /* best-effort */ }
+    }
+
     // Get PRs for this project
     const prs = safeJson(projectPrPath(project)) || [];
     const mergedBranches = new Set();
@@ -714,6 +757,12 @@ async function runCleanup(config, verbose = false) {
       const allDirs = [];
       const topDirs = fs.readdirSync(worktreeRoot);
       for (const dir of topDirs) {
+        // Skip infra/scratch dirs (`.agent-temp`, `.git`, …). They are never
+        // managed worktrees, and recursing into them (the else branch below)
+        // would readdir + stat their entire contents — `.agent-temp` routinely
+        // holds thousands of throwaway test/agent git repos, and walking that
+        // pile every cleanup cycle stalls the engine tick loop ("engine stale").
+        if (shared.isWorktreeRootInfraEntry(dir)) continue;
         const dirPath = path.join(worktreeRoot, dir);
         try { if (!fs.statSync(dirPath).isDirectory()) continue; } catch { continue; }
         // Check if this is a git worktree (has .git file) or a parent directory
@@ -1672,4 +1721,5 @@ module.exports = {
   getWorktreeBranch,         // exported for lifecycle cleanup
   cleanupMergedPrLocalBranch, // exported for lifecycle cleanup and testing
   collectPhantomBranchesForProject, // P-e0b4f7a5 — exported for testing
+  reapAgentScratch,                 // exported for testing
 };

package/engine/discover-project-skills.js

@@ -354,7 +354,12 @@ function discoverProjectSkills(args) {
         seenKey.add(key);
         all.push(entry);
       }
-      if (_now() > deadline) break;
+      // No deadline break here — skills and commands for the same area are
+      // scanned as an atomic unit. The deadline guards *starting* a new area
+      // (line above, `if (_now() > deadline) break`) but must not split a
+      // half-scanned area: doing so drops commands while keeping skills from
+      // the same area, causing test/prod divergence under load (PR-82 blind spot
+      // regression, CI failure yemi33#28135287117).
       for (const entry of _discoverCommandsAt(areaBase, projectPath, opts, deadline, `area:${area}`)) {
         const key = `command:${entry.name}`;
         if (seenKey.has(key)) continue;

package/engine/shared.js

@@ -5553,6 +5553,21 @@ function buildWorktreeDirName({
   return `${projectSlug}-${branchSlug}-${suffix}`;
 }
 
+// The worktree root (`<localPath>/../worktrees`) is a SHARED namespace: it holds
+// managed git worktrees AND infra/scratch dirs — most importantly `.agent-temp`,
+// the agent scratch base (`resolveAgentTempBaseDir`) where dispatched agents and
+// the test-suite-run-by-agents write thousands of throwaway git repos. Worktree
+// names from `buildWorktreeDirName` are ALWAYS `W-…` / `<project>-<branch>-<hash>`
+// and never dot-prefixed, so any dot-prefixed entry in the worktree root is infra
+// or scratch, never a managed worktree. The worktree sweeps MUST skip these — a
+// single `.agent-temp` accumulating thousands of entries otherwise makes the
+// sweep (which recurses one level into non-worktree dirs) readdir + stat the
+// whole pile every cleanup cycle, stalling the engine tick loop (engine "stale").
+const WORKTREE_SCRATCH_DIR_NAME = '.agent-temp';
+function isWorktreeRootInfraEntry(name) {
+  return typeof name === 'string' && name.length > 0 && name.charCodeAt(0) === 46; // '.'
+}
+
 /**
  * True when `childPath` is strictly nested within `parentPath` (descendant,
  * NOT the same path). Cross-platform via `path.relative`; resilient to mixed
@@ -8904,6 +8919,8 @@ module.exports = {
   deriveWorkItemBranchName,
   safeSlugComponent,
   buildWorktreeDirName, // exported for testing
+  isWorktreeRootInfraEntry,
+  WORKTREE_SCRATCH_DIR_NAME,
   isPathInside,
   isPathInsideOrEqual,
   parseWorktreePorcelain,

package/engine/worktree-gc.js

@@ -819,6 +819,8 @@ function pruneOrphanWorktrees(opts) {
       if (!ent || (typeof ent.isDirectory === 'function' && !ent.isDirectory())) continue;
       const name = ent.name || ent;
       if (typeof name !== 'string' || name.length === 0) continue;
+      // Skip infra/scratch dirs (`.agent-temp`, `.git`, …) — never worktrees.
+      if (shared.isWorktreeRootInfraEntry(name)) continue;
       projStats.scanned++;
       result.scanned++;
       const wtPath = path.join(wtParent, name);

package/package.json

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