@bli-cockpit/cli 0.1.30 → 0.1.32

package/dist/adapters/attribution-core.js

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import path from "node:path";
+import { normalizeGitOrigin, repoFingerprintFromOrigin, repoLabelFromOrigin, stableWorktreeFingerprint, } from "../repo-identity.js";
 /**
  * Shared deterministic attribution core for agent session transcripts (Codex
  * and Claude Code). Both adapters extract source-shaped signals, normalize them
@@ -73,6 +74,12 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
     const secondBestScore = scored[1]?.score ?? 0;
     if (!best || best.score === 0) {
         if (repoPathAbsentFromDisk([...signals.cwds, ...signals.workspaceRoots], options.collectionRoots ?? [])) {
+            const transcriptFallback = fallbackToTranscriptOriginForDeletedRepo({
+                originLabel,
+                signals,
+            });
+            if (transcriptFallback)
+                return transcriptFallback;
             return skipped("repo_not_on_disk");
         }
         const reason = signals.cwds.length > 0 || signals.workspaceRoots.length > 0
@@ -173,6 +180,49 @@ function fallbackToKnownRepoPrimaryWorkContext(options) {
         worktree: primary,
     };
 }
+/**
+ * Reconstructs a repo/worktree identity from transcript origin metadata only
+ * after the caller has already proven a recorded cwd/workspace root sits under
+ * an operator-approved collection root. The origin is never allowed to widen
+ * consent by itself: it only rescues sessions for repos that were once inside
+ * the approved scan boundary but have since been deleted from disk, where the
+ * transcript is still durable enough to carry the normalized remote identity.
+ */
+function fallbackToTranscriptOriginForDeletedRepo(options) {
+    const origins = [
+        ...new Set(options.signals.originUrls
+            .map((origin) => normalizeGitOrigin(origin))
+            .filter(Boolean)),
+    ];
+    if (origins.length === 0)
+        return null;
+    if (origins.length > 1)
+        return skipped("multiple_transcript_origins");
+    const recordedPath = options.signals.workspaceRoots[0] ?? options.signals.cwds[0] ?? null;
+    if (!recordedPath)
+        return null;
+    const resolvedPath = path.resolve(recordedPath);
+    const origin = origins[0] ?? "";
+    return {
+        state: "attributed_fallback",
+        reason: "transcript_origin_fallback",
+        signals: ["transcript_origin_fallback", options.originLabel],
+        attribution_score: clampScore(SCORE_ORIGIN_MATCH),
+        path_score: 0,
+        worktree: {
+            requested_path: resolvedPath,
+            repo_root: resolvedPath,
+            repo_label: repoLabelFromOrigin(origin),
+            repo_fingerprint: repoFingerprintFromOrigin(origin),
+            repo_origin_url: origin,
+            branch: options.signals.branches[0] ?? "unknown",
+            head_sha: options.signals.headShas[0] ?? null,
+            worktree_label: path.basename(resolvedPath),
+            worktree_fingerprint: stableWorktreeFingerprint(resolvedPath),
+            worktree_is_primary: false,
+        },
+    };
+}
 /**
  * For each path signal, the single worktree whose root most specifically
  * contains it (the longest containing root). Returns the set of worktree

package/dist/adapters/claude-attribution.js

@@ -1,4 +1,4 @@
-import { SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { createReadStream } from "node:fs";
@@ -24,7 +24,7 @@ export const CLAUDE_ATTRIBUTION_DEFAULT_SINCE_MINUTES = 24 * 60;
 export const CLAUDE_ATTRIBUTION_DEFAULT_SESSION_LIMIT = 50;
 // Upload cap, NOT an attribution cap (D7): an oversized main file is still
 // scored and attributed via a streamed read; only the file's bytes stay local.
-export const CLAUDE_SESSION_MAX_FILE_BYTES = 10 * 1024 * 1024;
+export const CLAUDE_SESSION_MAX_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export const CLAUDE_SESSION_MAX_SIDECAR_FILES = 40;
 // JSONL lines holding a large tool result can be multi-MiB; a streamed read of
 // an oversized main caps the per-line buffer so one giant line cannot blow

package/dist/adapters/raw-evidence.js

@@ -1,4 +1,4 @@
-import { EvidenceCompletenessPayloadSchema, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { EvidenceCompletenessPayloadSchema, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
 import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
@@ -13,14 +13,12 @@ const MAX_GIT_DIFF_BYTES = 2 * 1024 * 1024;
 const GIT_DIFF_TIMEOUT_MS = 3_000;
 export const RAW_EVIDENCE_BUCKET = "ambient-raw-evidence";
 export const RAW_EVIDENCE_RETENTION_MODE = "remote_durable";
-// Per-sync upload budgets enforced at COLLECTION time (D7b). With sidecars a
-// worst-case sync could buffer hundreds of MiB and fire thousands of chunk
-// POSTs; the byte budget bounds buffered bytes and the object budget bounds
-// request count. Overflow becomes a deferred-skip entry, picked up next sync
-// (content addressing makes this convergent).
-export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 512 * 1024 * 1024;
+// Per-sync upload budgets enforced at COLLECTION time (D7b). A single marathon
+// transcript can now approach 512 MiB, so 2 GiB leaves room for several files
+// without starving the sync; overflow still defers and converges next run.
+export const RAW_EVIDENCE_DEFAULT_BYTE_BUDGET = 2 * 1024 * 1024 * 1024;
 export const RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET = 300;
-const CLAUDE_MAX_COLLECT_FILE_BYTES = 10 * 1024 * 1024;
+const CLAUDE_MAX_COLLECT_FILE_BYTES = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES;
 export async function collectRawEvidencePack(context, options) {
     const startedAt = context.now.toISOString();
     const packId = rawEvidencePackId(context);
@@ -587,6 +585,29 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return false;
     }
+    if (options.maxFileBytes) {
+        let stat;
+        try {
+            stat = await fs.stat(options.filePath);
+        }
+        catch {
+            collection.skipped.push({
+                kind: options.kind,
+                label: fileName,
+                reason: "file_read_failed",
+            });
+            return false;
+        }
+        if (stat.size > options.maxFileBytes) {
+            markCapApplied(collection, options.kind, "max_file_bytes");
+            collection.skipped.push({
+                kind: options.kind,
+                label: fileName,
+                reason: "file_too_large",
+            });
+            return false;
+        }
+    }
     let raw;
     try {
         raw = await fs.readFile(options.filePath);

package/dist/commands/backfill.js

@@ -557,7 +557,7 @@ function reasonClassification(reason) {
     if (reason === "file_too_large") {
         return {
             classification: "retryable",
-            note: "until chunked-file support",
+            note: "until the evidence file cap is raised",
         };
     }
     if (reason === "repo_not_on_disk") {

package/dist/evidence-upload-client.js

@@ -12,6 +12,22 @@ export async function uploadRawEvidenceFilesChunked(options) {
     const loaded = [];
     const loadedByObjectKey = new Map();
     for (const file of options.files) {
+        let stat;
+        try {
+            stat = await fs.stat(file.local_path);
+        }
+        catch {
+            outcomes.push(failedOutcome(file, "file_read_failed"));
+            continue;
+        }
+        if (stat.size === 0) {
+            outcomes.push(failedOutcome(file, "empty_file"));
+            continue;
+        }
+        if (stat.size > RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
+            outcomes.push(failedOutcome(file, "file_too_large"));
+            continue;
+        }
         let bytes;
         try {
             bytes = await fs.readFile(file.local_path);

package/dist/repo-identity.js

@@ -32,10 +32,9 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
     const repoLabel = repoOriginUrl
         ? repoLabelFromOrigin(repoOriginUrl)
         : path.basename(resolvedRoot);
-    const repoMaterial = repoOriginUrl
-        ? `origin:${repoOriginUrl}`
-        : `local:${sha256(commonGitDir ?? resolvedRoot)}`;
-    const repoFingerprint = `repo-${sha256(repoMaterial).slice(0, 24)}`;
+    const repoFingerprint = repoOriginUrl
+        ? repoFingerprintFromOrigin(repoOriginUrl)
+        : `repo-${sha256(`local:${sha256(commonGitDir ?? resolvedRoot)}`).slice(0, 24)}`;
     const gitFilePath = path.join(resolvedRoot, ".git");
     const worktreeIsPrimary = await fs.stat(gitFilePath).then((stat) => stat.isDirectory(), () => false);
     return {
@@ -162,6 +161,10 @@ export async function stableWorktreeRoot(repoRoot) {
 export function stableWorktreeFingerprint(repoRoot) {
     return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot)}`).slice(0, 24)}`;
 }
+export function repoFingerprintFromOrigin(origin) {
+    const normalizedOrigin = normalizeGitOrigin(origin);
+    return `repo-${sha256(`origin:${normalizedOrigin}`).slice(0, 24)}`;
+}
 async function resolveBranchFromHead(repoRoot) {
     try {
         const gitPath = path.join(repoRoot, ".git");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.10"
+    "@bli-cockpit/telemetry-core": "0.1.11"
   }
 }