@bli-cockpit/cli 0.2.10 → 0.2.11

package/dist/commands/backfill.js

@@ -9,7 +9,7 @@ import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET }
 import { acquireBackfillLock } from "../backfill-lock.js";
 import { BACKFILL_COMPLETION_RECHECK_MS, BACKFILL_COVERAGE_VERSION, emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCursor, recordBackfillCursorObservations, recordBackfillScanCoverage, writeBackfillCompletionMarker, writeBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, readLocalWorkContextForRepo, startLocalWorkContext } from "../local-state.js";
-import { collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
+import { DEFAULT_DISCOVERY_MAX_DEPTH, DEFAULT_DISCOVERY_MAX_REPOS, collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
 import { isRawEvidenceUploadableAttributionState } from "../raw-evidence-attribution-policy.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
 import { acquireSyncLock } from "../sync-lock.js";
@@ -17,8 +17,6 @@ import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelo
 const BACKFILL_UPLOAD_BATCH_SESSIONS = 25;
 const BACKFILL_MAX_CONSECUTIVE_FAILURES = 3;
 const ALL_BACKFILL_SINCE_MINUTES = 20 * 365 * 24 * 60;
-const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
-const DEFAULT_DISCOVERY_MAX_REPOS = 50;
 // Window a bare `cockpit backfill` uses. Wide enough to cover a new machine's
 // recent history and an intern who went quiet for a few weeks, narrow enough
 // that it is not the whole-history scan `--all` deliberately gates.

package/dist/commands/local.js

@@ -15,7 +15,7 @@ import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WIN
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { backfillCompletionCovers, emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCompletionMarker, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { acquireSyncLock } from "../sync-lock.js";
-import { collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
+import { DEFAULT_DISCOVERY_MAX_DEPTH, DEFAULT_DISCOVERY_MAX_REPOS, collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
 import { runAttributedWorktreeSync, matchesLiveSyncWorktree, } from "./session-sync.js";
 import { COLLECTION_ROOT_REQUIRED, missingCollectionRootMessage, normalizeRootsDetailed, resolveOnboardingRoots, rootRejectionExplanation, } from "../onboarding-roots.js";
 import { rawEvidenceGcSummary, runRawEvidenceLocalGc, } from "../raw-evidence-gc.js";
@@ -1779,8 +1779,6 @@ function rawEvidenceSyncLine(sync) {
 function cursorStatusLine(sync) {
     return `Cursor: ${sync.cursor_tracked_object_count} durable object(s) tracked`;
 }
-const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
-const DEFAULT_DISCOVERY_MAX_REPOS = 50;
 const ALL_SESSION_SCAN_WINDOW_MINUTES = 20 * 365 * 24 * 60;
 const SESSION_SCAN_OVERRIDE_LIMIT = 10_000;
 async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
@@ -1794,17 +1792,59 @@ async function discoverCommandWorktrees(repoRoot, discovery = {}, io) {
     });
     const worktrees = result.worktrees;
     if (!result.complete) {
-        const reasons = result.incomplete_reasons.join(",");
-        if (io) {
-            writeLine(io.stderr, `BLOCKED: repo discovery is incomplete (${reasons}); no collection cursor was advanced.`);
-        }
-        throw new Error(`repo discovery incomplete: ${reasons}. Raise --max-depth or --max-repos until every approved-root repo is included.`);
+        // Sync fails closed here ON PURPOSE, and that is not the bug. Advancing a
+        // cursor after a partial scan would mark the run as covering repos it
+        // never saw, permanently skipping their sessions — backfill can tolerate
+        // partial only because it keeps per-scope completion markers, and sync
+        // does not. The bug (BLI-2362) was that the refusal named no roots and
+        // gave no runnable command, so a big workspace just stayed red forever.
+        const message = incompleteDiscoveryMessage({
+            result,
+            roots,
+            maxDepth: discovery.maxDepth ?? DEFAULT_DISCOVERY_MAX_DEPTH,
+            maxRepos: maxWorktrees,
+            found: worktrees.length,
+        });
+        if (io)
+            writeLine(io.stderr, message);
+        throw new Error(message);
     }
     if (worktrees.length === 0 && !discovery.allowEmpty) {
         throw new Error("No git repos found. Run from a git repo, or from a parent folder containing git repos.");
     }
     return worktrees;
 }
+/**
+ * Names the roots that could not be covered and hands back a command that
+ * actually fixes it, with this machine's numbers already filled in.
+ */
+function incompleteDiscoveryMessage(input) {
+    const { result, roots, maxDepth, maxRepos, found } = input;
+    const blocked = result.incomplete_roots.length > 0 ? result.incomplete_roots : roots;
+    const hitRepoCap = result.incomplete_reasons.includes("max_worktrees_reached");
+    const nextDepth = maxDepth + 3;
+    const nextRepos = Math.max(maxRepos * 2, found + 50);
+    const retry = [
+        "cockpit do-everything",
+        ...roots.map((root) => `--workspace ${root}`),
+        `--max-depth ${hitRepoCap ? maxDepth : nextDepth}`,
+        `--max-repos ${nextRepos}`,
+    ].join(" ");
+    return [
+        `Cockpit could not finish scanning for repos, so it stopped instead of collecting a partial picture (${result.incomplete_reasons.join(", ")}).`,
+        "It stops rather than continuing because a partial scan would mark these repos as already checked and skip them from now on.",
+        "",
+        "Could not fully scan:",
+        ...blocked.map((root) => `  ${root}`),
+        "",
+        `Found ${found} repo(s) before stopping, with --max-depth ${maxDepth} and --max-repos ${maxRepos}.`,
+        "",
+        "Run this to raise the limits and try again:",
+        `  ${retry}`,
+        "",
+        "If that still stops, the folder is deeper or larger than expected — raise the numbers again, or point --workspace at the specific project folders instead of a parent.",
+    ].join("\n");
+}
 async function runMultiRepoOnboard(command, io, worktrees) {
     if (!command.json) {
         writeLine(io.stdout, `3/5 Parent folder mode: discovered ${worktrees.length} git worktree(s).`);

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.10");
+    writeLine(io?.stdout ?? process.stdout, "0.2.11");
     return 0;
   }
 

package/dist/repo-identity.js

@@ -16,6 +16,21 @@ const SKIPPED_DIR_NAMES = new Set([
     "node_modules",
     "out",
 ]);
+/**
+ * How deep discovery walks, and how many repos it will hold, when the caller
+ * names no limit. Both are the ONLY defaults — commands import these rather
+ * than declaring their own, because a second copy silently drifts.
+ *
+ * These are generous on purpose. Discovery stops descending the moment it sees
+ * a git marker and skips dot-dirs, `node_modules`, `dist` and friends, so the
+ * walk is bounded by plain folders rather than by repo contents: on a real
+ * workspace of 38 repos, depth 20 visited the same 308 directories in the same
+ * ~110ms as depth 6, because the tree simply ran out first. A limit that is too
+ * low is not merely slow — discovery fails closed, so every extra level costs
+ * nothing while every missing level costs the whole machine's collection.
+ */
+export const DEFAULT_DISCOVERY_MAX_DEPTH = 20;
+export const DEFAULT_DISCOVERY_MAX_REPOS = 200;
 export async function resolveRepoWorktreeIdentity(repoRoot) {
     const requestedPath = path.resolve(repoRoot);
     const gitRoot = await runGit(["rev-parse", "--show-toplevel"], requestedPath);
@@ -62,14 +77,14 @@ export async function discoverGitWorktrees(root, options = {}) {
 export async function discoverGitWorktreesWithStatus(root, options = {}) {
     const resolvedRoot = path.resolve(root);
     const allowedRoots = [await stableWorktreeRoot(resolvedRoot)];
-    const maxWorktrees = Math.max(1, options.maxWorktrees ?? 50);
+    const maxWorktrees = Math.max(1, options.maxWorktrees ?? DEFAULT_DISCOVERY_MAX_REPOS);
     const direct = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
     if (direct)
         return expandLinkedWorktrees([direct], maxWorktrees, allowedRoots);
     if (await hasGitMarker(resolvedRoot)) {
         return expandLinkedWorktrees([await fallbackFilesystemIdentity(resolvedRoot)], maxWorktrees, allowedRoots);
     }
-    const maxDepth = options.maxDepth ?? 2;
+    const maxDepth = options.maxDepth ?? DEFAULT_DISCOVERY_MAX_DEPTH;
     const discovered = new Map();
     const stack = [{ dir: resolvedRoot, depth: 0 }];
     const visited = new Set();
@@ -113,6 +128,8 @@ export async function discoverGitWorktreesWithStatus(root, options = {}) {
         worktrees: expanded.worktrees,
         complete: incompleteReasons.size === 0,
         incomplete_reasons: [...incompleteReasons].sort(),
+        // Single-root scanner: the only root in play is the one it was handed.
+        incomplete_roots: incompleteReasons.size === 0 ? [] : [path.resolve(root)],
     };
 }
 /**
@@ -126,9 +143,10 @@ export async function discoverGitWorktreesInRoots(roots, options = {}) {
     return (await discoverGitWorktreesInRootsWithStatus(roots, options)).worktrees;
 }
 export async function discoverGitWorktreesInRootsWithStatus(roots, options = {}) {
-    const maxWorktrees = Math.max(1, options.maxWorktrees ?? 50);
+    const maxWorktrees = Math.max(1, options.maxWorktrees ?? DEFAULT_DISCOVERY_MAX_REPOS);
     const discovered = new Map();
     const incompleteReasons = new Set();
+    const incompleteRoots = new Set();
     for (const root of roots) {
         const result = await discoverGitWorktreesWithStatus(root, {
             ...options,
@@ -136,11 +154,15 @@ export async function discoverGitWorktreesInRootsWithStatus(roots, options = {})
         });
         for (const reason of result.incomplete_reasons) {
             incompleteReasons.add(reason);
+            incompleteRoots.add(root);
         }
         for (const worktree of result.worktrees) {
             if (discovered.size >= maxWorktrees) {
                 if (!discovered.has(worktree.worktree_fingerprint)) {
                     incompleteReasons.add("max_worktrees_reached");
+                    // The cap is global, so the root being read when it filled up is the
+                    // one whose repos got dropped.
+                    incompleteRoots.add(root);
                 }
                 continue;
             }
@@ -151,6 +173,7 @@ export async function discoverGitWorktreesInRootsWithStatus(roots, options = {})
         worktrees: [...discovered.values()].sort(compareIdentity),
         complete: incompleteReasons.size === 0,
         incomplete_reasons: [...incompleteReasons].sort(),
+        incomplete_roots: [...incompleteRoots].sort(),
     };
 }
 /**
@@ -219,6 +242,9 @@ async function expandLinkedWorktrees(identities, maxWorktrees, allowedRoots) {
         worktrees,
         complete: incompleteReasons.length === 0,
         incomplete_reasons: incompleteReasons,
+        // Linked-worktree expansion is not scoped to one root; callers merge this
+        // into a result that already knows which roots were involved.
+        incomplete_roots: [],
     };
 }
 function isLinkedWorktreeWithinCollectionScope(linked, discoveredFromApprovedRoots, allowedRoots) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "private": false,
   "type": "module",
   "bin": {