@bli-cockpit/cli 0.1.22 → 0.1.23

package/README.md

@@ -95,7 +95,9 @@ What happens:
    Supabase invite flow automatically.
 5. The CLI starts general ambient capture, uploads private raw evidence objects
    when present (chunked and resumable, with identical content acknowledged
-   instead of re-uploaded), then uploads one safe metadata/ref envelope.
+   instead of re-uploaded), then uploads one safe metadata/ref envelope. Text
+   evidence with secret-shaped values is sanitized before storage and marked as
+   partial evidence with redaction metadata; env files are still never read.
 6. The CLI prints `PASS: Cockpit collector is ready for harvest.`
 
 `--device-name` is optional and only a readable label in Cockpit. Pass it only
@@ -173,7 +175,9 @@ Remote dashboard:
 - raw evidence refs accepted by `/api/ambient/ingest`;
 - durable private Storage objects accepted by the chunked
   `/api/ambient/evidence/upload/begin|chunk|commit` endpoints, tracked in a
-  durable per-object upload ledger;
+  durable per-object upload ledger. When deterministic sanitization was
+  applied, the evidence ref stores the redaction metadata and sanitized object
+  hash/size;
 - attached image artifact metadata accepted by `/api/ambient/agent-artifacts`
   for screenshots/images explicitly attached into Codex or Claude sessions;
 - Codex session attribution records (session id, file hash, attribution state

package/dist/adapters/raw-evidence.js

@@ -1,4 +1,4 @@
-import { EvidenceCompletenessPayloadSchema, SECRET_FILE_SEGMENT_PATTERN, SourceScanResultSchema, containsSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { EvidenceCompletenessPayloadSchema, 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";
@@ -29,6 +29,7 @@ export async function collectRawEvidencePack(context, options) {
     const skipped = [];
     const truncated = [];
     const failed = [];
+    const redacted = [];
     const reused = [];
     const sinceMinutes = options.sinceMinutes ?? DEFAULT_SINCE_MINUTES;
     const sessionLimit = options.sessionLimit ?? DEFAULT_SESSION_LIMIT;
@@ -42,6 +43,7 @@ export async function collectRawEvidencePack(context, options) {
         skipped,
         truncated,
         failed,
+        redacted,
         reused,
         scanned: new Map(),
         caps: [
@@ -126,6 +128,7 @@ export async function collectRawEvidencePack(context, options) {
                 file_count: 0,
                 byte_size: 0,
                 skipped_count: countEvidenceEntries(skipped),
+                sanitized_count: redacted.length,
                 reused_count: reused.length,
                 deferred_byte_budget_count: deferredByteBudgetCount,
                 deferred_object_budget_count: deferredObjectBudgetCount,
@@ -150,6 +153,7 @@ export async function collectRawEvidencePack(context, options) {
             packId,
             entries,
             skipped,
+            redacted,
             reused,
         });
         const manifestPath = path.join(evidenceDir, "manifest.json");
@@ -180,6 +184,7 @@ export async function collectRawEvidencePack(context, options) {
             file_count: entries.length,
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
             skipped_count: countEvidenceEntries(skipped),
+            sanitized_count: redacted.length,
             reused_count: reused.length,
             deferred_byte_budget_count: deferredByteBudgetCount,
             deferred_object_budget_count: deferredObjectBudgetCount,
@@ -225,6 +230,7 @@ export async function collectRawEvidencePack(context, options) {
             file_count: 0,
             byte_size: 0,
             skipped_count: countEvidenceEntries(skipped),
+            sanitized_count: redacted.length,
             reused_count: reused.length,
             deferred_byte_budget_count: skipped
                 .filter((entry) => entry.reason === "deferred_byte_budget")
@@ -603,15 +609,29 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return false;
     }
-    if (containsSecretLikeContent(raw.toString("utf8"))) {
+    const sanitized = sanitizeTextEvidenceForUpload({
+        text: raw.toString("utf8"),
+        originalBytes: raw,
+        redactedFields: [`${options.kind}.body`],
+    });
+    if (sanitized.status === "blocked") {
         collection.skipped.push({
             kind: options.kind,
             label: fileName,
-            reason: "secret_like_content_guard",
+            reason: sanitized.reason,
         });
         return false;
     }
-    const contentHash = sha256(raw);
+    if (sanitized.status === "redacted") {
+        collection.redacted.push({
+            kind: options.kind,
+            label: fileName,
+            redaction: sanitized.redaction,
+        });
+    }
+    const evidenceBytes = sanitized.bytes;
+    const redaction = sanitized.redaction;
+    const contentHash = sha256(evidenceBytes);
     if (collection.skipContentHashes.has(contentHash)) {
         collection.reused.push({
             kind: options.kind,
@@ -621,7 +641,7 @@ async function collectOneEvidenceFile(collection, options) {
         });
         return true;
     }
-    const deferReason = admitToBudget(collection.budget, raw.byteLength);
+    const deferReason = admitToBudget(collection.budget, evidenceBytes.byteLength);
     if (deferReason) {
         markBudgetCapApplied(collection, deferReason);
         collection.skipped.push({
@@ -634,7 +654,7 @@ async function collectOneEvidenceFile(collection, options) {
     collection.index.value += 1;
     const relativePath = path.join("files", `${String(collection.index.value).padStart(3, "0")}-${shortHash(options.filePath)}-${fileName}`);
     const destination = path.join(collection.filesDir, path.basename(relativePath));
-    await fs.writeFile(destination, raw, { mode: 0o600 });
+    await fs.writeFile(destination, evidenceBytes, { mode: 0o600 });
     await chmodPrivate(destination, 0o600);
     collection.entries.push(evidenceEntry({
         context: collection.context,
@@ -643,8 +663,11 @@ async function collectOneEvidenceFile(collection, options) {
         localPath: destination,
         relativePath,
         mediaType: options.mediaType,
-        redactedSummary: options.redactedSummary,
-        bytes: raw,
+        redactedSummary: redaction
+            ? `${options.redactedSummary} Secret-like values were deterministically redacted before upload.`
+            : options.redactedSummary,
+        redaction,
+        bytes: evidenceBytes,
         codexSessionId: options.sessionId,
         contentAddress: options.contentAddress(contentHash.slice(0, 16)),
     }));
@@ -664,6 +687,31 @@ function admitToBudget(budget, byteLength) {
     budget.remainingBytes -= byteLength;
     return null;
 }
+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 sanitizedBytes = Buffer.from(redactionResult.text, "utf8");
+        return {
+            status: "redacted",
+            bytes: sanitizedBytes,
+            redaction: withRedactionContentMetadata(redactionResult.metadata, {
+                originalBytes,
+                sanitizedBytes,
+            }),
+        };
+    }
+    if (containsSecretLikeContent(options.text)) {
+        return { status: "blocked", reason: "secret_like_content_guard" };
+    }
+    return { status: "clean", bytes: originalBytes };
+}
 async function collectGitDiffFiles(collection, repoRoot) {
     const diffTargets = [
         { label: "unstaged", args: ["diff", "--no-ext-diff", "--"] },
@@ -697,15 +745,27 @@ async function collectGitDiffFiles(collection, repoRoot) {
         }
         if (!diff.stdout.trim())
             continue;
-        if (containsSecretLikeContent(diff.stdout)) {
+        const sanitized = sanitizeTextEvidenceForUpload({
+            text: diff.stdout,
+            redactedFields: [`git_diff.${target.label}`],
+        });
+        if (sanitized.status === "blocked") {
             collection.skipped.push({
                 kind: "git_diff",
                 label: target.label,
-                reason: "secret_like_content_guard",
+                reason: sanitized.reason,
             });
             continue;
         }
-        const raw = Buffer.from(diff.stdout, "utf8");
+        if (sanitized.status === "redacted") {
+            collection.redacted.push({
+                kind: "git_diff",
+                label: target.label,
+                redaction: sanitized.redaction,
+            });
+        }
+        const raw = sanitized.bytes;
+        const redaction = sanitized.redaction;
         const contentHash = sha256(raw);
         if (collection.skipContentHashes.has(contentHash)) {
             collection.reused.push({
@@ -737,9 +797,12 @@ async function collectGitDiffFiles(collection, repoRoot) {
             localPath: destination,
             relativePath,
             mediaType: "text/x-diff",
-            redactedSummary: diff.truncated
-                ? `Raw git ${target.label} diff truncated to the capture cap and preserved locally with env/secret paths excluded.`
-                : `Raw git ${target.label} diff preserved locally with env/secret paths excluded.`,
+            redactedSummary: redaction
+                ? `Raw git ${target.label} diff preserved locally with env/secret paths excluded and secret-like values deterministically redacted.`
+                : diff.truncated
+                    ? `Raw git ${target.label} diff truncated to the capture cap and preserved locally with env/secret paths excluded.`
+                    : `Raw git ${target.label} diff preserved locally with env/secret paths excluded.`,
+            redaction,
             bytes: raw,
             contentAddress: `git-diff/${target.label}-${contentHash.slice(0, 16)}.diff`,
         }));
@@ -864,6 +927,8 @@ function makeEvidenceCompleteness(collection, options) {
         sources.add(entry.kind);
     for (const entry of collection.failed)
         sources.add(entry.kind);
+    for (const entry of collection.redacted)
+        sources.add(entry.kind);
     const sourceCounts = [...sources].sort().map((source) => {
         const skipped = collection.skipped.filter((entry) => entry.kind === source);
         return {
@@ -950,10 +1015,30 @@ 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 existing = redactionCounts.get(key);
+        if (existing) {
+            existing.count += 1;
+            existing.rule_ids = [...new Set([...existing.rule_ids, ...ruleIds])].sort();
+        }
+        else {
+            redactionCounts.set(key, {
+                source: redacted.kind,
+                status: "sanitized",
+                mode: redacted.redaction.mode,
+                count: 1,
+                rule_ids: [...new Set(ruleIds)].sort(),
+            });
+        }
+    }
     const hasGaps = totals.skipped_count > 0 ||
         totals.truncated_count > 0 ||
         totals.deferred_count > 0 ||
         totals.failed_count > 0 ||
+        collection.redacted.length > 0 ||
         collection.caps.some((cap) => cap.applied);
     const status = totals.failed_count > 0 &&
         totals.included_count + totals.reused_count === 0
@@ -978,11 +1063,14 @@ function makeEvidenceCompleteness(collection, options) {
         skip_reasons: [...skipReasonCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
         failure_reasons: [...failureReasonCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
         truncation_markers: [...truncationCounts.values()].sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
+        redaction_markers: [...redactionCounts.values()].sort((a, b) => `${a.source}:${a.mode}`.localeCompare(`${b.source}:${b.mode}`)),
         notes: totals.failed_count > 0
             ? ["Evidence collection failed; downstream analysis should not infer confidence."]
-            : hasGaps
-                ? ["Evidence is incomplete; downstream analysis should lower confidence."]
-                : [],
+            : collection.redacted.length > 0
+                ? ["Evidence was sanitized before upload; downstream analysis should not treat it as raw-complete."]
+                : hasGaps
+                    ? ["Evidence is incomplete; downstream analysis should lower confidence."]
+                    : [],
     });
 }
 async function walkJsonlFiles(dir, cutoffMs) {
@@ -1045,6 +1133,7 @@ function makeManifest(options) {
         },
         files: options.entries.map(redactManifestEntry),
         skipped: options.skipped,
+        redacted: options.redacted,
         reused: options.reused,
     };
 }
@@ -1065,6 +1154,7 @@ function evidenceEntry(options) {
         byte_size: options.bytes.byteLength,
         media_type: options.mediaType,
         redacted_summary: options.redactedSummary,
+        ...(options.redaction ? { redaction: options.redaction } : {}),
         codex_session_id: options.codexSessionId ?? null,
         ...(options.artifactMetadata
             ? {
@@ -1089,6 +1179,7 @@ function redactManifestEntry(entry) {
         byte_size: entry.byte_size,
         media_type: entry.media_type,
         redacted_summary: entry.redacted_summary,
+        ...(entry.redaction ? { redaction: entry.redaction } : {}),
         ...(entry.artifact_metadata
             ? { artifact_metadata: entry.artifact_metadata }
             : {}),
@@ -1109,6 +1200,7 @@ function pointerFromEntry(entry) {
         byte_size: entry.byte_size,
         media_type: entry.media_type,
         redacted_summary: entry.redacted_summary,
+        ...(entry.redaction ? { redaction: entry.redaction } : {}),
     };
 }
 /**
@@ -1193,6 +1285,18 @@ function safeKeySegment(value) {
 function sha256(value) {
     return crypto.createHash("sha256").update(value).digest("hex");
 }
+function withRedactionContentMetadata(metadata, options) {
+    if (!metadata) {
+        throw new Error("redacted evidence is missing redaction metadata");
+    }
+    return {
+        ...metadata,
+        original_content_hash_sha256: sha256(options.originalBytes),
+        sanitized_content_hash_sha256: sha256(options.sanitizedBytes),
+        original_byte_size: options.originalBytes.byteLength,
+        sanitized_byte_size: options.sanitizedBytes.byteLength,
+    };
+}
 async function ensurePrivateDir(dir) {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     await chmodPrivate(dir, 0o700);

package/dist/agent-rules.js

@@ -106,9 +106,9 @@ export function cockpitAgentRulesBlock(options = {}) {
         "## Cockpit Ticket Binding",
         "",
         scopeLine,
-        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
+        "- For implementation, debugging, review, PR, or ship work that already has a clear Linear ticket, run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
         "- Use `--ticket`; do not invent `--ticketId` or other flag shapes.",
-        "- If the user mentions ticketed work but no ticket ID is visible, ask once for the Linear ticket ID before editing. Agents cannot reliably infer it from context.",
+        "- If the user mentions ticketed work but no ticket ID is visible, search Linear for an existing ticket before editing. If none exists and the work is ticket-worthy, create a narrow Linear ticket, then run the canonical `cockpit start --ticket ...` command. Ask the user only when ticket creation would be ambiguous or the user has forbidden creating one.",
         "- If there is truly no ticket, state that the work remains in general ambient capture and do not invent a ticket.",
         "- After the first meaningful checkpoint, run `cockpit sync --workspace \"$PWD\" --json` so Cockpit has fresh ticket/session binding metadata.",
         MANAGED_BLOCK_END,
@@ -208,16 +208,20 @@ function hasEquivalentUnmanagedTicketBinding(contents, scopePath) {
         return false;
     if (scopePath && !hasScopePath(text, scopePath))
         return false;
+    if (!hasTicketLookupOrCreationCue(text))
+        return false;
     const signals = [
         /cockpit\s+start\s+--ticket\b/u,
         /before\s+(?:the\s+)?first\s+code\s+edit|before\s+ticketed\s+implementation/u,
-        /ticket\s+id\s+(?:is\s+)?(?:missing|visible)|ask\s+once/u,
         /general\s+ambient/u,
         /cockpit\s+sync\s+--repo|fresh\s+ticket\/session\s+binding\s+metadata/u,
         /use\s+--ticket|do\s+not\s+invent\s+--ticketid/u,
     ];
     const score = signals.filter((signal) => signal.test(text)).length;
-    return score >= 5;
+    return score >= 4;
+}
+function hasTicketLookupOrCreationCue(text) {
+    return /search\s+linear|create\s+(?:a\s+)?(?:narrow\s+)?linear\s+ticket|new\s+linear\s+ticket/u.test(text);
 }
 function hasScopePath(text, scopePath) {
     return text.includes(normalizeRuleText(path.resolve(scopePath)));

package/dist/evidence-upload-client.js

@@ -1,4 +1,4 @@
-import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadCommitResponseSchema, } from "@bli-cockpit/telemetry-core";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 const DEFAULT_MAX_ATTEMPTS = 3;
@@ -114,7 +114,7 @@ export async function uploadRawEvidenceFilesChunked(options) {
 function duplicateOutcome(primary, duplicate) {
     return {
         ...primary,
-        pointer: duplicate.pointer,
+        pointer: pointerWithUploadedMetadata(duplicate.pointer, primary.pointer),
         codex_session_id: duplicate.codex_session_id ?? null,
         kind: duplicate.kind ?? "unknown",
         artifact_metadata: duplicate.artifact_metadata,
@@ -181,9 +181,10 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
     const commitStatus = commit.body && typeof commit.body === "object"
         ? commit.body.status
         : undefined;
+    const committedPointer = pointerWithCommitResponse(entry.file.pointer, commit.body);
     if (commitStatus === "already_committed") {
         return {
-            pointer: entry.file.pointer,
+            pointer: committedPointer,
             object_key: objectKey,
             codex_session_id: entry.file.codex_session_id ?? null,
             kind: entry.file.kind ?? "unknown",
@@ -194,7 +195,7 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
         };
     }
     return {
-        pointer: entry.file.pointer,
+        pointer: committedPointer,
         object_key: objectKey,
         codex_session_id: entry.file.codex_session_id ?? null,
         kind: entry.file.kind ?? "unknown",
@@ -227,8 +228,9 @@ async function uploadWithLegacyFallback(options, loaded, outcomes) {
             ],
         });
         if (response.ok) {
+            const pointer = pointerWithLegacyUploadResponse(entry.file.pointer, response.body);
             outcome = {
-                pointer: entry.file.pointer,
+                pointer,
                 object_key: entry.file.pointer.object_key ?? "",
                 codex_session_id: entry.file.codex_session_id ?? null,
                 kind: entry.file.kind ?? "unknown",
@@ -331,6 +333,50 @@ function failedOutcome(file, reason, uploadedChunks = 0) {
         uploaded_chunk_count: uploadedChunks,
     };
 }
+function pointerWithCommitResponse(pointer, body) {
+    const parsed = RawEvidenceUploadCommitResponseSchema.safeParse(body);
+    if (!parsed.success)
+        return pointer;
+    return pointerWithUploadedMetadata(pointer, {
+        content_hash_sha256: parsed.data.content_hash_sha256,
+        byte_size: parsed.data.byte_size,
+        redaction: parsed.data.redaction,
+    });
+}
+function pointerWithLegacyUploadResponse(pointer, body) {
+    if (!body || typeof body !== "object")
+        return pointer;
+    const uploaded = body.uploaded;
+    if (!Array.isArray(uploaded))
+        return pointer;
+    const entry = uploaded.find((candidate) => {
+        if (!candidate || typeof candidate !== "object")
+            return false;
+        return (candidate
+            .raw_evidence_pointer_id === pointer.raw_evidence_pointer_id);
+    });
+    if (!entry || typeof entry !== "object")
+        return pointer;
+    const record = entry;
+    return pointerWithUploadedMetadata(pointer, {
+        content_hash_sha256: typeof record["content_hash_sha256"] === "string"
+            ? record["content_hash_sha256"]
+            : undefined,
+        byte_size: typeof record["byte_size"] === "number" ? record["byte_size"] : undefined,
+        redaction: record["redaction"],
+    });
+}
+function pointerWithUploadedMetadata(pointer, metadata) {
+    const redaction = RawEvidenceRedactionMetadataSchema.safeParse(metadata.redaction);
+    return {
+        ...pointer,
+        content_hash_sha256: typeof metadata.content_hash_sha256 === "string"
+            ? metadata.content_hash_sha256
+            : pointer.content_hash_sha256,
+        byte_size: typeof metadata.byte_size === "number" ? metadata.byte_size : pointer.byte_size,
+        redaction: redaction.success ? redaction.data : pointer.redaction,
+    };
+}
 function summarizeOutcomes(outcomes, usedLegacyFallback) {
     const uploaded = outcomes.filter((outcome) => outcome.upload_state === "uploaded");
     return {

package/dist/upload.js

@@ -162,7 +162,7 @@ export async function syncLocalAmbientEnvelope(options = {}) {
             uploadOutcomes = upload.outcomes;
             uploadedChunkCount = upload.uploaded_chunk_count;
         }
-        const envelope = pruneUndurablePointers(built.envelope, uploadOutcomes);
+        const envelope = applyRawEvidenceUploadOutcomes(built.envelope, uploadOutcomes);
         const response = await fetchImpl(`${built.dashboard_url}/api/ambient/ingest`, {
             method: "POST",
             headers: {
@@ -499,6 +499,7 @@ function rawEvidenceSummary(built, outcomes, uploadedChunkCount, cursor) {
         raw_evidence_uploaded_chunk_count: uploadedChunkCount,
         raw_evidence_reused_count: cursorReused.length + serverReusedCount,
         raw_evidence_failed_count: failed.length,
+        raw_evidence_sanitized_count: built.raw_evidence_facts?.sanitized_count ?? 0,
         raw_evidence_failure_reasons: [
             ...new Set(failed.map((outcome) => outcome.reason ?? "unknown")),
         ],
@@ -523,32 +524,40 @@ function rawEvidenceSummary(built, outcomes, uploadedChunkCount, cursor) {
 }
 /**
  * Ingest refuses pointers whose objects never became durable, so failed
- * uploads are pruned from the envelope instead of failing the whole sync;
- * the failures stay visible via reason labels and the server-side ledger.
+ * uploads are pruned from the envelope instead of failing the whole sync.
+ * Successful upload responses can also carry server-side sanitized hash and
+ * redaction metadata; apply those before ingest so refs describe the bytes
+ * actually stored in the durable bucket.
  */
-function pruneUndurablePointers(envelope, outcomes) {
+function applyRawEvidenceUploadOutcomes(envelope, outcomes) {
     // Content-addressed keys mean one pointer id can carry several outcomes
     // (byte-identical files); the pointer is durable if ANY outcome succeeded.
-    const durablePointerIds = new Set(outcomes
-        .filter((outcome) => outcome.upload_state !== "upload_failed")
-        .map((outcome) => outcome.pointer.raw_evidence_pointer_id));
+    const durablePointers = new Map();
+    for (const outcome of outcomes) {
+        if (outcome.upload_state === "upload_failed")
+            continue;
+        durablePointers.set(outcome.pointer.raw_evidence_pointer_id, outcome.pointer);
+    }
+    const durablePointerIds = new Set([...durablePointers.keys()]);
     const failedPointerIds = new Set(outcomes
         .filter((outcome) => outcome.upload_state === "upload_failed" &&
         !durablePointerIds.has(outcome.pointer.raw_evidence_pointer_id))
         .map((outcome) => outcome.pointer.raw_evidence_pointer_id));
     const failedOutcomes = outcomes.filter((outcome) => failedPointerIds.has(outcome.pointer.raw_evidence_pointer_id));
-    if (failedPointerIds.size === 0)
+    if (failedPointerIds.size === 0 && durablePointers.size === 0)
         return envelope;
     return {
         ...envelope,
         events: envelope.events.map((event) => ({
             ...event,
-            metrics: {
-                ...event.metrics,
-                evidence_failed_count: (event.metrics["evidence_failed_count"] ?? 0) +
-                    failedOutcomes.length,
-            },
-            attributes: event.evidence_completeness
+            metrics: failedPointerIds.size > 0
+                ? {
+                    ...event.metrics,
+                    evidence_failed_count: (event.metrics["evidence_failed_count"] ?? 0) +
+                        failedOutcomes.length,
+                }
+                : event.metrics,
+            attributes: failedPointerIds.size > 0 && event.evidence_completeness
                 ? {
                     ...event.attributes,
                     evidence_completeness_schema_version: event.evidence_completeness.schema_version,
@@ -556,14 +565,21 @@ function pruneUndurablePointers(envelope, outcomes) {
                     evidence_incomplete: true,
                 }
                 : event.attributes,
-            evidence_completeness: event.evidence_completeness
+            evidence_completeness: failedPointerIds.size > 0 && event.evidence_completeness
                 ? markCompletenessUploadFailures(event.evidence_completeness, failedOutcomes)
                 : event.evidence_completeness,
-            raw_evidence_pointers: event.raw_evidence_pointers.filter((pointer) => !failedPointerIds.has(pointer.raw_evidence_pointer_id)),
-            redaction: {
-                ...event.redaction,
-                raw_evidence_pointer_ids: event.redaction.raw_evidence_pointer_ids.filter((pointerId) => !failedPointerIds.has(pointerId)),
-            },
+            raw_evidence_pointers: event.raw_evidence_pointers.flatMap((pointer) => {
+                const pointerId = pointer.raw_evidence_pointer_id;
+                if (failedPointerIds.has(pointerId))
+                    return [];
+                return [durablePointers.get(pointerId) ?? pointer];
+            }),
+            redaction: failedPointerIds.size > 0
+                ? {
+                    ...event.redaction,
+                    raw_evidence_pointer_ids: event.redaction.raw_evidence_pointer_ids.filter((pointerId) => !failedPointerIds.has(pointerId)),
+                }
+                : event.redaction,
         })),
     };
 }
@@ -701,6 +717,7 @@ function makeSourceScanCompletedEvent(options) {
             raw_evidence_file_count: options.rawEvidenceFacts?.file_count ?? 0,
             raw_evidence_byte_size: options.rawEvidenceFacts?.byte_size ?? 0,
             raw_evidence_skipped_count: options.rawEvidenceFacts?.skipped_count ?? 0,
+            raw_evidence_sanitized_count: options.rawEvidenceFacts?.sanitized_count ?? 0,
             raw_evidence_reused_count: options.rawEvidenceFacts?.reused_count ?? 0,
             evidence_scanned_count: evidenceCompleteness?.totals.scanned_count ?? 0,
             evidence_included_count: evidenceCompleteness?.totals.included_count ?? 0,

package/package.json

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