@bli-cockpit/cli 0.1.20 → 0.1.22

package/README.md

@@ -14,24 +14,24 @@ device pairing.
 Run this from the repo where work will happen:
 
 ```bash
-COCKPIT_DEVICE_NAME="$(scutil --get ComputerName 2>/dev/null || hostname -s)"
 npm install -g @bli-cockpit/cli@latest
-cockpit onboard \
-  --email <APPROVED_EMAIL> \
-  --device-name "$COCKPIT_DEVICE_NAME" \
-  --workspace "$PWD"
+cockpit onboard --workspace "$PWD"
+```
+
+Interactive onboarding prompts for the dashboard email. Enter the approved
+intern/operator email. For reused laptops, VMs, or headless/agent-run setup,
+pass the email explicitly:
+
+```bash
+cockpit onboard --email <APPROVED_EMAIL> --workspace "$PWD"
 ```
 
 If a work folder contains multiple repos, run the same command from the parent:
 
 ```bash
 cd ~/Downloads/bluepearl-workspace
-COCKPIT_DEVICE_NAME="$(scutil --get ComputerName 2>/dev/null || hostname -s)"
 npm install -g @bli-cockpit/cli@latest
-cockpit onboard \
-  --email <APPROVED_EMAIL> \
-  --device-name "$COCKPIT_DEVICE_NAME" \
-  --workspace "$PWD"
+cockpit onboard --workspace "$PWD"
 ```
 
 The CLI defaults to the production dashboard. Normal intern/operator setup,
@@ -50,6 +50,11 @@ to install or replace it. The managed guidance is scoped to the workspace path
 used for onboarding, so agents should ignore it in private chats or unrelated
 repos.
 
+For intern machines, accept the onboarding prompt to keep Cockpit syncing in the
+background. It installs the launchd autostart agent so Cockpit syncs at login
+and every 15 minutes. If skipped, run
+`cockpit autostart install --workspace "$PWD"` later.
+
 ```bash
 # Repair/manual path, or headless/json onboarding where Cockpit cannot prompt.
 cockpit agent-rules install --workspace "$PWD"
@@ -79,33 +84,40 @@ What happens:
 1. npm installs or updates the public `@bli-cockpit/cli` package.
 2. `cockpit onboard` writes local user config.
 3. Cockpit prints a dashboard pairing URL and code.
-4. Admin approves the pending request from Ambient -> Collector approvals, or
-   pastes the printed code there. The signed-in intern can still use the
-   printed URL.
+4. Admin approves the persistent email access request from Ambient -> Collector
+   approvals. Pair codes still expire, but the access request remains. If the
+   terminal is still polling, approval pairs it immediately; if not, the intern
+   reruns `cockpit onboard --email <APPROVED_EMAIL> --workspace "$PWD"` and the
+   stored approval auto-pairs without another Admin action. Admin can still
+   paste the printed code there as a rescue path. The signed-in intern can still
+   use the printed URL. If the claimed email is not an app user yet, a super
+   admin approval creates the user, adds team membership, and sends the
+   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.
 6. The CLI prints `PASS: Cockpit collector is ready for harvest.`
 
-`--device-name` is just a readable label in Cockpit. It can be
-`"Savina MacBook"`, `"Box VM 42"`, or the auto-filled macOS computer name.
+`--device-name` is optional and only a readable label in Cockpit. Pass it only
+when you want a specific label such as `"Savina MacBook"` or `"Box VM 42"`.
 On reused laptops or VMs, keep `--email <APPROVED_EMAIL>` in the command.
 `cockpit onboard` skips pairing only when the existing valid session belongs to
 that same email and dashboard URL (the production default unless overridden); a
 different email or dashboard forces a new approval.
 
-Before the command runs, an Admin must create or approve the email in the
-private dashboard. Default launch path is email + temporary password, handed
-over out of band. Magic link remains available as fallback.
-For temporary-password accounts, the intern signs in directly; there is no
-separate invite acceptance step.
+Before the command runs, an Admin does not need to open Supabase or pre-create
+ordinary interns in Settings -> Team. Approval of the claimed email in Ambient
+creates the missing app user and stores the durable access approval. Settings
+-> Team remains available for manual pre-provisioning, including
+temporary-password launch. For temporary-password accounts, the intern signs in
+directly; there is no separate invite acceptance step.
 
 When ticket work starts later:
 
 ```bash
 cockpit start \
   --ticket <ticket-id> \
-  --repo "$PWD"
+  --workspace "$PWD"
 
 cockpit sync \
   --workspace "$PWD" \

package/dist/adapters/claude-attribution.js

@@ -54,8 +54,19 @@ export async function scanAndAttributeClaudeSessions(options) {
     const countState = (state) => results.filter((result) => result.state === state).length;
     return {
         results,
+        discovered_session_count: discovery.sessions.length,
         scanned_session_count: sessions.length,
+        since_minutes: sinceMinutes,
+        session_limit: limit,
+        session_limit_applied: discovery.sessions.length > limit,
+        max_file_bytes: CLAUDE_SESSION_MAX_FILE_BYTES,
+        max_sidecar_files: CLAUDE_SESSION_MAX_SIDECAR_FILES,
+        max_line_buffer_bytes: MAX_LINE_BUFFER_BYTES,
         project_dirs_skipped: discovery.projectDirsSkipped,
+        project_dir_read_failed_count: discovery.projectDirReadFailedCount,
+        session_stat_failed_count: discovery.sessionStatFailedCount,
+        sidecar_dir_read_failed_count: discovery.sidecarDirReadFailedCount,
+        sidecar_stat_failed_count: discovery.sidecarStatFailedCount,
         counts: {
             attributed: countState("attributed"),
             ambiguous: countState("ambiguous"),
@@ -72,12 +83,23 @@ export async function scanAndAttributeClaudeSessions(options) {
 async function discoverClaudeSessions(projectsDir, cutoffMs) {
     const sessions = [];
     let projectDirsSkipped = 0;
+    let projectDirReadFailedCount = 0;
+    let sessionStatFailedCount = 0;
+    let sidecarDirReadFailedCount = 0;
+    let sidecarStatFailedCount = 0;
     let projectEntries;
     try {
         projectEntries = await fs.readdir(projectsDir, { withFileTypes: true });
     }
     catch {
-        return { sessions, projectDirsSkipped };
+        return {
+            sessions,
+            projectDirsSkipped,
+            projectDirReadFailedCount: 1,
+            sessionStatFailedCount,
+            sidecarDirReadFailedCount,
+            sidecarStatFailedCount,
+        };
     }
     for (const projectEntry of projectEntries) {
         if (!projectEntry.isDirectory())
@@ -96,6 +118,7 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
             sessionEntries = await fs.readdir(projectDir, { withFileTypes: true });
         }
         catch {
+            projectDirReadFailedCount += 1;
             continue;
         }
         for (const sessionEntry of sessionEntries) {
@@ -109,10 +132,14 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
                 mainStat = await fs.stat(mainFile);
             }
             catch {
+                sessionStatFailedCount += 1;
                 continue;
             }
             const sessionUuid = sessionEntry.name.replace(/\.jsonl$/i, "");
-            const { sidecars, sidecarsCapped } = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
+            const sidecarDiscovery = await discoverSidecars(path.join(projectDir, sessionUuid, "subagents"));
+            const { sidecars, sidecarsCapped } = sidecarDiscovery;
+            sidecarDirReadFailedCount += sidecarDiscovery.dirReadFailedCount;
+            sidecarStatFailedCount += sidecarDiscovery.statFailedCount;
             const recencyMs = Math.max(mainStat.mtimeMs, ...sidecars.map((sidecar) => sidecar.mtimeMs));
             // D10: a session is recent if its main file OR any sidecar is in window.
             if (recencyMs < cutoffMs)
@@ -127,7 +154,14 @@ async function discoverClaudeSessions(projectsDir, cutoffMs) {
             });
         }
     }
-    return { sessions, projectDirsSkipped };
+    return {
+        sessions,
+        projectDirsSkipped,
+        projectDirReadFailedCount,
+        sessionStatFailedCount,
+        sidecarDirReadFailedCount,
+        sidecarStatFailedCount,
+    };
 }
 async function discoverSidecars(subagentsDir) {
     let entries;
@@ -135,9 +169,15 @@ async function discoverSidecars(subagentsDir) {
         entries = await fs.readdir(subagentsDir, { withFileTypes: true });
     }
     catch {
-        return { sidecars: [], sidecarsCapped: 0 };
+        return {
+            sidecars: [],
+            sidecarsCapped: 0,
+            dirReadFailedCount: 1,
+            statFailedCount: 0,
+        };
     }
     const discovered = [];
+    let statFailedCount = 0;
     for (const entry of entries) {
         // Only agent transcripts. `*.meta.json` carry operator-authored
         // descriptions and are never harvested (D3).
@@ -152,6 +192,7 @@ async function discoverSidecars(subagentsDir) {
             stat = await fs.stat(local_path);
         }
         catch {
+            statFailedCount += 1;
             continue;
         }
         discovered.push({
@@ -166,6 +207,8 @@ async function discoverSidecars(subagentsDir) {
     return {
         sidecars: discovered.slice(0, CLAUDE_SESSION_MAX_SIDECAR_FILES),
         sidecarsCapped: capped,
+        dirReadFailedCount: 0,
+        statFailedCount,
     };
 }
 async function attributeOneSession(session, worktrees) {

package/dist/adapters/codex-attribution.js

@@ -23,14 +23,23 @@ export async function scanAndAttributeCodexSessions(options) {
     const sinceMinutes = options.sinceMinutes ?? CODEX_ATTRIBUTION_DEFAULT_SINCE_MINUTES;
     const limit = options.limit ?? CODEX_ATTRIBUTION_DEFAULT_SESSION_LIMIT;
     const cutoffMs = options.now.getTime() - sinceMinutes * 60 * 1000;
-    const files = (await walkCodexJsonlFiles(options.sessionsDir, cutoffMs)).slice(0, limit);
+    const discovery = await discoverCodexJsonlFiles(options.sessionsDir, cutoffMs);
+    const files = discovery.files.slice(0, limit);
     const results = [];
     for (const file of files) {
         results.push(await attributeOneSession(file, options.worktrees));
     }
     return {
         results,
+        discovered_file_count: discovery.files.length,
         scanned_file_count: files.length,
+        since_minutes: sinceMinutes,
+        session_limit: limit,
+        session_limit_applied: discovery.files.length > limit,
+        max_file_bytes: CODEX_SESSION_MAX_FILE_BYTES,
+        directory_read_failed_count: discovery.directoryReadFailedCount,
+        stat_failed_count: discovery.statFailedCount,
+        secret_path_skipped_count: discovery.secretPathSkippedCount,
         counts: {
             attributed: results.filter((entry) => entry.state === "attributed").length,
             ambiguous: results.filter((entry) => entry.state === "ambiguous").length,
@@ -41,25 +50,40 @@ export async function scanAndAttributeCodexSessions(options) {
     };
 }
 export async function walkCodexJsonlFiles(dir, cutoffMs) {
+    return (await discoverCodexJsonlFiles(dir, cutoffMs)).files;
+}
+async function discoverCodexJsonlFiles(dir, cutoffMs) {
     const out = [];
+    let directoryReadFailedCount = 0;
+    let statFailedCount = 0;
+    let secretPathSkippedCount = 0;
     const stack = [dir];
     while (stack.length > 0) {
         const current = stack.pop();
-        if (!current || isSecretLikePath(current))
+        if (!current)
+            continue;
+        if (isSecretLikePath(current)) {
+            secretPathSkippedCount += 1;
             continue;
+        }
         let entries;
         try {
             entries = await fs.readdir(current, { withFileTypes: true });
         }
         catch {
+            directoryReadFailedCount += 1;
             continue;
         }
         for (const entry of entries) {
             const full = path.join(current, entry.name);
             if (entry.isDirectory()) {
                 // Never descend into secret-like directories.
-                if (!isSecretLikePath(full))
+                if (isSecretLikePath(full)) {
+                    secretPathSkippedCount += 1;
+                }
+                else {
                     stack.push(full);
+                }
                 continue;
             }
             // Secret-like file NAMES stay in the list so attribution can record a
@@ -67,14 +91,26 @@ export async function walkCodexJsonlFiles(dir, cutoffMs) {
             // instead of silently dropping the session.
             if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
                 continue;
-            const stat = await fs.stat(full);
+            let stat;
+            try {
+                stat = await fs.stat(full);
+            }
+            catch {
+                statFailedCount += 1;
+                continue;
+            }
             if (stat.mtimeMs >= cutoffMs) {
                 out.push({ file: full, mtimeMs: stat.mtimeMs, byteSize: stat.size });
             }
         }
     }
     out.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return out;
+    return {
+        files: out,
+        directoryReadFailedCount,
+        statFailedCount,
+        secretPathSkippedCount,
+    };
 }
 async function attributeOneSession(file, worktrees) {
     const fileName = path.basename(file.file);

package/dist/adapters/local-sources.js

@@ -28,7 +28,9 @@ export async function runLocalSourceCollectors(options) {
             includeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
             includeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
             codexSessionFiles: options.rawEvidenceCodexSessionFiles,
+            codexAttributionScan: options.rawEvidenceCodexAttributionScan,
             claudeSessionFiles: options.rawEvidenceClaudeSessionFiles,
+            claudeAttributionScan: options.rawEvidenceClaudeAttributionScan,
             skipContentHashes: options.rawEvidenceSkipContentHashes,
             byteBudget: options.rawEvidenceByteBudget,
             objectBudget: options.rawEvidenceObjectBudget,

package/dist/adapters/raw-evidence.js

@@ -28,6 +28,7 @@ export async function collectRawEvidencePack(context, options) {
     const entries = [];
     const skipped = [];
     const truncated = [];
+    const failed = [];
     const reused = [];
     const sinceMinutes = options.sinceMinutes ?? DEFAULT_SINCE_MINUTES;
     const sessionLimit = options.sessionLimit ?? DEFAULT_SESSION_LIMIT;
@@ -40,6 +41,7 @@ export async function collectRawEvidencePack(context, options) {
         entries,
         skipped,
         truncated,
+        failed,
         reused,
         scanned: new Map(),
         caps: [
@@ -92,6 +94,10 @@ export async function collectRawEvidencePack(context, options) {
     try {
         await ensurePrivateDir(evidenceDir);
         await ensurePrivateDir(filesDir);
+        recordAttributionCompleteness(collection, {
+            codex: options.codexAttributionScan,
+            claude: options.claudeAttributionScan,
+        });
         if (options.includeCodexJsonl !== false) {
             await collectCodexJsonlFiles(collection, {
                 codexSessionFiles: options.codexSessionFiles,
@@ -104,8 +110,8 @@ export async function collectRawEvidencePack(context, options) {
             await collectClaudeJsonlFiles(collection, options.claudeSessionFiles);
         }
         await collectGitDiffFiles(collection, options.repoRoot);
-        const deferredByteBudgetCount = skipped.filter((entry) => entry.reason === "deferred_byte_budget").length;
-        const deferredObjectBudgetCount = skipped.filter((entry) => entry.reason === "deferred_object_budget").length;
+        const deferredByteBudgetCount = skipped.filter((entry) => entry.reason === "deferred_byte_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
+        const deferredObjectBudgetCount = skipped.filter((entry) => entry.reason === "deferred_object_budget").reduce((sum, entry) => sum + evidenceEntryCount(entry), 0);
         if (entries.length === 0) {
             const evidenceCompleteness = makeEvidenceCompleteness(collection, {
                 startedAt,
@@ -119,7 +125,7 @@ export async function collectRawEvidencePack(context, options) {
                 storage_bucket: RAW_EVIDENCE_BUCKET,
                 file_count: 0,
                 byte_size: 0,
-                skipped_count: skipped.length,
+                skipped_count: countEvidenceEntries(skipped),
                 reused_count: reused.length,
                 deferred_byte_budget_count: deferredByteBudgetCount,
                 deferred_object_budget_count: deferredObjectBudgetCount,
@@ -173,7 +179,7 @@ export async function collectRawEvidencePack(context, options) {
             storage_bucket: RAW_EVIDENCE_BUCKET,
             file_count: entries.length,
             byte_size: entries.reduce((sum, entry) => sum + entry.byte_size, 0),
-            skipped_count: skipped.length,
+            skipped_count: countEvidenceEntries(skipped),
             reused_count: reused.length,
             deferred_byte_budget_count: deferredByteBudgetCount,
             deferred_object_budget_count: deferredObjectBudgetCount,
@@ -201,18 +207,46 @@ export async function collectRawEvidencePack(context, options) {
             }),
         };
     }
-    catch (error) {
-        const scan = SourceScanResultSchema.parse({
-            adapter: makeSourceAdapterIdentity("collector_runtime", "raw-evidence-pack"),
-            work_context_id: context.workContextId,
-            status: "failed",
-            started_at: startedAt,
-            finished_at: context.now.toISOString(),
-            diagnostic_labels: [
-                `raw_evidence_failed:${error instanceof Error ? error.message : String(error)}`,
-            ],
+    catch {
+        failed.push({
+            kind: "raw_evidence",
+            reason: "collection_failed",
+        });
+        const evidenceCompleteness = makeEvidenceCompleteness(collection, {
+            startedAt,
+            finishedAt: context.now.toISOString(),
+            sinceMinutes,
         });
-        return { scan, facts: null };
+        const facts = {
+            pack_id: packId,
+            manifest_path: path.join(evidenceDir, "manifest.json"),
+            evidence_dir: evidenceDir,
+            storage_bucket: RAW_EVIDENCE_BUCKET,
+            file_count: 0,
+            byte_size: 0,
+            skipped_count: countEvidenceEntries(skipped),
+            reused_count: reused.length,
+            deferred_byte_budget_count: skipped
+                .filter((entry) => entry.reason === "deferred_byte_budget")
+                .reduce((sum, entry) => sum + evidenceEntryCount(entry), 0),
+            deferred_object_budget_count: skipped
+                .filter((entry) => entry.reason === "deferred_object_budget")
+                .reduce((sum, entry) => sum + evidenceEntryCount(entry), 0),
+            content_kinds: [],
+            evidence_completeness: evidenceCompleteness,
+            pointers: [],
+            upload_files: [],
+            reused,
+        };
+        return {
+            facts,
+            scan: makeRawEvidenceScan({
+                context,
+                startedAt,
+                status: "failed",
+                facts,
+            }),
+        };
     }
 }
 function makeRawEvidenceScan(options) {
@@ -246,10 +280,105 @@ function makeRawEvidenceScan(options) {
             `completeness:${options.facts.evidence_completeness.status}`,
             `truncated:${options.facts.evidence_completeness.totals.truncated_count}`,
             `deferred:${options.facts.evidence_completeness.totals.deferred_count}`,
+            `failed:${options.facts.evidence_completeness.totals.failed_count}`,
             ...options.facts.content_kinds.map((kind) => `kind:${kind}`),
         ],
     });
 }
+function recordAttributionCompleteness(collection, scans) {
+    if (scans.codex)
+        recordCodexAttributionCompleteness(collection, scans.codex);
+    if (scans.claude)
+        recordClaudeAttributionCompleteness(collection, scans.claude);
+}
+function recordCodexAttributionCompleteness(collection, scan) {
+    recordScanned(collection, "codex_attribution", scan.scanned_file_count);
+    collection.caps.push({
+        source: "codex_attribution",
+        cap_type: "scan_window_minutes",
+        limit: scan.since_minutes,
+        observed: scan.since_minutes,
+        applied: false,
+    }, {
+        source: "codex_attribution",
+        cap_type: "session_limit",
+        limit: scan.session_limit,
+        observed: scan.discovered_file_count,
+        applied: scan.session_limit_applied,
+    }, {
+        source: "codex_attribution",
+        cap_type: "max_file_bytes",
+        limit: scan.max_file_bytes,
+        applied: scan.results.some((result) => result.reason === "file_too_large"),
+    });
+    recordSkipCount(collection, "codex_attribution", "session_limit_overflow", Math.max(0, scan.discovered_file_count - scan.scanned_file_count));
+    recordSkipCount(collection, "codex_attribution", "directory_read_failed", scan.directory_read_failed_count);
+    recordSkipCount(collection, "codex_attribution", "file_stat_failed", scan.stat_failed_count);
+    recordSkipCount(collection, "codex_attribution", "secret_like_directory", scan.secret_path_skipped_count);
+    recordAttributionResultSkips(collection, "codex_attribution", scan.results);
+}
+function recordClaudeAttributionCompleteness(collection, scan) {
+    recordScanned(collection, "claude_attribution", scan.scanned_session_count);
+    if (scan.disabled_reason) {
+        recordSkipCount(collection, "claude_attribution", scan.disabled_reason, 1);
+    }
+    collection.caps.push({
+        source: "claude_attribution",
+        cap_type: "scan_window_minutes",
+        limit: scan.since_minutes,
+        observed: scan.since_minutes,
+        applied: false,
+    }, {
+        source: "claude_attribution",
+        cap_type: "session_limit",
+        limit: scan.session_limit,
+        observed: scan.discovered_session_count,
+        applied: scan.session_limit_applied,
+    }, {
+        source: "claude_attribution",
+        cap_type: "max_file_bytes",
+        limit: scan.max_file_bytes,
+        applied: scan.counts.mains_oversized > 0 ||
+            scan.results.some((result) => result.reason === "file_too_large"),
+    }, {
+        source: "claude_attribution",
+        cap_type: "max_sidecar_files",
+        limit: scan.max_sidecar_files,
+        observed: scan.max_sidecar_files + scan.counts.sidecars_capped,
+        applied: scan.counts.sidecars_capped > 0,
+    }, {
+        source: "claude_attribution",
+        cap_type: "max_line_buffer_bytes",
+        limit: scan.max_line_buffer_bytes,
+        applied: scan.counts.oversized_lines_skipped > 0,
+    });
+    recordSkipCount(collection, "claude_attribution", "session_limit_overflow", Math.max(0, scan.discovered_session_count - scan.scanned_session_count));
+    recordSkipCount(collection, "claude_attribution", "secret_like_project_dir", scan.project_dirs_skipped);
+    recordSkipCount(collection, "claude_attribution", "project_dir_read_failed", scan.project_dir_read_failed_count);
+    recordSkipCount(collection, "claude_attribution", "session_stat_failed", scan.session_stat_failed_count);
+    recordSkipCount(collection, "claude_attribution", "sidecar_dir_read_failed", scan.sidecar_dir_read_failed_count);
+    recordSkipCount(collection, "claude_attribution", "sidecar_stat_failed", scan.sidecar_stat_failed_count);
+    recordSkipCount(collection, "claude_attribution", "sidecar_limit_overflow", scan.counts.sidecars_capped);
+    recordTruncationCount(collection, "claude_attribution", "oversized_jsonl_line", scan.counts.oversized_lines_skipped, { max_bytes: scan.max_line_buffer_bytes });
+    recordAttributionResultSkips(collection, "claude_attribution", scan.results);
+    for (const result of scan.results) {
+        for (const sidecar of result.sidecar_files) {
+            if (!sidecar.skipped_reason)
+                continue;
+            recordSkipCount(collection, "claude_attribution", `sidecar_${sidecar.skipped_reason}`, 1);
+        }
+    }
+}
+function recordAttributionResultSkips(collection, source, results) {
+    for (const result of results) {
+        if (result.state === "attributed")
+            continue;
+        const reason = result.state === "skipped"
+            ? result.reason
+            : `attribution_${result.state}:${result.reason}`;
+        recordSkipCount(collection, source, reason, 1);
+    }
+}
 async function collectCodexJsonlFiles(collection, options) {
     const resolvedCandidates = options.codexSessionFiles
         ? options.codexSessionFiles.map((file) => ({
@@ -542,7 +671,18 @@ async function collectGitDiffFiles(collection, repoRoot) {
     ];
     for (const target of diffTargets) {
         recordScanned(collection, "git_diff");
-        const diff = await runGitDiff(target.args, repoRoot);
+        let diff;
+        try {
+            diff = await runGitDiff(target.args, repoRoot);
+        }
+        catch {
+            collection.skipped.push({
+                kind: "git_diff",
+                label: target.label,
+                reason: "git_diff_failed",
+            });
+            continue;
+        }
         if (diff.truncated) {
             markCapApplied(collection, "git_diff", diff.truncationCapType);
             collection.truncated.push({
@@ -686,6 +826,32 @@ function markCapApplied(collection, source, capType) {
     if (cap)
         cap.applied = true;
 }
+function recordSkipCount(collection, source, reason, count) {
+    if (count <= 0)
+        return;
+    collection.skipped.push({
+        kind: source,
+        label: reason,
+        reason,
+        count,
+    });
+}
+function recordTruncationCount(collection, source, reason, count, details = {}) {
+    if (count <= 0)
+        return;
+    collection.truncated.push({
+        kind: source,
+        reason,
+        count,
+        ...details,
+    });
+}
+function evidenceEntryCount(entry) {
+    return entry.count ?? 1;
+}
+function countEvidenceEntries(entries, predicate = () => true) {
+    return entries.reduce((sum, entry) => sum + (predicate(entry) ? evidenceEntryCount(entry) : 0), 0);
+}
 function makeEvidenceCompleteness(collection, options) {
     const sources = new Set(collection.scanned.keys());
     for (const entry of collection.entries)
@@ -696,16 +862,19 @@ function makeEvidenceCompleteness(collection, options) {
         sources.add(entry.kind);
     for (const entry of collection.truncated)
         sources.add(entry.kind);
+    for (const entry of collection.failed)
+        sources.add(entry.kind);
     const sourceCounts = [...sources].sort().map((source) => {
         const skipped = collection.skipped.filter((entry) => entry.kind === source);
         return {
             source,
             scanned_count: collection.scanned.get(source) ?? 0,
             included_count: collection.entries.filter((entry) => entry.kind === source).length,
-            skipped_count: skipped.length,
-            truncated_count: collection.truncated.filter((entry) => entry.kind === source).length,
-            deferred_count: skipped.filter((entry) => entry.reason.startsWith("deferred_")).length,
+            skipped_count: countEvidenceEntries(skipped),
+            truncated_count: countEvidenceEntries(collection.truncated, (entry) => entry.kind === source),
+            deferred_count: countEvidenceEntries(skipped, (entry) => entry.reason.startsWith("deferred_")),
             reused_count: collection.reused.filter((entry) => entry.kind === source).length,
+            failed_count: countEvidenceEntries(collection.failed, (entry) => entry.kind === source),
         };
     });
     const totals = sourceCounts.reduce((sum, count) => ({
@@ -715,6 +884,7 @@ function makeEvidenceCompleteness(collection, options) {
         truncated_count: sum.truncated_count + count.truncated_count,
         deferred_count: sum.deferred_count + count.deferred_count,
         reused_count: sum.reused_count + count.reused_count,
+        failed_count: sum.failed_count + count.failed_count,
     }), {
         scanned_count: 0,
         included_count: 0,
@@ -722,19 +892,35 @@ function makeEvidenceCompleteness(collection, options) {
         truncated_count: 0,
         deferred_count: 0,
         reused_count: 0,
+        failed_count: 0,
     });
     const skipReasonCounts = new Map();
     for (const skipped of collection.skipped) {
         const key = `${skipped.kind}:${skipped.reason}`;
         const existing = skipReasonCounts.get(key);
         if (existing) {
-            existing.count += 1;
+            existing.count += evidenceEntryCount(skipped);
         }
         else {
             skipReasonCounts.set(key, {
                 source: skipped.kind,
                 reason: skipped.reason,
-                count: 1,
+                count: evidenceEntryCount(skipped),
+            });
+        }
+    }
+    const failureReasonCounts = new Map();
+    for (const failed of collection.failed) {
+        const key = `${failed.kind}:${failed.reason}`;
+        const existing = failureReasonCounts.get(key);
+        if (existing) {
+            existing.count += evidenceEntryCount(failed);
+        }
+        else {
+            failureReasonCounts.set(key, {
+                source: failed.kind,
+                reason: failed.reason,
+                count: evidenceEntryCount(failed),
             });
         }
     }
@@ -743,7 +929,7 @@ function makeEvidenceCompleteness(collection, options) {
         const key = `${truncated.kind}:${truncated.reason}`;
         const existing = truncationCounts.get(key);
         if (existing) {
-            existing.count += 1;
+            existing.count += evidenceEntryCount(truncated);
             existing.observed_bytes = Math.max(existing.observed_bytes ?? 0, truncated.observed_bytes ?? 0);
             existing.included_bytes = Math.max(existing.included_bytes ?? 0, truncated.included_bytes ?? 0);
         }
@@ -751,7 +937,7 @@ function makeEvidenceCompleteness(collection, options) {
             truncationCounts.set(key, {
                 source: truncated.kind,
                 reason: truncated.reason,
-                count: 1,
+                count: evidenceEntryCount(truncated),
                 ...(truncated.max_bytes !== undefined
                     ? { max_bytes: truncated.max_bytes }
                     : {}),
@@ -767,12 +953,16 @@ function makeEvidenceCompleteness(collection, options) {
     const hasGaps = totals.skipped_count > 0 ||
         totals.truncated_count > 0 ||
         totals.deferred_count > 0 ||
+        totals.failed_count > 0 ||
         collection.caps.some((cap) => cap.applied);
-    const status = totals.included_count + totals.reused_count === 0 && !hasGaps
-        ? "empty"
-        : hasGaps
-            ? "partial"
-            : "complete";
+    const status = totals.failed_count > 0 &&
+        totals.included_count + totals.reused_count === 0
+        ? "failed"
+        : totals.included_count + totals.reused_count === 0 && !hasGaps
+            ? "empty"
+            : hasGaps
+                ? "partial"
+                : "complete";
     return EvidenceCompletenessPayloadSchema.parse({
         schema_version: "evidence-completeness.v1",
         status,
@@ -786,10 +976,13 @@ function makeEvidenceCompleteness(collection, options) {
         totals,
         caps: collection.caps,
         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}`)),
-        notes: hasGaps
-            ? ["Evidence is incomplete; downstream analysis should lower confidence."]
-            : [],
+        notes: totals.failed_count > 0
+            ? ["Evidence collection failed; downstream analysis should not infer confidence."]
+            : hasGaps
+                ? ["Evidence is incomplete; downstream analysis should lower confidence."]
+                : [],
     });
 }
 async function walkJsonlFiles(dir, cutoffMs) {

package/dist/commands/session-sync.js

@@ -120,7 +120,9 @@ export async function runAttributedWorktreeSync(options) {
                 local_path: result.file_path,
                 codex_session_id: result.codex_session_id,
             })),
+            codexAttributionScan: codexAttribution,
             claudeSessionFiles,
+            claudeAttributionScan: claudeAttribution,
             rawEvidenceBudget,
             fetch: options.fetchImpl,
         };
@@ -480,8 +482,20 @@ function buildAgentSessionSummary(options) {
 function emptyClaudeScan() {
     return {
         results: [],
+        discovered_session_count: 0,
         scanned_session_count: 0,
+        since_minutes: 0,
+        session_limit: 0,
+        session_limit_applied: false,
+        max_file_bytes: 0,
+        max_sidecar_files: 0,
+        max_line_buffer_bytes: 0,
         project_dirs_skipped: 0,
+        project_dir_read_failed_count: 0,
+        session_stat_failed_count: 0,
+        sidecar_dir_read_failed_count: 0,
+        sidecar_stat_failed_count: 0,
+        disabled_reason: "claude_collection_disabled_by_config",
         counts: {
             attributed: 0,
             ambiguous: 0,

package/dist/upload.js

@@ -1,4 +1,4 @@
-import { AgentImageArtifactReportRequestSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
+import { AgentImageArtifactReportRequestSchema, EvidenceCompletenessPayloadSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
 import path from "node:path";
 import { getCollectorRuntimePaths, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, readLocalWorkContextForRepo, } from "./local-state.js";
 import { runLocalSourceCollectors } from "./adapters/local-sources.js";
@@ -62,7 +62,9 @@ export async function buildLocalAmbientEnvelope(options = {}) {
         rawEvidenceIncludeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
         rawEvidenceIncludeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
         rawEvidenceCodexSessionFiles: options.codexSessionFiles,
+        rawEvidenceCodexAttributionScan: options.codexAttributionScan,
         rawEvidenceClaudeSessionFiles: options.claudeSessionFiles,
+        rawEvidenceClaudeAttributionScan: options.claudeAttributionScan,
         rawEvidenceSkipContentHashes: skipContentHashes,
         rawEvidenceByteBudget: options.rawEvidenceByteBudget,
         rawEvidenceObjectBudget: options.rawEvidenceObjectBudget,
@@ -534,12 +536,29 @@ function pruneUndurablePointers(envelope, 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)
         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
+                ? {
+                    ...event.attributes,
+                    evidence_completeness_schema_version: event.evidence_completeness.schema_version,
+                    evidence_completeness_status: "partial",
+                    evidence_incomplete: true,
+                }
+                : event.attributes,
+            evidence_completeness: 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,
@@ -548,6 +567,71 @@ function pruneUndurablePointers(envelope, outcomes) {
         })),
     };
 }
+function markCompletenessUploadFailures(completeness, failedOutcomes) {
+    const failureCounts = new Map();
+    for (const outcome of failedOutcomes) {
+        const source = outcome.kind ?? "raw_evidence";
+        failureCounts.set(source, (failureCounts.get(source) ?? 0) + 1);
+    }
+    const totalFailures = [...failureCounts.values()].reduce((sum, count) => sum + count, 0);
+    const sourceCounts = [...completeness.source_counts];
+    for (const [source, count] of failureCounts) {
+        const existingIndex = sourceCounts.findIndex((entry) => entry.source === source);
+        if (existingIndex === -1) {
+            sourceCounts.push({
+                source,
+                scanned_count: 0,
+                included_count: 0,
+                skipped_count: 0,
+                truncated_count: 0,
+                deferred_count: 0,
+                reused_count: 0,
+                failed_count: count,
+            });
+            continue;
+        }
+        const existing = sourceCounts[existingIndex];
+        if (!existing)
+            continue;
+        sourceCounts[existingIndex] = {
+            ...existing,
+            failed_count: existing.failed_count + count,
+        };
+    }
+    const failureReasons = [...completeness.failure_reasons];
+    for (const [source, count] of failureCounts) {
+        const reason = "upload_failed";
+        const existingIndex = failureReasons.findIndex((entry) => entry.source === source && entry.reason === reason);
+        if (existingIndex === -1) {
+            failureReasons.push({ source, reason, count });
+        }
+        else {
+            const existing = failureReasons[existingIndex];
+            if (existing) {
+                failureReasons[existingIndex] = {
+                    ...existing,
+                    count: existing.count + count,
+                };
+            }
+        }
+    }
+    return EvidenceCompletenessPayloadSchema.parse({
+        ...completeness,
+        status: "partial",
+        source_counts: sourceCounts,
+        totals: {
+            ...completeness.totals,
+            failed_count: completeness.totals.failed_count + totalFailures,
+        },
+        failure_reasons: failureReasons.sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
+        notes: [
+            ...new Set([
+                ...completeness.notes,
+                "Some collected evidence did not become durable; downstream analysis should lower confidence.",
+            ]),
+        ],
+    });
+}
 function makeUploadWorkContext(options) {
     const provenance = makeCollectorProvenance({
         context: options.activeContext,
@@ -624,6 +708,7 @@ function makeSourceScanCompletedEvent(options) {
             evidence_truncated_count: evidenceCompleteness?.totals.truncated_count ?? 0,
             evidence_deferred_count: evidenceCompleteness?.totals.deferred_count ?? 0,
             evidence_reused_count: evidenceCompleteness?.totals.reused_count ?? 0,
+            evidence_failed_count: evidenceCompleteness?.totals.failed_count ?? 0,
         },
         attributes: {
             repo_label: options.context.repo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "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.6"
+    "@bli-cockpit/telemetry-core": "0.1.7"
   }
 }