@yemi33/minions 0.1.2384 → 0.1.2386

package/dashboard.js

@@ -1965,51 +1965,125 @@ function getEngineState() { return queries.getControl(); }
 
 let _worktreeCountCache = 0;
 let _worktreeCountCacheTs = 0;
+let _worktreeCountRefreshPromise = null;
+const WORKTREE_COUNT_SCAN_CONCURRENCY = 8;
 
-function _countWorktrees() {
-  const now = Date.now();
-  if (_worktreeCountCacheTs && (now - _worktreeCountCacheTs) < shared.ENGINE_DEFAULTS.worktreeCountCacheTtl) {
-    return _worktreeCountCache;
+function _isMissingWorktreePathError(error) {
+  return !!(error && (error.code === 'ENOENT' || error.code === 'ENOTDIR'));
+}
+
+async function _readWorktreeDirectory(dirPath) {
+  try {
+    return await fs.promises.readdir(dirPath, { withFileTypes: true });
+  } catch (error) {
+    if (_isMissingWorktreePathError(error)) return [];
+    throw error;
   }
+}
+
+async function _hasGitEntry(dirPath) {
   try {
-    const config = queries.getConfig();
-    const projects = shared.getProjects(config);
-    const worktreeRoots = new Map();
-    for (const p of projects) {
-      if (!p.localPath) continue;
-      const wtRoot = path.resolve(
-        p.localPath,
-        config.engine?.worktreeRoot || shared.ENGINE_DEFAULTS.worktreeRoot,
-      );
-      const rootKey = shared._normalizeWorktreePath(wtRoot);
-      if (!worktreeRoots.has(rootKey)) worktreeRoots.set(rootKey, wtRoot);
+    await fs.promises.access(path.join(dirPath, '.git'), fs.constants.F_OK);
+    return true;
+  } catch (error) {
+    if (_isMissingWorktreePathError(error)) return false;
+    throw error;
+  }
+}
+
+async function _mapWorktreeEntriesBounded(entries, worker) {
+  if (entries.length === 0) return [];
+  const results = new Array(entries.length);
+  let nextIndex = 0;
+
+  async function runWorker() {
+    while (nextIndex < entries.length) {
+      const index = nextIndex++;
+      results[index] = await worker(entries[index]);
     }
+  }
 
-    let count = 0;
-    for (const wtRoot of worktreeRoots.values()) {
-      try {
-        for (const dir of fs.readdirSync(wtRoot)) {
-          const dirPath = path.join(wtRoot, dir);
-          try { if (!fs.statSync(dirPath).isDirectory()) continue; } catch { continue; }
-          // A git worktree has a .git file (not directory) in its root
-          if (fs.existsSync(path.join(dirPath, '.git'))) {
-            count++;
-          } else {
-            // Parent directory — scan subdirs for nested worktrees
-            try {
-              for (const sub of fs.readdirSync(dirPath)) {
-                const subPath = path.join(dirPath, sub);
-                try { if (fs.statSync(subPath).isDirectory() && fs.existsSync(path.join(subPath, '.git'))) count++; } catch {}
-              }
-            } catch {}
-          }
-        }
-      } catch {}
+  const workerCount = Math.min(WORKTREE_COUNT_SCAN_CONCURRENCY, entries.length);
+  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+  return results;
+}
+
+async function _countWorktreesInRoot(worktreeRoot) {
+  const entries = await _readWorktreeDirectory(worktreeRoot);
+  const directories = entries.filter(entry => entry.isDirectory());
+  const inspected = await _mapWorktreeEntriesBounded(directories, async entry => {
+    const dirPath = path.join(worktreeRoot, entry.name);
+    if (await _hasGitEntry(dirPath)) return { direct: 1, nested: [] };
+
+    const nestedEntries = await _readWorktreeDirectory(dirPath);
+    return {
+      direct: 0,
+      nested: nestedEntries
+        .filter(nestedEntry => nestedEntry.isDirectory())
+        .map(nestedEntry => path.join(dirPath, nestedEntry.name)),
+    };
+  });
+  const directCount = inspected.reduce((total, result) => total + result.direct, 0);
+  const nestedPaths = inspected.flatMap(result => result.nested);
+  const nestedMatches = await _mapWorktreeEntriesBounded(nestedPaths, _hasGitEntry);
+  return directCount + nestedMatches.filter(Boolean).length;
+}
+
+async function _scanWorktreeCount() {
+  const config = queries.getConfig();
+  const worktreeRoots = new Map();
+  for (const project of shared.getProjects(config)) {
+    if (!project.localPath) continue;
+    const worktreeRoot = path.resolve(
+      project.localPath,
+      config.engine?.worktreeRoot || shared.ENGINE_DEFAULTS.worktreeRoot,
+    );
+    const rootKey = shared._normalizeWorktreePath(worktreeRoot);
+    if (!worktreeRoots.has(rootKey)) worktreeRoots.set(rootKey, worktreeRoot);
+  }
+
+  let count = 0;
+  for (const worktreeRoot of worktreeRoots.values()) {
+    count += await _countWorktreesInRoot(worktreeRoot);
+  }
+  return count;
+}
+
+function _refreshWorktreeCount() {
+  if (_worktreeCountRefreshPromise) return _worktreeCountRefreshPromise;
+
+  _worktreeCountRefreshPromise = (async () => {
+    try {
+      const count = await _scanWorktreeCount();
+      const changed = count !== _worktreeCountCache;
+      _worktreeCountCache = count;
+      _worktreeCountCacheTs = Date.now();
+      // A cold outer rebuild may already have captured the previous count.
+      if (changed && (_statusCache || _statusRebuildPromise)) invalidateStatusCache();
+      return count;
+    } catch (error) {
+      _worktreeCountCacheTs = Date.now();
+      console.warn(`[dashboard] worktree count refresh failed: ${error.message}`);
+      return _worktreeCountCache;
+    } finally {
+      _worktreeCountRefreshPromise = null;
     }
-    _worktreeCountCache = count;
-    _worktreeCountCacheTs = now;
-    return count;
-  } catch { return 0; }
+  })();
+  return _worktreeCountRefreshPromise;
+}
+
+function _countWorktrees() {
+  const now = Date.now();
+  if (!_worktreeCountCacheTs || (now - _worktreeCountCacheTs) >= shared.ENGINE_DEFAULTS.worktreeCountCacheTtl) {
+    _refreshWorktreeCount();
+  }
+  return _worktreeCountCache;
+}
+
+function _resetWorktreeCountCacheForTesting() {
+  _worktreeCountCache = 0;
+  _worktreeCountCacheTs = 0;
+  _worktreeCountRefreshPromise = null;
 }
 
 // ── npm update check ────────────────────────────────────────────────────────
@@ -14770,6 +14844,7 @@ module.exports = {
   _setStatusRefreshHook,
   _resetStatusCacheForTesting,
   _ifNoneMatchHasEtag,
+  _countWorktrees, _refreshWorktreeCount, _scanWorktreeCount, _resetWorktreeCountCacheForTesting, // exported for testing
   // W-status-swr — exported for direct unit tests of the subprocess-free git
   // HEAD parser and the prefix-tolerant short-SHA comparison. No production
   // caller imports these; they are test seams.
@@ -14833,6 +14908,14 @@ if (require.main === module) {
   // block boot.
   (async () => {
     const _warmStartedAt = Date.now();
+    // This reporting-only scan must never delay port binding.
+    _refreshWorktreeCount()
+      .then(worktreeCount => {
+        console.log(`[boot] pre-warmed worktree count (${worktreeCount}) off the request path`);
+      })
+      .catch(error => {
+        console.warn(`[boot] worktree count pre-warm failed: ${error && error.message}`);
+      });
     try {
       await warmProjectGitStatusCache();
       const ms = Date.now() - _warmStartedAt;

package/minions.js

@@ -423,11 +423,13 @@ async function initMinions({ skipScan = false, scanRoot, scanDepth } = {}) {
       config.engine.defaultCli = detected[0];
       console.log(`\n  ✓ Detected ${detected[0]} CLI — set as fleet default runtime`);
     } else if (detected.length > 1) {
-      // Both available — prefer claude (the historical default and broader skill coverage)
-      config.engine.defaultCli = detected.includes('claude') ? 'claude' : detected[0];
+      // Prefer the canonical fleet default when it is installed.
+      config.engine.defaultCli = detected.includes(ENGINE_DEFAULTS.defaultCli)
+        ? ENGINE_DEFAULTS.defaultCli
+        : detected[0];
       console.log(`\n  ✓ Detected ${detected.join(' + ')} — fleet default set to ${config.engine.defaultCli}`);
     }
-    // If nothing detected, leave defaultCli unset (engine falls back to 'claude')
+    // If nothing is detected, leave defaultCli unset so the engine uses its canonical default.
   }
   saveConfig(config);
   console.log(`\n  Minions initialized at ${MINIONS_HOME}`);

package/package.json

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