@bli-cockpit/cli 0.2.47 → 0.2.49

package/dist/adapters/raw-evidence-attribution-gaps.js

@@ -0,0 +1,133 @@
+import { isLiveRawEvidenceSyncAttribution } from "../raw-evidence-attribution-policy.js";
+import { recordScanned, recordSkipCount, recordTruncationCount, } from "./raw-evidence-completeness.js";
+/**
+ * Record every Codex session the attribution scan saw, capped or lost, so the
+ * pass reports them as its own gaps.
+ */
+export function recordCodexAttributionCompleteness(ledger, scan, selectedPaths) {
+    recordScanned(ledger, "codex_attribution", scan.scanned_file_count);
+    ledger.caps.push(...codexAttributionCaps(scan));
+    recordSkipCount(ledger, "codex_attribution", "session_limit_overflow", Math.max(0, scan.discovered_file_count - scan.scanned_file_count));
+    recordSkipCount(ledger, "codex_attribution", "directory_read_failed", scan.directory_read_failed_count);
+    recordSkipCount(ledger, "codex_attribution", "file_stat_failed", scan.stat_failed_count);
+    recordSkipCount(ledger, "codex_attribution", "secret_like_directory", scan.secret_path_skipped_count);
+    recordAttributionResultSkips(ledger, "codex_attribution", scan.results, selectedPaths);
+}
+/** Every limit the Codex attribution scan ran under, and whether it bit. */
+function codexAttributionCaps(scan) {
+    return [
+        {
+            source: "codex_attribution",
+            cap_type: "scan_window_minutes",
+            limit: scan.since_minutes,
+            observed: scan.since_minutes,
+            applied: false,
+        },
+        {
+            source: "codex_attribution",
+            cap_type: "session_limit",
+            limit: scan.session_limit,
+            observed: scan.discovered_file_count,
+            applied: scan.session_limit_applied,
+        },
+    ];
+}
+/**
+ * Record every Claude session the attribution scan saw, capped or lost —
+ * sidecars included, because a subagent transcript nobody could read is missing
+ * evidence exactly like a main.
+ */
+export function recordClaudeAttributionCompleteness(ledger, scan, selectedPaths) {
+    recordScanned(ledger, "claude_attribution", scan.scanned_session_count);
+    if (scan.disabled_reason) {
+        recordSkipCount(ledger, "claude_attribution", scan.disabled_reason, 1);
+    }
+    ledger.caps.push(...claudeAttributionCaps(scan));
+    recordClaudeAttributionSkips(ledger, scan);
+    recordTruncationCount(ledger, "claude_attribution", "oversized_jsonl_line", scan.counts.oversized_lines_skipped, { max_bytes: scan.max_line_buffer_bytes });
+    recordAttributionResultSkips(ledger, "claude_attribution", scan.results, selectedPaths);
+    recordClaudeSidecarSkips(ledger, scan);
+}
+/** Every limit the Claude attribution scan ran under, and whether it bit. */
+function claudeAttributionCaps(scan) {
+    return [
+        {
+            source: "claude_attribution",
+            cap_type: "scan_window_minutes",
+            limit: scan.since_minutes,
+            observed: scan.since_minutes,
+            applied: false,
+        },
+        {
+            source: "claude_attribution",
+            cap_type: "session_limit",
+            limit: scan.session_limit,
+            observed: scan.discovered_session_count,
+            applied: scan.session_limit_applied,
+        },
+        {
+            source: "claude_attribution",
+            cap_type: "max_file_bytes",
+            limit: scan.max_file_bytes,
+            applied: scan.counts.mains_oversized > 0 ||
+                scan.results.some((result) => result.reason === "file_too_large"),
+        },
+        {
+            source: "claude_attribution",
+            cap_type: "max_sidecar_files",
+            limit: scan.max_sidecar_files,
+            observed: scan.max_sidecar_files + scan.counts.sidecars_capped,
+            applied: scan.counts.sidecars_capped > 0,
+        },
+        {
+            source: "claude_attribution",
+            cap_type: "max_line_buffer_bytes",
+            limit: scan.max_line_buffer_bytes,
+            applied: scan.counts.oversized_lines_skipped > 0,
+        },
+    ];
+}
+/** Each way the Claude scan lost whole sessions, one named skip count apiece. */
+function recordClaudeAttributionSkips(ledger, scan) {
+    recordSkipCount(ledger, "claude_attribution", "session_limit_overflow", Math.max(0, scan.discovered_session_count - scan.scanned_session_count));
+    recordSkipCount(ledger, "claude_attribution", "secret_like_project_dir", scan.project_dirs_skipped);
+    recordSkipCount(ledger, "claude_attribution", "project_dir_read_failed", scan.project_dir_read_failed_count);
+    recordSkipCount(ledger, "claude_attribution", "session_stat_failed", scan.session_stat_failed_count);
+    recordSkipCount(ledger, "claude_attribution", "sidecar_dir_read_failed", scan.sidecar_dir_read_failed_count);
+    recordSkipCount(ledger, "claude_attribution", "sidecar_stat_failed", scan.sidecar_stat_failed_count);
+    recordSkipCount(ledger, "claude_attribution", "sidecar_limit_overflow", scan.counts.sidecars_capped);
+}
+/** One skip per sidecar the scan declined, labelled with its own reason. */
+function recordClaudeSidecarSkips(ledger, scan) {
+    for (const result of scan.results) {
+        for (const sidecar of result.sidecar_files) {
+            if (!sidecar.skipped_reason)
+                continue;
+            recordSkipCount(ledger, "claude_attribution", `sidecar_${sidecar.skipped_reason}`, 1);
+        }
+    }
+}
+/** One skip per scanned session this pass is neither collecting nor excusing. */
+function recordAttributionResultSkips(ledger, source, results, selectedPaths) {
+    for (const result of results) {
+        if (isAttributionAccountedFor(result, selectedPaths))
+            continue;
+        const reason = result.state === "skipped"
+            ? result.reason
+            : `attribution_${result.state}:${result.reason}`;
+        recordSkipCount(ledger, source, reason, 1);
+    }
+}
+/**
+ * Not every unattributed result is a gap. A selected session is being collected
+ * by this pass, and a live-sync-safe synthetic target is owned by another
+ * workspace's pack — neither is missing evidence.
+ */
+function isAttributionAccountedFor(result, selectedPaths) {
+    if (result.state === "attributed")
+        return true;
+    if (selectedPaths.has(result.file_path))
+        return true;
+    return (result.worktree !== null &&
+        isLiveRawEvidenceSyncAttribution(result.state, result.reason, true));
+}