@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/adapters/attribution-core-fallbacks.js

@@ -75,17 +75,7 @@ function deepestApprovedRootForRecordedPaths(recordedPaths, collectionRoots) {
  * root.
  */
 export function fallbackToFolderWorkspaceForContainerCwd(options) {
-    let bestFolder = null;
-    for (const recordedPath of pathComparisonAliases(options.approvedRecordedPaths)) {
-        const resolvedPath = resolveAttributionPath(recordedPath);
-        const containedWorktrees = options.worktrees.filter((worktree) => isPathStrictlyWithin(worktree.repo_root, resolvedPath));
-        if (containedWorktrees.length === 0)
-            continue;
-        const depth = pathDepth(resolvedPath);
-        if (!bestFolder || depth > bestFolder.depth) {
-            bestFolder = { resolvedPath, depth, containedWorktrees };
-        }
-    }
+    const bestFolder = findDeepestContainerFolder(options);
     if (!bestFolder)
         return null;
     const repoFingerprints = new Set(bestFolder.containedWorktrees.map((worktree) => worktree.repo_fingerprint));
@@ -123,6 +113,20 @@ export function fallbackToFolderWorkspaceForContainerCwd(options) {
         },
     };
 }
+function findDeepestContainerFolder(options) {
+    let bestFolder = null;
+    for (const recordedPath of pathComparisonAliases(options.approvedRecordedPaths)) {
+        const resolvedPath = resolveAttributionPath(recordedPath);
+        const containedWorktrees = options.worktrees.filter((worktree) => isPathStrictlyWithin(worktree.repo_root, resolvedPath));
+        if (containedWorktrees.length === 0)
+            continue;
+        const depth = pathDepth(resolvedPath);
+        if (!bestFolder || depth > bestFolder.depth) {
+            bestFolder = { resolvedPath, depth, containedWorktrees };
+        }
+    }
+    return bestFolder;
+}
 export function fallbackToKnownRepoPrimaryWorkContext(options) {
     const originCandidates = options.worktrees.filter((worktree) => worktree.repo_origin_url &&
         options.signals.originUrls.includes(worktree.repo_origin_url));

package/dist/adapters/attribution-core-score.js

@@ -16,6 +16,17 @@ import { attachApprovedRootWorkspace, fallbackToFolderWorkspaceForContainerCwd,
  * origin standing in for a deleted repo.
  */
 export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
+    const context = prepareScoringContext(signals, worktrees, options);
+    if (!hasAnyAttributionSignal(signals))
+        return unattributed("no_repo_signals");
+    const scored = scoreCandidateWorktrees(context);
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    if (!best || best.score === 0)
+        return resolveUnmatchedSignals(context);
+    return resolveBestMatch(context, scored, best);
+}
+function prepareScoringContext(signals, worktrees, options) {
     const originLabel = options.originLabel ?? "origin_url_match";
     const collectionRoots = collectionRootComparisonAliases(options.collectionRoots ?? []);
     const recordedPaths = [...signals.cwds, ...signals.workspaceRoots];
@@ -23,14 +34,17 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const scopedWorktrees = worktreesWithinCollectionScope(worktrees, collectionRoots);
     const cwdComparisonPaths = pathComparisonAliases(signals.cwds);
     const workspaceRootComparisonPaths = pathComparisonAliases(signals.workspaceRoots);
-    const hasAnySignal = signals.cwds.length > 0 ||
-        signals.workspaceRoots.length > 0 ||
-        signals.originUrls.length > 0 ||
-        signals.branches.length > 0 ||
-        signals.headShas.length > 0;
-    if (!hasAnySignal) {
-        return unattributed("no_repo_signals");
-    }
+    return {
+        signals, options, originLabel, collectionRoots, recordedPaths,
+        approvedRecordedPaths, scopedWorktrees, cwdComparisonPaths, workspaceRootComparisonPaths
+    };
+}
+function hasAnyAttributionSignal(signals) {
+    return signals.cwds.length > 0 || signals.workspaceRoots.length > 0 ||
+        signals.originUrls.length > 0 || signals.branches.length > 0 || signals.headShas.length > 0;
+}
+function scoreCandidateWorktrees(context) {
+    const { cwdComparisonPaths, workspaceRootComparisonPaths, scopedWorktrees } = context;
     // D6 deepest-root tie-break: a path signal can sit inside several candidate
     // roots when one root is nested inside another (e.g. Claude's
     // `<repo>/.claude/worktrees/<name>` linked worktrees, or any monorepo with a
@@ -39,73 +53,76 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     // root earns the path score, which is also the most specific (correct) match.
     const cwdWinners = deepestContainers(cwdComparisonPaths, scopedWorktrees);
     const workspaceRootWinners = deepestContainers(workspaceRootComparisonPaths, scopedWorktrees);
-    const scored = scopedWorktrees.map((worktree) => {
-        const matched = [];
-        let score = 0;
-        let pathScore = 0;
-        if (cwdWinners.has(worktree.worktree_fingerprint)) {
-            score += SCORE_CWD_MATCH;
-            pathScore += SCORE_CWD_MATCH;
-            matched.push("cwd_match");
-        }
-        if (workspaceRootWinners.has(worktree.worktree_fingerprint)) {
-            score += SCORE_WORKSPACE_ROOT_MATCH;
-            pathScore += SCORE_WORKSPACE_ROOT_MATCH;
-            matched.push("workspace_root_match");
-        }
-        if (worktree.repo_origin_url &&
-            signals.originUrls.includes(worktree.repo_origin_url)) {
-            score += SCORE_ORIGIN_MATCH;
-            matched.push(originLabel);
-        }
-        if (signals.branches.includes(worktree.branch)) {
-            score += SCORE_BRANCH_MATCH;
-            matched.push("branch_match");
-        }
-        if (worktree.head_sha && signals.headShas.includes(worktree.head_sha)) {
-            score += SCORE_HEAD_SHA_MATCH;
-            matched.push("head_sha_match");
-        }
-        return { worktree, score, pathScore, matched };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    const best = scored[0];
-    const secondBestScore = scored[1]?.score ?? 0;
-    if (!best || best.score === 0) {
-        if (approvedRecordedPaths.length > 0) {
-            const folderFallback = fallbackToFolderWorkspaceForContainerCwd({
-                signals,
-                worktrees: scopedWorktrees,
-                approvedRecordedPaths,
-            });
-            if (folderFallback)
-                return folderFallback;
-            const transcriptFallback = fallbackToTranscriptOriginForDeletedRepo({
-                originLabel,
-                signals,
-                collectionRoots,
-                pathExists: options.pathExists,
-            });
-            if (transcriptFallback) {
-                return attachApprovedRootWorkspace({
-                    outcome: transcriptFallback,
-                    signals,
-                    collectionRoots,
-                    approvedRecordedPaths,
-                });
-            }
+    return scopedWorktrees.map(worktree => scoreOneWorktree(worktree, context.signals, context.originLabel, cwdWinners, workspaceRootWinners));
+}
+function scoreOneWorktree(worktree, signals, originLabel, cwdWinners, workspaceRootWinners) {
+    const matched = [];
+    let score = 0;
+    let pathScore = 0;
+    if (cwdWinners.has(worktree.worktree_fingerprint)) {
+        score += SCORE_CWD_MATCH;
+        pathScore += SCORE_CWD_MATCH;
+        matched.push("cwd_match");
+    }
+    if (workspaceRootWinners.has(worktree.worktree_fingerprint)) {
+        score += SCORE_WORKSPACE_ROOT_MATCH;
+        pathScore += SCORE_WORKSPACE_ROOT_MATCH;
+        matched.push("workspace_root_match");
+    }
+    if (worktree.repo_origin_url &&
+        signals.originUrls.includes(worktree.repo_origin_url)) {
+        score += SCORE_ORIGIN_MATCH;
+        matched.push(originLabel);
+    }
+    if (signals.branches.includes(worktree.branch)) {
+        score += SCORE_BRANCH_MATCH;
+        matched.push("branch_match");
+    }
+    if (worktree.head_sha && signals.headShas.includes(worktree.head_sha)) {
+        score += SCORE_HEAD_SHA_MATCH;
+        matched.push("head_sha_match");
+    }
+    return { worktree, score, pathScore, matched };
+}
+function resolveUnmatchedSignals(context) {
+    const { signals, options, originLabel, collectionRoots, approvedRecordedPaths, scopedWorktrees } = context;
+    if (approvedRecordedPaths.length > 0) {
+        const folderFallback = fallbackToFolderWorkspaceForContainerCwd({
+            signals,
+            worktrees: scopedWorktrees,
+            approvedRecordedPaths,
+        });
+        if (folderFallback)
+            return folderFallback;
+        const transcriptFallback = fallbackToTranscriptOriginForDeletedRepo({
+            originLabel,
+            signals,
+            collectionRoots,
+            pathExists: options.pathExists,
+        });
+        if (transcriptFallback) {
             return attachApprovedRootWorkspace({
-                outcome: skipped(terminalReasonForRecordedPaths(approvedRecordedPaths, options.pathExists)),
+                outcome: transcriptFallback,
                 signals,
                 collectionRoots,
                 approvedRecordedPaths,
             });
         }
-        const reason = signals.cwds.length > 0 || signals.workspaceRoots.length > 0
-            ? "cwd_outside_scanned_worktrees"
-            : "no_matching_worktree_signals";
-        return unattributed(reason);
+        return attachApprovedRootWorkspace({
+            outcome: skipped(terminalReasonForRecordedPaths(approvedRecordedPaths, options.pathExists)),
+            signals,
+            collectionRoots,
+            approvedRecordedPaths,
+        });
     }
+    const reason = signals.cwds.length > 0 || signals.workspaceRoots.length > 0
+        ? "cwd_outside_scanned_worktrees"
+        : "no_matching_worktree_signals";
+    return unattributed(reason);
+}
+function resolveBestMatch(context, scored, best) {
+    const { signals, collectionRoots, approvedRecordedPaths } = context;
+    const secondBestScore = scored[1]?.score ?? 0;
     const score = clampScore(best.score);
     const pathScore = clampScore(best.pathScore);
     if (best.pathScore > 0 &&
@@ -121,25 +138,9 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
         };
     }
     if (best.pathScore === 0) {
-        if (collectionRoots.length > 0 && approvedRecordedPaths.length === 0) {
-            return unattributed(recordedPaths.length > 0
-                ? "cwd_outside_scanned_worktrees"
-                : "no_matching_worktree_signals");
-        }
-        const fallback = fallbackToKnownRepoPrimaryWorkContext({
-            originLabel,
-            scored,
-            signals,
-            worktrees: scopedWorktrees,
-        });
-        if (fallback) {
-            return attachApprovedRootWorkspace({
-                outcome: fallback,
-                signals,
-                collectionRoots,
-                approvedRecordedPaths,
-            });
-        }
+        const fallback = resolveOriginOnlyMatch(context, scored);
+        if (fallback)
+            return fallback;
     }
     return attachApprovedRootWorkspace({
         outcome: {
@@ -156,4 +157,27 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
         collectionRoots,
         approvedRecordedPaths,
     });
+}
+function resolveOriginOnlyMatch(context, scored) {
+    const { signals, originLabel, collectionRoots, recordedPaths, approvedRecordedPaths, scopedWorktrees } = context;
+    if (collectionRoots.length > 0 && approvedRecordedPaths.length === 0) {
+        return unattributed(recordedPaths.length > 0
+            ? "cwd_outside_scanned_worktrees"
+            : "no_matching_worktree_signals");
+    }
+    const fallback = fallbackToKnownRepoPrimaryWorkContext({
+        originLabel,
+        scored,
+        signals,
+        worktrees: scopedWorktrees,
+    });
+    if (fallback) {
+        return attachApprovedRootWorkspace({
+            outcome: fallback,
+            signals,
+            collectionRoots,
+            approvedRecordedPaths,
+        });
+    }
+    return null;
 }

package/dist/adapters/car-state.js

@@ -6,41 +6,7 @@ import { describeError, isMissingFileFailure } from "../health-detail.js";
 export async function collectCarState(context) {
     const ticketsDir = path.join(context.repoRoot, ".codex-autorunner", "tickets");
     try {
-        const filenames = (await fs.readdir(ticketsDir))
-            .filter(isCarTicketFilename)
-            .sort();
-        const tickets = await Promise.all(filenames.map(async (filename) => parseCarTicketFile(path.join(ticketsDir, filename))));
-        const openTickets = tickets.filter((ticket) => !ticket.done);
-        const currentTicket = openTickets[0] ?? null;
-        const ticketId = currentTicket && parseTicketIdFromText(`${currentTicket.ticket_id} ${currentTicket.title}`);
-        const ticketBindingCandidates = ticketId
-            ? [
-                {
-                    ticket_id: ticketId,
-                    binding_source: "car_ticket",
-                    confidence: 0.7,
-                    evidence_labels: [`car_ticket:${currentTicket.file}`],
-                },
-            ]
-            : [];
-        const facts = {
-            present: true,
-            current_ticket: currentTicket,
-            open_ticket_count: openTickets.length,
-        };
-        return {
-            scan: makeCarScan({
-                context,
-                status: "ok",
-                facts,
-                ticketBindingCandidates,
-                diagnosticLabels: [
-                    `car_open_tickets:${facts.open_ticket_count}`,
-                    currentTicket ? `car_current_ticket:${currentTicket.file}` : "car_no_open_ticket",
-                ],
-            }),
-            facts,
-        };
+        return await collectPresentCarState(context, ticketsDir);
     }
     catch (error) {
         // `car_not_present` is honest for a repo with no `car/` folder, which is
@@ -70,6 +36,43 @@ export async function collectCarState(context) {
         };
     }
 }
+async function collectPresentCarState(context, ticketsDir) {
+    const filenames = (await fs.readdir(ticketsDir))
+        .filter(isCarTicketFilename)
+        .sort();
+    const tickets = await Promise.all(filenames.map(async (filename) => parseCarTicketFile(path.join(ticketsDir, filename))));
+    const openTickets = tickets.filter((ticket) => !ticket.done);
+    const currentTicket = openTickets[0] ?? null;
+    const ticketId = currentTicket && parseTicketIdFromText(`${currentTicket.ticket_id} ${currentTicket.title}`);
+    const ticketBindingCandidates = ticketId
+        ? [
+            {
+                ticket_id: ticketId,
+                binding_source: "car_ticket",
+                confidence: 0.7,
+                evidence_labels: [`car_ticket:${currentTicket.file}`],
+            },
+        ]
+        : [];
+    const facts = {
+        present: true,
+        current_ticket: currentTicket,
+        open_ticket_count: openTickets.length,
+    };
+    return {
+        scan: makeCarScan({
+            context,
+            status: "ok",
+            facts,
+            ticketBindingCandidates,
+            diagnosticLabels: [
+                `car_open_tickets:${facts.open_ticket_count}`,
+                currentTicket ? `car_current_ticket:${currentTicket.file}` : "car_no_open_ticket",
+            ],
+        }),
+        facts,
+    };
+}
 export async function parseCarTicketFile(filePath) {
     const raw = await fs.readFile(filePath, "utf8");
     return {

package/dist/adapters/claude-attribution-discovery.js

@@ -11,14 +11,9 @@ import { CLAUDE_SESSION_MAX_SIDECAR_FILES, } from "./claude-attribution-types.js
 export async function discoverClaudeSessions(projectsDir, cutoffMs) {
     const sessions = [];
     const projectDirsSkipped = 0;
-    let projectDirReadFailedCount = 0;
-    let sessionStatFailedCount = 0;
-    let sidecarDirReadFailedCount = 0;
-    let sidecarStatFailedCount = 0;
-    // Same shape as the Codex walk: first reason plus counts, once. Per-file
-    // lines across a store of thousands would be their own silence (BLI-3238).
-    let firstDirectoryFailure = null;
-    let firstStatFailure = null;
+    const sessionStatFailedCount = 0;
+    const sidecarDirReadFailedCount = 0;
+    const sidecarStatFailedCount = 0;
     let projectEntries;
     try {
         projectEntries = await fs.readdir(projectsDir, { withFileTypes: true });
@@ -42,6 +37,19 @@ export async function discoverClaudeSessions(projectsDir, cutoffMs) {
             sidecarStatFailedCount,
         };
     }
+    return walkProjectSessions(projectEntries, projectsDir, cutoffMs);
+}
+async function walkProjectSessions(projectEntries, projectsDir, cutoffMs) {
+    const sessions = [];
+    const projectDirsSkipped = 0;
+    let projectDirReadFailedCount = 0;
+    let sessionStatFailedCount = 0;
+    let sidecarDirReadFailedCount = 0;
+    let sidecarStatFailedCount = 0;
+    // Same shape as the Codex walk: first reason plus counts, once. Per-file
+    // lines across a store of thousands would be their own silence (BLI-3238).
+    let firstDirectoryFailure = null;
+    let firstStatFailure = null;
     for (const projectEntry of projectEntries) {
         if (!projectEntry.isDirectory())
             continue;
@@ -57,40 +65,61 @@ export async function discoverClaudeSessions(projectsDir, cutoffMs) {
             }
             continue;
         }
-        for (const sessionEntry of sessionEntries) {
-            if (!sessionEntry.isFile())
-                continue;
-            if (!SESSION_FILE_UUID_PATTERN.test(sessionEntry.name))
-                continue;
-            const mainFile = path.join(projectDir, sessionEntry.name);
-            let mainStat;
-            try {
-                mainStat = await fs.stat(mainFile);
-            }
-            catch (error) {
-                sessionStatFailedCount += 1;
-                firstStatFailure ??= describeError(error);
-                continue;
-            }
-            const sessionUuid = sessionEntry.name.replace(/\.jsonl$/i, "");
-            const sidecarDiscovery = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
-            const { sidecars, sidecarsCapped } = sidecarDiscovery;
-            sidecarDirReadFailedCount += sidecarDiscovery.dirReadFailedCount;
-            sidecarStatFailedCount += sidecarDiscovery.statFailedCount;
-            const recencyMs = Math.max(mainStat.mtimeMs, ...sidecars.map((sidecar) => sidecar.mtimeMs));
-            // D10: a session is recent if its main file OR any sidecar is in window.
-            if (recencyMs < cutoffMs)
-                continue;
-            sessions.push({
-                mainFile,
-                mainMtimeMs: mainStat.mtimeMs,
-                mainByteSize: mainStat.size,
-                recencyMs,
-                sidecars,
-                sidecarsCapped,
-            });
+        const project = await collectProjectSessions(sessionEntries, projectDir, cutoffMs, sessions);
+        sessionStatFailedCount += project.sessionStatFailedCount;
+        sidecarDirReadFailedCount += project.sidecarDirReadFailedCount;
+        sidecarStatFailedCount += project.sidecarStatFailedCount;
+        firstStatFailure ??= project.firstStatFailure;
+    }
+    logSessionDiscoveryFailures(sessions, projectDirReadFailedCount, sessionStatFailedCount, firstDirectoryFailure, firstStatFailure);
+    return {
+        sessions,
+        projectDirsSkipped,
+        projectDirReadFailedCount,
+        sessionStatFailedCount,
+        sidecarDirReadFailedCount,
+        sidecarStatFailedCount,
+    };
+}
+async function collectProjectSessions(sessionEntries, projectDir, cutoffMs, sessions) {
+    let sessionStatFailedCount = 0, sidecarDirReadFailedCount = 0, sidecarStatFailedCount = 0;
+    let firstStatFailure = null;
+    for (const sessionEntry of sessionEntries) {
+        if (!sessionEntry.isFile())
+            continue;
+        if (!SESSION_FILE_UUID_PATTERN.test(sessionEntry.name))
+            continue;
+        const mainFile = path.join(projectDir, sessionEntry.name);
+        let mainStat;
+        try {
+            mainStat = await fs.stat(mainFile);
+        }
+        catch (error) {
+            sessionStatFailedCount += 1;
+            firstStatFailure ??= describeError(error);
+            continue;
         }
+        const sessionUuid = sessionEntry.name.replace(/\.jsonl$/i, "");
+        const sidecarDiscovery = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
+        const { sidecars, sidecarsCapped } = sidecarDiscovery;
+        sidecarDirReadFailedCount += sidecarDiscovery.dirReadFailedCount;
+        sidecarStatFailedCount += sidecarDiscovery.statFailedCount;
+        const recencyMs = Math.max(mainStat.mtimeMs, ...sidecars.map((sidecar) => sidecar.mtimeMs));
+        // D10: a session is recent if its main file OR any sidecar is in window.
+        if (recencyMs < cutoffMs)
+            continue;
+        sessions.push({
+            mainFile,
+            mainMtimeMs: mainStat.mtimeMs,
+            mainByteSize: mainStat.size,
+            recencyMs,
+            sidecars,
+            sidecarsCapped,
+        });
     }
+    return { sessionStatFailedCount, sidecarDirReadFailedCount, sidecarStatFailedCount, firstStatFailure };
+}
+function logSessionDiscoveryFailures(sessions, projectDirReadFailedCount, sessionStatFailedCount, firstDirectoryFailure, firstStatFailure) {
     if (projectDirReadFailedCount > 0 || sessionStatFailedCount > 0) {
         console.error("[claude-attribution] Claude sessions were invisible to the walk", JSON.stringify({
             reason: "session_discovery_incomplete",
@@ -103,14 +132,6 @@ export async function discoverClaudeSessions(projectsDir, cutoffMs) {
             ...(firstStatFailure ? { first_stat_failure: firstStatFailure } : {}),
         }));
     }
-    return {
-        sessions,
-        projectDirsSkipped,
-        projectDirReadFailedCount,
-        sessionStatFailedCount,
-        sidecarDirReadFailedCount,
-        sidecarStatFailedCount,
-    };
 }
 async function discoverSidecars(subagentsDir) {
     let entries;
@@ -134,6 +155,17 @@ async function discoverSidecars(subagentsDir) {
             statFailedCount: 0,
         };
     }
+    const { discovered, statFailedCount } = await statSidecars(entries, subagentsDir);
+    discovered.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const capped = Math.max(0, discovered.length - CLAUDE_SESSION_MAX_SIDECAR_FILES);
+    return {
+        sidecars: discovered.slice(0, CLAUDE_SESSION_MAX_SIDECAR_FILES),
+        sidecarsCapped: capped,
+        dirReadFailedCount: 0,
+        statFailedCount,
+    };
+}
+async function statSidecars(entries, subagentsDir) {
     const discovered = [];
     let statFailedCount = 0;
     let firstSidecarStatFailure = null;
@@ -170,14 +202,7 @@ async function discoverSidecars(subagentsDir) {
             ...firstSidecarStatFailure,
         }));
     }
-    discovered.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const capped = Math.max(0, discovered.length - CLAUDE_SESSION_MAX_SIDECAR_FILES);
-    return {
-        sidecars: discovered.slice(0, CLAUDE_SESSION_MAX_SIDECAR_FILES),
-        sidecarsCapped: capped,
-        dirReadFailedCount: 0,
-        statFailedCount,
-    };
+    return { discovered, statFailedCount };
 }
 function isMissingPathError(error) {
     return (error instanceof Error &&