@bli-cockpit/cli 0.2.16 → 0.2.18

package/dist/adapters/attribution-core.js

@@ -94,9 +94,20 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
                 collectionRoots,
                 pathExists: options.pathExists,
             });
-            if (transcriptFallback)
-                return transcriptFallback;
-            return skipped(terminalReasonForRecordedPaths(approvedRecordedPaths, options.pathExists));
+            if (transcriptFallback) {
+                return attachApprovedRootWorkspace({
+                    outcome: transcriptFallback,
+                    signals,
+                    collectionRoots,
+                    approvedRecordedPaths,
+                });
+            }
+            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"
@@ -129,20 +140,67 @@ export function scoreSignalsAgainstWorktrees(signals, worktrees, options = {}) {
             signals,
             worktrees: scopedWorktrees,
         });
-        if (fallback)
-            return fallback;
+        if (fallback) {
+            return attachApprovedRootWorkspace({
+                outcome: fallback,
+                signals,
+                collectionRoots,
+                approvedRecordedPaths,
+            });
+        }
     }
+    return attachApprovedRootWorkspace({
+        outcome: {
+            state: "ambiguous",
+            reason: best.score - secondBestScore < ATTRIBUTION_MIN_MARGIN
+                ? "multiple_worktrees_close_scores"
+                : "signal_score_below_threshold",
+            signals: best.matched,
+            attribution_score: score,
+            path_score: pathScore,
+            worktree: null,
+        },
+        signals,
+        collectionRoots,
+        approvedRecordedPaths,
+    });
+}
+/**
+ * Gives an inside-boundary terminal attribution a durable upload context
+ * without pretending the session belongs to any discovered repository. The
+ * original state, reason, signals, and scores are deliberately untouched: the
+ * synthetic folder is transport identity, not stronger attribution.
+ */
+function attachApprovedRootWorkspace(options) {
+    if (options.outcome.worktree || options.approvedRecordedPaths.length === 0) {
+        return options.outcome;
+    }
+    const approvedRoot = deepestApprovedRootForRecordedPaths(options.approvedRecordedPaths, options.collectionRoots);
+    if (!approvedRoot)
+        return options.outcome;
+    const repoLabel = basenameForAttributionPath(approvedRoot);
     return {
-        state: "ambiguous",
-        reason: best.score - secondBestScore < ATTRIBUTION_MIN_MARGIN
-            ? "multiple_worktrees_close_scores"
-            : "signal_score_below_threshold",
-        signals: best.matched,
-        attribution_score: score,
-        path_score: pathScore,
-        worktree: null,
+        ...options.outcome,
+        worktree: {
+            requested_path: approvedRoot,
+            repo_root: approvedRoot,
+            repo_label: repoLabel,
+            repo_fingerprint: repoFingerprintFromLocalRoot(approvedRoot),
+            repo_origin_url: null,
+            branch: options.signals.branches[0] ?? "unknown",
+            head_sha: options.signals.headShas[0] ?? null,
+            worktree_label: repoLabel,
+            worktree_fingerprint: stableWorktreeFingerprint(approvedRoot),
+            worktree_is_primary: true,
+        },
     };
 }
+function deepestApprovedRootForRecordedPaths(recordedPaths, collectionRoots) {
+    const candidates = collectionRoots.filter((root) => recordedPaths.some((recordedPath) => isPathWithin(recordedPath, root)));
+    candidates.sort((a, b) => pathDepth(b) - pathDepth(a) ||
+        normalizedAttributionPathKey(a).localeCompare(normalizedAttributionPathKey(b)));
+    return candidates[0] ? resolveAttributionPath(candidates[0]) : null;
+}
 function unattributed(reason) {
     return {
         state: "unattributed",

package/dist/adapters/claude-attribution.js

@@ -1,4 +1,4 @@
-import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, SECRET_FILE_SEGMENT_PATTERN, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { createReadStream, existsSync } from "node:fs";
@@ -84,7 +84,7 @@ export async function scanAndAttributeClaudeSessions(options) {
 }
 async function discoverClaudeSessions(projectsDir, cutoffMs) {
     const sessions = [];
-    let projectDirsSkipped = 0;
+    const projectDirsSkipped = 0;
     let projectDirReadFailedCount = 0;
     let sessionStatFailedCount = 0;
     let sidecarDirReadFailedCount = 0;
@@ -106,14 +106,6 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
     for (const projectEntry of projectEntries) {
         if (!projectEntry.isDirectory())
             continue;
-        // A project slug encodes the full cwd, so a repo named e.g.
-        // `credentials-service` poisons its slug. Never read inside such a dir, but
-        // count the skip so a whole repo silently missing is visible (D12). The
-        // slug itself is a local path encoding and never printed.
-        if (isSecretLikePath(projectEntry.name)) {
-            projectDirsSkipped += 1;
-            continue;
-        }
         const projectDir = path.join(projectsDir, projectEntry.name);
         let sessionEntries;
         try {
@@ -237,18 +229,14 @@ async function attributeOneSession(session, worktrees, collectionRoots) {
         sidecars_capped: session.sidecarsCapped,
         sidecar_files: [],
     };
-    if (isSecretLikePath(fileName)) {
-        return skippedResult(base, "secret_like_file_name");
-    }
     if (session.mainByteSize === 0) {
         return skippedResult(base, "empty_file");
     }
     let signals;
-    let secretLike;
     const oversized = session.mainByteSize > CLAUDE_SESSION_MAX_FILE_BYTES;
     if (oversized) {
-        // D7: stream the oversized main so signals + secret guard still run, but the
-        // bytes themselves are never uploaded (collection skips it as file_too_large).
+        // D7: stream the oversized main so metadata signals remain available. The
+        // bytes themselves are not uploaded until the collection ceiling changes.
         let streamed;
         try {
             streamed = await streamMainSignals(session.mainFile);
@@ -259,7 +247,6 @@ async function attributeOneSession(session, worktrees, collectionRoots) {
             return skippedResult(base, "file_read_failed");
         }
         signals = streamed.signals;
-        secretLike = streamed.secretLike;
         base.content_hash_sha256 = streamed.contentHash;
         base.byte_size = streamed.byteSize;
         base.main_file_oversized = true;
@@ -280,10 +267,6 @@ async function attributeOneSession(session, worktrees, collectionRoots) {
             return skippedResult(base, "empty_file");
         }
         signals = extractClaudeSessionSignals(content);
-        secretLike = containsSecretLikeContent(content);
-    }
-    if (secretLike) {
-        return skippedResult(base, "secret_like_content_guard");
     }
     const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
     if (metaSessionId) {
@@ -317,7 +300,7 @@ async function attributeOneSession(session, worktrees, collectionRoots) {
         extraSignals.push("main_file_oversized");
     if (isSchemaDriftSuspected(signals))
         extraSignals.push("schema_drift_suspected");
-    const sidecarFiles = isRawEvidenceUploadableAttributionState(outcome.state) && outcome.worktree
+    const sidecarFiles = isRawEvidenceUploadableAttributionState(outcome.state, outcome.worktree !== null) && outcome.worktree
         ? await collectSidecarDiagnostics(session.sidecars, outcome.worktree)
         : session.sidecars.map((sidecar) => ({
             local_path: sidecar.local_path,
@@ -355,10 +338,6 @@ async function collectSidecarDiagnostics(sidecars, worktree) {
             content_hash_sha256: null,
             skipped_reason: null,
         };
-        if (isSecretLikePath(sidecar.file_name)) {
-            out.push({ ...entry, skipped_reason: "secret_like_file_name" });
-            continue;
-        }
         if (sidecar.byteSize > CLAUDE_SESSION_MAX_FILE_BYTES) {
             out.push({ ...entry, skipped_reason: "file_too_large" });
             continue;
@@ -372,10 +351,6 @@ async function collectSidecarDiagnostics(sidecars, worktree) {
             continue;
         }
         const content = raw.toString("utf8");
-        if (containsSecretLikeContent(content)) {
-            out.push({ ...entry, skipped_reason: "secret_like_content_guard" });
-            continue;
-        }
         const sidecarCwds = extractClaudeSessionSignals(content).cwds;
         if (sidecarCwds.length > 0 &&
             !sidecarCwds.some((cwd) => isPathWithin(cwd, worktree.repo_root))) {
@@ -483,25 +458,21 @@ function isSchemaDriftSuspected(signals) {
 async function streamMainSignals(filePath) {
     const accumulator = createSignalAccumulator();
     const hash = crypto.createHash("sha256");
-    let secretLike = false;
     let oversizedLinesSkipped = 0;
     let byteSize = 0;
     let pending = "";
     let pendingTruncated = false;
     const flushCompletedLine = (lineText) => {
         if (pendingTruncated) {
-            // The line exceeded the buffer; guard the head we retained, count it, drop.
+            // The line exceeded the metadata buffer; count it and continue. The raw
+            // evidence collector performs full-file sanitization before upload.
             oversizedLinesSkipped += 1;
-            if (containsSecretLikeContent(pending))
-                secretLike = true;
             pending = "";
             pendingTruncated = false;
             return;
         }
         const full = pending + lineText;
         pending = "";
-        if (containsSecretLikeContent(full))
-            secretLike = true;
         accumulator.processLine(full);
     };
     // StringDecoder buffers an incomplete multibyte char across chunk boundaries
@@ -547,7 +518,6 @@ async function streamMainSignals(filePath) {
     });
     return {
         signals: accumulator.finalize(),
-        secretLike,
         oversizedLinesSkipped,
         contentHash: hash.digest("hex"),
         byteSize,
@@ -578,9 +548,6 @@ function skippedResult(base, reason) {
 function stringOrNull(value) {
     return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function isSecretLikePath(value) {
-    return SECRET_FILE_SEGMENT_PATTERN.test(value);
-}
 function sha256(value) {
     return crypto.createHash("sha256").update(value).digest("hex");
 }

package/dist/adapters/codex-attribution.js

@@ -1,4 +1,3 @@
-import { SECRET_FILE_SEGMENT_PATTERN, } from "@bli-cockpit/telemetry-core";
 import { createReadStream, existsSync } from "node:fs";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
@@ -72,17 +71,13 @@ async function discoverCodexJsonlFiles(dir, cutoffMs) {
     const out = [];
     let directoryReadFailedCount = 0;
     let statFailedCount = 0;
-    let secretPathSkippedCount = 0;
+    const secretPathSkippedCount = 0;
     const stack = Array.isArray(dir) ? [...dir] : [dir];
     const seenFiles = new Set();
     while (stack.length > 0) {
         const current = stack.pop();
         if (!current)
             continue;
-        if (isSecretLikePath(current)) {
-            secretPathSkippedCount += 1;
-            continue;
-        }
         let entries;
         try {
             entries = await fs.readdir(current, { withFileTypes: true });
@@ -95,18 +90,9 @@ async function discoverCodexJsonlFiles(dir, cutoffMs) {
         for (const entry of entries) {
             const full = path.join(current, entry.name);
             if (entry.isDirectory()) {
-                // Never descend into secret-like directories.
-                if (isSecretLikePath(full)) {
-                    secretPathSkippedCount += 1;
-                }
-                else {
-                    stack.push(full);
-                }
+                stack.push(full);
                 continue;
             }
-            // Secret-like file NAMES stay in the list so attribution can record a
-            // "skipped" observation with a reason label (the content is never read)
-            // instead of silently dropping the session.
             if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
                 continue;
             let stat;
@@ -168,9 +154,6 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
         byte_size: file.byteSize,
         content_hash_sha256: null,
     };
-    if (isSecretLikePath(fileName)) {
-        return skippedResult(base, "secret_like_file_name");
-    }
     let read;
     try {
         read = await readCodexMetadataSignals(file.file);
@@ -352,7 +335,4 @@ function skippedResult(base, reason) {
 function addString(target, value) {
     if (typeof value === "string" && value.trim())
         target.add(value.trim());
-}
-function isSecretLikePath(value) {
-    return SECRET_FILE_SEGMENT_PATTERN.test(value);
 }

package/dist/adapters/raw-evidence.js

@@ -383,13 +383,12 @@ function recordClaudeAttributionCompleteness(collection, scan, selectedPaths) {
 }
 function recordAttributionResultSkips(collection, source, results, selectedPaths) {
     for (const result of results) {
-        // A selected fallback is being collected by this pass. A live-sync-safe
-        // fallback is also not a skip when another worktree pack owns its upload.
+        // A selected session is being collected by this pass. A live-sync-safe
+        // synthetic target is also not a skip when another workspace pack owns it.
         if (result.state === "attributed" ||
-            (result.state === "attributed_fallback" &&
-                (selectedPaths.has(result.file_path) ||
-                    (result.worktree !== null &&
-                        isLiveRawEvidenceSyncAttribution(result.state, result.reason))))) {
+            selectedPaths.has(result.file_path) ||
+            (result.worktree !== null &&
+                isLiveRawEvidenceSyncAttribution(result.state, result.reason, true))) {
             continue;
         }
         const reason = result.state === "skipped"
@@ -497,6 +496,9 @@ async function collectClaudeJsonlFiles(collection, sessions) {
         }
         for (const sidecar of session.sidecar_files) {
             const stem = path.basename(sidecar.local_path).replace(/\.jsonl$/i, "");
+            const safeSidecarId = isSecretLikePath(stem)
+                ? "redacted-file-name"
+                : safeKeySegment(stem);
             const sidecarAccepted = await collectOneEvidenceFile(collection, {
                 filePath: sidecar.local_path,
                 kind: "claude_jsonl_sidecar",
@@ -504,16 +506,16 @@ async function collectClaudeJsonlFiles(collection, sessions) {
                 mediaType: "application/jsonl",
                 maxFileBytes: CLAUDE_MAX_COLLECT_FILE_BYTES,
                 redactedSummary: "Raw Claude Code subagent transcript with prompts, responses, tool arguments, and tool outputs preserved locally.",
-                contentAddress: (hash16) => `claude/${safeKeySegment(sessionId)}/subagents/${safeKeySegment(stem)}-${hash16}.jsonl`,
+                contentAddress: (hash16) => `claude/${safeKeySegment(sessionId)}/subagents/${safeSidecarId}-${hash16}.jsonl`,
             });
             if (sidecarAccepted) {
                 await collectAgentImagesFromTranscript(collection, {
                     filePath: sidecar.local_path,
                     source: "claude_code",
                     sessionId,
-                    sidecarId: stem,
+                    sidecarId: safeSidecarId,
                     kind: "claude_image_attachment",
-                    contentAddress: (hash16, extension) => `claude/${safeKeySegment(sessionId)}/subagents/${safeKeySegment(stem)}/images/${hash16}.${extension}`,
+                    contentAddress: (hash16, extension) => `claude/${safeKeySegment(sessionId)}/subagents/${safeSidecarId}/images/${hash16}.${extension}`,
                 });
             }
         }
@@ -598,14 +600,11 @@ async function collectOneAgentImageFile(collection, options) {
  */
 async function collectOneEvidenceFile(collection, options) {
     const fileName = path.basename(options.filePath);
-    if (isSecretLikePath(fileName)) {
-        collection.skipped.push({
-            kind: options.kind,
-            label: fileName,
-            reason: "secret_like_file_name",
-        });
-        return false;
-    }
+    const secretLikeFileName = isSecretLikePath(fileName);
+    const evidenceLabel = secretLikeFileName
+        ? "[REDACTED_FILE_NAME]"
+        : fileName;
+    const packedFileName = secretLikeFileName ? "redacted-file.jsonl" : fileName;
     if (options.maxFileBytes) {
         let stat;
         try {
@@ -614,7 +613,7 @@ async function collectOneEvidenceFile(collection, options) {
         catch {
             collection.skipped.push({
                 kind: options.kind,
-                label: fileName,
+                label: evidenceLabel,
                 reason: "file_read_failed",
             });
             return false;
@@ -623,7 +622,7 @@ async function collectOneEvidenceFile(collection, options) {
             markCapApplied(collection, options.kind, "max_file_bytes");
             collection.skipped.push({
                 kind: options.kind,
-                label: fileName,
+                label: evidenceLabel,
                 reason: "file_too_large",
             });
             return false;
@@ -636,7 +635,7 @@ async function collectOneEvidenceFile(collection, options) {
     catch {
         collection.skipped.push({
             kind: options.kind,
-            label: fileName,
+            label: evidenceLabel,
             reason: "file_read_failed",
         });
         return false;
@@ -645,7 +644,7 @@ async function collectOneEvidenceFile(collection, options) {
         markCapApplied(collection, options.kind, "max_file_bytes");
         collection.skipped.push({
             kind: options.kind,
-            label: fileName,
+            label: evidenceLabel,
             reason: "file_too_large",
         });
         return false;
@@ -654,21 +653,21 @@ async function collectOneEvidenceFile(collection, options) {
         text: raw.toString("utf8"),
         originalBytes: raw,
         redactedFields: [`${options.kind}.body`],
+        secretLikeFileName,
     });
-    if (sanitized.status === "blocked") {
-        collection.skipped.push({
-            kind: options.kind,
-            label: fileName,
-            reason: sanitized.reason,
-        });
-        return false;
-    }
     if (sanitized.status === "redacted") {
         collection.redacted.push({
             kind: options.kind,
-            label: fileName,
+            label: evidenceLabel,
             redaction: sanitized.redaction,
+            completenessLabel: sanitized.completenessLabel,
         });
+        console.error("[raw-evidence] text evidence sanitized", JSON.stringify({
+            kind: options.kind,
+            mode: sanitized.completenessLabel,
+            original_bytes: raw.byteLength,
+            uploaded_bytes: sanitized.bytes.byteLength,
+        }));
     }
     const evidenceBytes = sanitized.bytes;
     const redaction = sanitized.redaction;
@@ -676,7 +675,7 @@ async function collectOneEvidenceFile(collection, options) {
     if (collection.skipContentHashes.has(contentHash)) {
         collection.reused.push({
             kind: options.kind,
-            label: fileName,
+            label: evidenceLabel,
             content_hash_sha256: contentHash,
             codex_session_id: options.sessionId,
         });
@@ -687,13 +686,13 @@ async function collectOneEvidenceFile(collection, options) {
         markBudgetCapApplied(collection, deferReason);
         collection.skipped.push({
             kind: options.kind,
-            label: fileName,
+            label: evidenceLabel,
             reason: deferReason,
         });
         return false;
     }
     collection.index.value += 1;
-    const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${fileName}`);
+    const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${packedFileName}`);
     const destination = path.join(collection.filesDir, path.basename(relativePath));
     await fs.writeFile(destination, evidenceBytes, { mode: 0o600 });
     await chmodPrivate(destination, 0o600);
@@ -728,30 +727,138 @@ function admitToBudget(budget, byteLength) {
     budget.remainingBytes -= byteLength;
     return null;
 }
-function sanitizeTextEvidenceForUpload(options) {
+export function sanitizeTextEvidenceForUpload(options) {
     const originalBytes = options.originalBytes ?? Buffer.from(options.text, "utf8");
-    const redactionResult = redactSecretLikeContent(options.text, {
-        appliedBy: "local_collector",
-        redactedFields: options.redactedFields,
-    });
-    if (redactionResult.redacted) {
-        if (containsSecretLikeContent(redactionResult.text)) {
-            return { status: "blocked", reason: "secret_redaction_failed" };
+    const secretLikeContent = containsSecretLikeContent(options.text);
+    try {
+        const redactionResult = (options.redact ?? redactSecretLikeContent)(options.text, {
+            appliedBy: "local_collector",
+            redactedFields: options.redactedFields,
+        });
+        if (options.secretLikeFileName) {
+            const sanitizedText = redactionResult.redacted
+                ? redactionResult.text
+                : options.text;
+            const safeText = containsSecretLikeContent(sanitizedText)
+                ? "[REDACTED_LINE:secret_redaction_failed]\n"
+                : sanitizedText;
+            const sanitizedBytes = Buffer.from(safeText, "utf8");
+            return {
+                status: "redacted",
+                bytes: sanitizedBytes,
+                redaction: withRedactionContentMetadata(redactionResult.metadata ??
+                    fallbackRedactionMetadata({
+                        ruleId: "secret_like_file_name",
+                        originalText: options.text,
+                        redactedFields: options.redactedFields,
+                        fullContentRedacted: false,
+                    }), { originalBytes, sanitizedBytes }),
+                completenessLabel: "secret_like_name_masked",
+            };
         }
-        const sanitizedBytes = Buffer.from(redactionResult.text, "utf8");
+        if (secretLikeContent) {
+            const redaction = redactionResult.metadata ??
+                fallbackRedactionMetadata({
+                    ruleId: "secret_like_content_guard",
+                    originalText: options.text,
+                    redactedFields: options.redactedFields,
+                });
+            let maskedText = maskSecretBearingLines(options.text, redaction);
+            if (containsSecretLikeContent(maskedText)) {
+                maskedText = "[REDACTED_LINE:secret_redaction_failed]\n";
+            }
+            const sanitizedBytes = Buffer.from(maskedText, "utf8");
+            return {
+                status: "redacted",
+                bytes: sanitizedBytes,
+                redaction: withRedactionContentMetadata(redaction, {
+                    originalBytes,
+                    sanitizedBytes,
+                }),
+                completenessLabel: "secret_content_masked",
+            };
+        }
+        if (redactionResult.redacted) {
+            const sanitizedBytes = Buffer.from(redactionResult.text, "utf8");
+            return {
+                status: "redacted",
+                bytes: sanitizedBytes,
+                redaction: withRedactionContentMetadata(redactionResult.metadata ??
+                    fallbackRedactionMetadata({
+                        ruleId: "secret_redaction_failed",
+                        originalText: options.text,
+                        redactedFields: options.redactedFields,
+                    }), { originalBytes, sanitizedBytes }),
+                completenessLabel: "secret_content_masked",
+            };
+        }
+        return { status: "clean", bytes: originalBytes };
+    }
+    catch {
+        const sanitizedBytes = Buffer.from("[REDACTED_LINE:redaction_crashed_stubbed]\n", "utf8");
         return {
             status: "redacted",
             bytes: sanitizedBytes,
-            redaction: withRedactionContentMetadata(redactionResult.metadata, {
-                originalBytes,
-                sanitizedBytes,
-            }),
+            redaction: withRedactionContentMetadata(fallbackRedactionMetadata({
+                ruleId: "redaction_crashed_stubbed",
+                originalText: options.text,
+                redactedFields: options.redactedFields,
+            }), { originalBytes, sanitizedBytes }),
+            completenessLabel: "redaction_crashed_stubbed",
         };
     }
-    if (containsSecretLikeContent(options.text)) {
-        return { status: "blocked", reason: "secret_like_content_guard" };
+}
+function maskSecretBearingLines(text, redaction) {
+    if (redaction.redacted_ranges.length === 0) {
+        return "[REDACTED_LINE:secret_like_content_guard]\n";
     }
-    return { status: "clean", bytes: originalBytes };
+    const segments = text.match(/[^\n]*(?:\n|$)/gu)?.filter(Boolean) ?? [];
+    let offset = 0;
+    return segments
+        .map((segment) => {
+        const start = offset;
+        const end = offset + segment.length;
+        offset = end;
+        const matched = redaction.redacted_ranges.find((range) => range.start < end && start < range.end);
+        if (!matched)
+            return segment;
+        const lineEnding = segment.endsWith("\r\n")
+            ? "\r\n"
+            : segment.endsWith("\n")
+                ? "\n"
+                : "";
+        return `[REDACTED_LINE:${matched.rule_id}]${lineEnding}`;
+    })
+        .join("");
+}
+function fallbackRedactionMetadata(options) {
+    const fullContentRedacted = options.fullContentRedacted !== false;
+    return {
+        schema_version: "raw-evidence-redaction.v1",
+        status: "sanitized",
+        mode: "deterministic_text_replacement",
+        applied_by: ["local_collector"],
+        rule_counts: [
+            {
+                rule_id: options.ruleId,
+                match_count: 1,
+                redacted_char_count: fullContentRedacted
+                    ? options.originalText.length
+                    : 0,
+            },
+        ],
+        secret_like_match_count: 1,
+        redacted_fields: options.redactedFields,
+        redacted_ranges: fullContentRedacted && options.originalText.length > 0
+            ? [
+                {
+                    start: 0,
+                    end: options.originalText.length,
+                    rule_id: options.ruleId,
+                },
+            ]
+            : [],
+    };
 }
 async function collectGitDiffFiles(collection, repoRoot) {
     const diffTargets = [
@@ -790,20 +897,18 @@ async function collectGitDiffFiles(collection, repoRoot) {
             text: diff.stdout,
             redactedFields: [`git_diff.${target.label}`],
         });
-        if (sanitized.status === "blocked") {
-            collection.skipped.push({
-                kind: "git_diff",
-                label: target.label,
-                reason: sanitized.reason,
-            });
-            continue;
-        }
         if (sanitized.status === "redacted") {
             collection.redacted.push({
                 kind: "git_diff",
                 label: target.label,
                 redaction: sanitized.redaction,
+                completenessLabel: sanitized.completenessLabel,
             });
+            console.error("[raw-evidence] git diff sanitized", JSON.stringify({
+                mode: sanitized.completenessLabel,
+                original_bytes: Buffer.byteLength(diff.stdout, "utf8"),
+                uploaded_bytes: sanitized.bytes.byteLength,
+            }));
         }
         const raw = sanitized.bytes;
         const redaction = sanitized.redaction;
@@ -1059,7 +1164,7 @@ function makeEvidenceCompleteness(collection, options) {
     const redactionCounts = new Map();
     for (const redacted of collection.redacted) {
         const ruleIds = redacted.redaction.rule_counts.map((rule) => rule.rule_id);
-        const key = `${redacted.kind}:${redacted.redaction.mode}:${ruleIds.sort().join(",")}`;
+        const key = `${redacted.kind}:${redacted.completenessLabel}:${ruleIds.sort().join(",")}`;
         const existing = redactionCounts.get(key);
         if (existing) {
             existing.count += 1;
@@ -1069,7 +1174,7 @@ function makeEvidenceCompleteness(collection, options) {
             redactionCounts.set(key, {
                 source: redacted.kind,
                 status: "sanitized",
-                mode: redacted.redaction.mode,
+                mode: redacted.completenessLabel,
                 count: 1,
                 rule_ids: [...new Set(ruleIds)].sort(),
             });

package/dist/commands/backfill.js

@@ -1,4 +1,4 @@
-import { containsSecretLikeContent, NO_UPLOAD_ATTEMPT_RECORDED, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
+import { NO_UPLOAD_ATTEMPT_RECORDED, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -8,6 +8,7 @@ import { defaultCodexSessionDirs, scanAndAttributeCodexSessions } from "../adapt
 import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
 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 { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
 import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, readLocalWorkContextForRepo, startLocalWorkContext } from "../local-state.js";
 import { DEFAULT_DISCOVERY_MAX_DEPTH, DEFAULT_DISCOVERY_MAX_REPOS, collectionRootPathAliases, discoverGitWorktreesInRootsWithStatus, } from "../repo-identity.js";
 import { isRawEvidenceUploadableAttributionState } from "../raw-evidence-attribution-policy.js";
@@ -87,6 +88,7 @@ export async function runBackfill(command, io) {
         : await readBackfillCursor(paths);
     const scopedCursor = prepareBackfillCursorForScope(storedCursor, collectionRoots, sources);
     const cursor = scopedCursor.cursor;
+    const pointerlessTerminalSessions = await loadPointerlessTerminalSessions(paths, sources);
     const scan = await scanBackfillSessions({
         command,
         homeDir: command.homeDir ?? os.homedir(),
@@ -95,6 +97,7 @@ export async function runBackfill(command, io) {
         sources,
         window,
         cursor,
+        pointerlessTerminalSessions,
         now,
     });
     for (const reason of worktreeDiscovery.incomplete_reasons) {
@@ -107,13 +110,6 @@ export async function runBackfill(command, io) {
     scan.issues.sort((a, b) => scanIssuePriority(a.scope) - scanIssuePriority(b.scope) ||
         a.reason.localeCompare(b.reason));
     const guards = await countReadOnlyGuards(scan.candidates);
-    for (const candidate of scan.candidates) {
-        const permanentReason = guards.permanent_skip_reasons.get(candidateCursorKey(candidate));
-        if (!permanentReason)
-            continue;
-        candidate.state = "skipped";
-        candidate.reason = permanentReason;
-    }
     scan.retryable_candidate_keys = new Set([
         ...scan.retryable_candidate_keys,
         ...guards.retryable_candidate_keys,
@@ -392,6 +388,14 @@ export async function runBackfill(command, io) {
                     ? "session_report_ack_incomplete"
                     : report.reason;
         }
+        if (reportAcknowledged && durableCandidateKeys.size > 0) {
+            await recordBackfillDurableSessionPointers({
+                paths,
+                candidates: scan.candidates,
+                syncResults,
+                now,
+            });
+        }
         // Raw evidence durability is necessary but not sufficient: the server must
         // also acknowledge the session attribution rows before their historical
         // cursor positions become irreversible.
@@ -672,8 +676,9 @@ async function scanBackfillSessions(options) {
         ...(codexAttribution?.results.map(normalizeCodexCandidate) ?? []),
         ...(claudeAttribution?.results.map(normalizeClaudeCandidate) ?? []),
     ]
-        .filter((candidate) => isAfterCursor(candidate, options.cursor))
-        .sort(compareBackfillCandidates);
+        .filter((candidate) => isAfterCursor(candidate, options.cursor) ||
+        isPointerlessTerminalRetry(candidate, options.pointerlessTerminalSessions))
+        .sort((a, b) => compareBackfillCandidatesForRetry(a, b, options.pointerlessTerminalSessions));
     const candidates = allCandidates.slice(0, options.command.maxFiles ?? Number.MAX_SAFE_INTEGER);
     const omittedCandidateCount = allCandidates.length - candidates.length;
     const issues = await backfillScanIssues({
@@ -693,6 +698,52 @@ async function scanBackfillSessions(options) {
         omitted_candidate_count: omittedCandidateCount,
     };
 }
+async function loadPointerlessTerminalSessions(paths, sources) {
+    const [codexCursor, claudeCursor] = await Promise.all([
+        sources.includes("codex")
+            ? readRawEvidenceCursor(paths)
+            : Promise.resolve(null),
+        sources.includes("claude_code")
+            ? readRawEvidenceCursor(paths, { filename: CLAUDE_CURSOR_FILENAME })
+            : Promise.resolve(null),
+    ]);
+    const terminalIds = (sessions) => new Set(Object.entries(sessions ?? {})
+        .filter(([, entry]) => isPointerlessTerminalCursorEntry(entry))
+        .map(([sessionId]) => sessionId));
+    const result = {
+        codex: terminalIds(codexCursor?.sessions),
+        claude_code: terminalIds(claudeCursor?.sessions),
+    };
+    const count = result.codex.size + result.claude_code.size;
+    if (count > 0) {
+        console.error("[backfill] pointer-less terminal sessions reopened", JSON.stringify({
+            count,
+            codex_count: result.codex.size,
+            claude_count: result.claude_code.size,
+        }));
+    }
+    return result;
+}
+function isPointerlessTerminalCursorEntry(entry) {
+    return (!entry.uploaded_object_key &&
+        (entry.state === "ambiguous" ||
+            entry.state === "unattributed" ||
+            entry.state === "skipped"));
+}
+function isPointerlessTerminalRetry(candidate, sessions) {
+    return sessions[candidate.source].has(candidate.session_id);
+}
+function compareBackfillCandidatesForRetry(a, b, sessions) {
+    const aRetry = isPointerlessTerminalRetry(a, sessions);
+    const bRetry = isPointerlessTerminalRetry(b, sessions);
+    if (aRetry !== bRetry)
+        return aRetry ? -1 : 1;
+    if (aRetry && bRetry) {
+        return (a.session_file_mtime_ms - b.session_file_mtime_ms ||
+            candidateCursorKey(a).localeCompare(candidateCursorKey(b)));
+    }
+    return compareBackfillCandidates(a, b);
+}
 function normalizeCodexCandidate(result) {
     return {
         source: "codex",
@@ -808,7 +859,7 @@ async function backfillScanIssues(options) {
     }
     add("backfill_max_files_applied", options.omittedCandidateCount, "selection");
     add("candidate_file_read_failed", options.candidates.filter((candidate) => candidate.reason === "file_read_failed").length, "candidate");
-    add("candidate_worktree_unavailable", options.candidates.filter((candidate) => isRawEvidenceUploadableAttributionState(candidate.state) &&
+    add("candidate_worktree_unavailable", options.candidates.filter((candidate) => isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null) &&
         candidate.worktree === null).length, "candidate");
     add("claude_main_file_too_large", options.candidates.filter((candidate) => candidate.source === "claude_code" &&
         candidate.claude?.main_file_oversized).length, "candidate");
@@ -830,7 +881,7 @@ function retryableCandidateKeys(candidates) {
     return new Set(candidates
         .filter((candidate) => candidate.reason === "file_read_failed" ||
         candidate.reason === "repo_not_on_disk" ||
-        (isRawEvidenceUploadableAttributionState(candidate.state) &&
+        (isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null) &&
             !candidate.worktree) ||
         Boolean(candidate.claude?.main_file_oversized) ||
         (candidate.claude?.sidecars_capped ?? 0) > 0 ||
@@ -872,7 +923,6 @@ function isMissingFsError(error) {
 async function countReadOnlyGuards(candidates) {
     const counts = new Map();
     const retryableCandidateKeys = new Set();
-    const permanentSkipReasons = new Map();
     for (const candidate of candidates) {
         if (candidate.reason === "repo_not_on_disk") {
             increment(counts, "repo_not_on_disk");
@@ -888,14 +938,10 @@ async function countReadOnlyGuards(candidates) {
             retryableCandidateKeys.add(candidateCursorKey(candidate));
             continue;
         }
-        if (!isRawEvidenceUploadableAttributionState(candidate.state))
+        if (!isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null))
             continue;
         try {
-            const raw = await fs.readFile(candidate.file_path, "utf8");
-            if (containsSecretLikeContent(raw)) {
-                increment(counts, "secret_like_content_guard");
-                permanentSkipReasons.set(candidateCursorKey(candidate), "secret_like_content_guard");
-            }
+            await fs.readFile(candidate.file_path);
         }
         catch {
             increment(counts, "file_read_failed");
@@ -905,7 +951,6 @@ async function countReadOnlyGuards(candidates) {
     return {
         counts,
         retryable_candidate_keys: retryableCandidateKeys,
-        permanent_skip_reasons: permanentSkipReasons,
     };
 }
 function reasonCountsFor(candidates, guardCounts, scanIssues) {
@@ -918,11 +963,7 @@ function reasonCountsFor(candidates, guardCounts, scanIssues) {
     for (const issue of scanIssues) {
         counts.set(issue.reason, Math.max(counts.get(issue.reason) ?? 0, issue.count));
     }
-    for (const required of [
-        "secret_like_content_guard",
-        "file_too_large",
-        "repo_not_on_disk",
-    ]) {
+    for (const required of ["file_too_large", "repo_not_on_disk"]) {
         counts.set(required, counts.get(required) ?? 0);
     }
     return [...counts.entries()]
@@ -936,8 +977,8 @@ function reasonCountsFor(candidates, guardCounts, scanIssues) {
 function reasonClassification(reason) {
     if (reason === "secret_like_content_guard" || reason === "secret_redaction_failed") {
         return {
-            classification: "permanent",
-            note: "secret-guarded permanent by design",
+            classification: "retryable",
+            note: "historical guard result; collector now masks and retries",
         };
     }
     if (reason === "file_too_large") {
@@ -988,7 +1029,7 @@ function reasonClassification(reason) {
     };
 }
 function uploadableCandidates(candidates) {
-    return candidates.filter((candidate) => isRawEvidenceUploadableAttributionState(candidate.state) &&
+    return candidates.filter((candidate) => isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null) &&
         candidate.worktree);
 }
 function buildBackfillBatches(candidates) {
@@ -1157,7 +1198,7 @@ function buildBackfillSessionReport(options) {
                         ? { upload_reason: upload.reason ?? NO_UPLOAD_ATTEMPT_RECORDED }
                         : {}),
                 }
-                : isRawEvidenceUploadableAttributionState(candidate.state)
+                : isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null)
                     ? {
                         upload_state: "not_uploaded",
                         // BLI-2107: same rule as live sync — an attributed session with
@@ -1237,6 +1278,61 @@ function durableBackfillCandidateKeys(batch, sync) {
     }
     return durable;
 }
+async function recordBackfillDurableSessionPointers(options) {
+    const durableObjectBySession = new Map();
+    for (const sync of options.syncResults) {
+        for (const outcome of sync.raw_evidence_outcomes) {
+            if (!outcome.codex_session_id ||
+                (outcome.kind !== "codex_jsonl" && outcome.kind !== "claude_jsonl") ||
+                (outcome.upload_state !== "uploaded" &&
+                    outcome.upload_state !== "reused_existing") ||
+                !outcome.object_key) {
+                continue;
+            }
+            const source = outcome.kind === "codex_jsonl" ? "codex" : "claude_code";
+            durableObjectBySession.set(`${source}:${outcome.codex_session_id}`, outcome.object_key);
+        }
+    }
+    let recordedCount = 0;
+    for (const source of ["codex", "claude_code"]) {
+        const filename = source === "claude_code" ? CLAUDE_CURSOR_FILENAME : undefined;
+        const cursor = await readRawEvidenceCursor(options.paths, { filename });
+        let changed = false;
+        for (const candidate of options.candidates) {
+            if (candidate.source !== source)
+                continue;
+            const objectKey = durableObjectBySession.get(`${source}:${candidate.session_id}`);
+            const prior = cursor.sessions[candidate.session_id];
+            if (!objectKey || !prior || prior.uploaded_object_key)
+                continue;
+            cursor.sessions[candidate.session_id] = {
+                ...prior,
+                file_hash_sha256: candidate.content_hash_sha256,
+                file_mtime_ms: candidate.session_file_mtime_ms,
+                byte_size: candidate.byte_size,
+                byte_offset: candidate.byte_size,
+                state: candidate.state,
+                reason: candidate.reason,
+                worktree_fingerprint: candidate.worktree?.worktree_fingerprint ?? null,
+                uploaded_object_key: objectKey,
+                uploaded_at: options.now.toISOString(),
+                uploaded_byte_size: candidate.byte_size,
+                last_seen_at: options.now.toISOString(),
+            };
+            changed = true;
+            recordedCount += 1;
+        }
+        if (changed) {
+            await writeRawEvidenceCursor(options.paths, cursor, {
+                filename,
+                sessionsOnly: source === "claude_code",
+            });
+        }
+    }
+    if (recordedCount > 0) {
+        console.error("[backfill] terminal session pointers recorded", JSON.stringify({ count: recordedCount }));
+    }
+}
 function countSessionUploadFailures(sync) {
     return sync.raw_evidence_outcomes.filter((outcome) => Boolean(outcome.codex_session_id) &&
         outcome.upload_state === "upload_failed" &&
@@ -1266,7 +1362,7 @@ function advanceBackfillCursorThroughResolvedPrefix(options) {
             const key = candidateCursorKey(candidate);
             if (options.retryableCandidateKeys.has(key))
                 break;
-            const resolved = isRawEvidenceUploadableAttributionState(candidate.state)
+            const resolved = isRawEvidenceUploadableAttributionState(candidate.state, candidate.worktree !== null)
                 ? options.durableCandidateKeys.has(key)
                 : true;
             if (!resolved)

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.16");
+    writeLine(io?.stdout ?? process.stdout, "0.2.18");
     return 0;
   }
 

package/dist/commands/session-sync.js

@@ -14,7 +14,7 @@ import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET }
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
 import { clearSourceRetryFailure, readLocalUploadSpoolState, recordSourceRetryFailure, } from "../spool/local-spool.js";
-import { isLiveRawEvidenceSyncAttribution, } from "../raw-evidence-attribution-policy.js";
+import { isLiveRawEvidenceSyncAttribution, isRawEvidenceUploadableAttributionState, } from "../raw-evidence-attribution-policy.js";
 /**
  * The label used when a sync fails and nothing on the way there said why.
  *
@@ -30,16 +30,15 @@ const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
  * Live sync remains reason-allowlisted even though historical backfill accepts
  * every deterministic fallback state.
  */
-export function isLiveSyncCollectableAttributionState(state, reason) {
-    return isLiveRawEvidenceSyncAttribution(state, reason);
+export function isLiveSyncCollectableAttributionState(state, reason, hasApprovedWorkspace = false) {
+    return isLiveRawEvidenceSyncAttribution(state, reason, hasApprovedWorkspace);
 }
 function cursorHasUndurableCollectableSession(cursor) {
     return Object.values(cursor.sessions).some((entry) => liveSyncCursorEntryRequiresRetry(entry));
 }
 export function liveSyncCursorEntryRequiresRetry(entry) {
     return (!entry.uploaded_object_key &&
-        (isLiveSyncCollectableAttributionState(entry.state, entry.reason) ||
-            entry.reason === "repo_not_on_disk"));
+        (isLiveSyncCollectableAttributionState(entry.state, entry.reason, Boolean(entry.worktree_fingerprint)) || entry.reason === "repo_not_on_disk"));
 }
 function allLocalHistorySinceMinutes(now) {
     // A cutoff just before the Unix epoch is effectively unbounded for Codex and
@@ -82,7 +81,7 @@ async function reconcileSourceScanRetry(options) {
     }
 }
 export function matchesLiveSyncWorktree(result, target) {
-    return (isLiveRawEvidenceSyncAttribution(result.state, result.reason) &&
+    return (isLiveRawEvidenceSyncAttribution(result.state, result.reason, result.worktree !== null) &&
         result.worktree !== null &&
         liveSyncTargetKey(result.worktree) === liveSyncTargetKey(target));
 }
@@ -101,7 +100,7 @@ export function liveSyncTargetWorktrees(discovered, results) {
         const targetKey = result.worktree
             ? liveSyncTargetKey(result.worktree)
             : null;
-        if (!isLiveSyncCollectableAttributionState(result.state, result.reason) ||
+        if (!isLiveSyncCollectableAttributionState(result.state, result.reason, result.worktree !== null) ||
             !result.worktree ||
             !targetKey ||
             seen.has(targetKey)) {
@@ -117,10 +116,11 @@ export function liveSyncTargetWorktrees(discovered, results) {
  * modes. Codex AND Claude Code sessions are scanned and attributed once across
  * every discovered worktree; each worktree syncs its exact and deterministic
  * fallback-attributed transcripts (Codex + Claude main + sidecars). The
- * ambiguous/unattributed/skipped remainder is reported with reason labels and
- * a `source` discriminator instead of being duplicated into every repo or
- * silently dropped. The session row's upload state maps ONLY from the main-file
- * outcome (D3); sidecar outcomes aggregate into CLI counts.
+ * ambiguous/unattributed/skipped sessions inside an approved root retain those
+ * labels while syncing once through that root's synthetic folder workspace.
+ * Outside-root sessions remain diagnostic-only. The session row's upload state
+ * maps ONLY from the main-file outcome (D3); sidecar outcomes aggregate into
+ * CLI counts.
  */
 export async function runAttributedWorktreeSync(options) {
     const now = new Date();
@@ -625,8 +625,7 @@ export function buildAgentSessionReport(options) {
                         raw_evidence_pointer_id: priorDurablePointer,
                         upload_state: "reused_existing",
                     }
-                    : result.state === "attributed" ||
-                        result.state === "attributed_fallback"
+                    : isRawEvidenceUploadableAttributionState(result.state, result.worktree !== null)
                         ? {
                             upload_state: "not_uploaded",
                             // BLI-2107: `not_uploaded` used to be the branch of last

package/dist/evidence-upload-client.js

@@ -140,6 +140,7 @@ export async function uploadRawEvidenceFilesChunked(options) {
                 continue;
             }
             const outcome = await uploadOneObject(options, entry, disposition, chunkSizeBytes);
+            await reportAbandonedUpload(options, disposition, outcome);
             outcomes.push(outcome);
             for (const duplicate of entry.duplicates) {
                 outcomes.push(duplicateOutcome(outcome, duplicate));
@@ -171,6 +172,72 @@ function duplicateOutcome(primary, duplicate) {
         uploaded_chunk_count: 0,
     };
 }
+/**
+ * Tell the server why we gave up on a row `begin` already opened (BLI-2539).
+ *
+ * `begin` opens a ledger row per object and the chunks then go one object at a
+ * time, so one object failing leaves its siblings untouched — the production
+ * shape is a lone failure among committed rows. This function is the only thing
+ * standing between that failure and a row that sits `pending` with a null
+ * reason until a drain relabels it `staging_incomplete` weeks later, which
+ * names the shape and not the cause. 275 rows reached that state by 2026-08-14.
+ *
+ * The server records the reason on the still-open row (for a reason classified
+ * permanent it fails the row closed), so reporting a give-up never costs the
+ * staged chunks the next sync resumes from.
+ *
+ * Deliberately best-effort: the upload has already failed and the caller's
+ * outcome is the answer that matters. Losing the abort as well leaves exactly
+ * the row we had before this existed, so a delivery failure must not throw —
+ * but it is named on stderr rather than swallowed, because a reason the server
+ * never received is invisible precisely where BLI-2539 needed it visible.
+ */
+async function reportAbandonedUpload(options, disposition, outcome) {
+    if (outcome.upload_state !== "upload_failed")
+        return;
+    if (!outcome.reason)
+        return;
+    // Only a row this call actually opened or resumed. `conflict` never allocated
+    // one for us, and `already_committed` names durable content an abort must not
+    // touch.
+    if (disposition.disposition !== "new" && disposition.disposition !== "resume") {
+        return;
+    }
+    if (!disposition.upload_id)
+        return;
+    const reason = conformReasonLabel(outcome.reason);
+    const response = await requestJson(options, "/api/ambient/evidence/upload/abort", {
+        schema_version: "ambient-raw-evidence-upload-abort.v1",
+        generated_at: options.generatedAt,
+        provenance: options.provenance,
+        upload_id: disposition.upload_id,
+        object_key: outcome.object_key,
+        reason,
+        uploaded_chunk_count: outcome.uploaded_chunk_count,
+    });
+    if (!response.ok) {
+        // status 404 is an old dashboard without the abort route; status 0 means
+        // the request itself never completed. Metadata only — ids, status, labels.
+        console.error("[evidence-abort] delivery failed; the server did not record the reason", JSON.stringify({
+            upload_id: disposition.upload_id,
+            reason,
+            http_status: response.status,
+        }));
+    }
+}
+/**
+ * Force a reason into the label shape the abort route accepts.
+ *
+ * Every reason this client composes already fits, and this exists so that stays
+ * true without anyone having to remember it. A label the server rejects comes
+ * back 400 and the reason is lost — which is the precise failure BLI-2539 is
+ * about, arriving through the code meant to fix it. A mangled label that lands
+ * beats a perfect one that does not.
+ */
+function conformReasonLabel(reason) {
+    const conformed = reason.replace(/[^a-z0-9_:.-]/gi, "_").slice(0, 120);
+    return conformed.length > 0 ? conformed : "upload_failed_unlabelled";
+}
 async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
     const objectKey = entry.file.pointer.object_key ?? "";
     if (disposition.disposition === "already_committed") {

package/dist/raw-evidence-attribution-policy.js

@@ -1,11 +1,13 @@
 /**
  * Historical backfill and attribution diagnostics may retain any deterministic
- * fallback that produced a worktree identity. Ambiguous and unattributed
- * sessions still need a separate quarantine lane so collection does not invent
- * repo provenance.
+ * fallback that produced a worktree identity. Session-first terminal labels
+ * are uploadable only when attribution attached an approved-root synthetic
+ * workspace; the label stays terminal and no repository provenance is invented.
  */
-export function isRawEvidenceUploadableAttributionState(state) {
-    return state === "attributed" || state === "attributed_fallback";
+export function isRawEvidenceUploadableAttributionState(state, hasApprovedWorkspace = false) {
+    return (state === "attributed" ||
+        state === "attributed_fallback" ||
+        (hasApprovedWorkspace && isTerminalAttributionState(state)));
 }
 const LIVE_WORKTREE_FALLBACK_REASONS = new Set([
     "known_repo_primary_fallback",
@@ -18,8 +20,12 @@ const LIVE_WORKTREE_FALLBACK_REASONS = new Set([
  * identities it knows how to validate and materialize as sync targets. Future
  * fallback reasons stay fail-closed until their provenance contract is added.
  */
-export function isLiveRawEvidenceSyncAttribution(state, reason) {
+export function isLiveRawEvidenceSyncAttribution(state, reason, hasApprovedWorkspace = false) {
     return (state === "attributed" ||
         (state === "attributed_fallback" &&
-            LIVE_WORKTREE_FALLBACK_REASONS.has(reason)));
+            LIVE_WORKTREE_FALLBACK_REASONS.has(reason)) ||
+        (hasApprovedWorkspace && isTerminalAttributionState(state)));
+}
+function isTerminalAttributionState(state) {
+    return state === "ambiguous" || state === "unattributed" || state === "skipped";
 }

package/package.json

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