@bli-cockpit/cli 0.1.28 → 0.1.30

package/dist/commands/session-sync.js

@@ -6,11 +6,13 @@
 import os from "node:os";
 import path from "node:path";
 import { getCollectorRuntimePaths, startLocalWorkContext, readLocalCollectorConfig } from "../local-state.js";
+import { CODEX_SESSION_ATTRIBUTION_STATE_RANK, } from "@bli-cockpit/telemetry-core";
 import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope } from "../upload.js";
-import { CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT, CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
+import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
 const CLAUDE_FIRST_RUN_BACKFILL_MINUTES = 14 * 24 * 60;
 const CLAUDE_DAMP_GROWTH_BYTES = 256 * 1024;
 const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
@@ -28,13 +30,16 @@ export async function runAttributedWorktreeSync(options) {
     const now = new Date();
     const homeDir = options.homeDir ?? os.homedir();
     const paths = getCollectorRuntimePaths(options.homeDir);
-    const claudeEnabled = await isClaudeCollectionEnabled(paths);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    const claudeEnabled = config?.collect_claude_jsonl !== false;
+    const collectionRoots = fallbackCollectionRoots(config?.default_repo_paths ?? [], options.worktrees);
     const codexAttribution = await scanAndAttributeCodexSessions({
         sessionsDirs: defaultCodexSessionDirs(homeDir),
         worktrees: options.worktrees,
         now,
-        sinceMinutes: CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES,
-        limit: CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT,
+        sinceMinutes: CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
+        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
+        collectionRoots,
     });
     // First run (D B.4 §8): without a Claude cursor yet, widen the window to 14
     // days so the first sync captures retroactive history instead of only 24h.
@@ -45,6 +50,7 @@ export async function runAttributedWorktreeSync(options) {
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees: options.worktrees,
             now,
+            collectionRoots,
             sinceMinutes: firstRunBackfill
                 ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
                 : undefined,
@@ -114,6 +120,7 @@ export async function runAttributedWorktreeSync(options) {
             homeDir: options.homeDir,
             repoRoot: worktree.repo_root,
             dashboardUrl: options.dashboardUrl,
+            worktreeInventory: worktreeInventoryForRepo(worktree, options.worktrees),
             codexSessionFiles: codexAttribution.results
                 .filter((result) => result.state === "attributed" &&
                 result.worktree?.worktree_fingerprint ===
@@ -227,12 +234,7 @@ export async function runAttributedWorktreeSync(options) {
     });
     return { ok, outcomes, codexAttribution, claudeAttribution, summary };
 }
-const ATTRIBUTION_STATE_RANK = {
-    attributed: 3,
-    ambiguous: 2,
-    unattributed: 1,
-    skipped: 0,
-};
+export const ATTRIBUTION_STATE_RANK = CODEX_SESSION_ATTRIBUTION_STATE_RANK;
 function normalizeCodexResult(result) {
     return {
         source: "codex",
@@ -357,7 +359,8 @@ function buildAgentSessionReport(options) {
                         raw_evidence_pointer_id: priorDurablePointer,
                         upload_state: "reused_existing",
                     }
-                    : result.state === "attributed"
+                    : result.state === "attributed" ||
+                        result.state === "attributed_fallback"
                         ? { upload_state: "not_uploaded" }
                         : {}),
         };
@@ -441,6 +444,7 @@ function buildAgentSessionSummary(options) {
     const codex = {
         scanned: options.codexAttribution.scanned_file_count,
         attributed: options.codexAttribution.counts.attributed,
+        attributed_fallback: options.codexAttribution.counts.attributed_fallback,
         ambiguous: options.codexAttribution.counts.ambiguous,
         unattributed: options.codexAttribution.counts.unattributed,
         skipped: options.codexAttribution.counts.skipped,
@@ -449,6 +453,7 @@ function buildAgentSessionSummary(options) {
     const claude = {
         scanned: options.claudeAttribution.scanned_session_count,
         attributed: options.claudeAttribution.counts.attributed,
+        attributed_fallback: options.claudeAttribution.counts.attributed_fallback,
         ambiguous: options.claudeAttribution.counts.ambiguous,
         unattributed: options.claudeAttribution.counts.unattributed,
         skipped: options.claudeAttribution.counts.skipped,
@@ -469,6 +474,7 @@ function buildAgentSessionSummary(options) {
     return {
         scanned: codex.scanned,
         attributed: codex.attributed,
+        attributed_fallback: codex.attributed_fallback,
         ambiguous: codex.ambiguous,
         unattributed: codex.unattributed,
         skipped: codex.skipped,
@@ -500,6 +506,7 @@ function emptyClaudeScan() {
         disabled_reason: "claude_collection_disabled_by_config",
         counts: {
             attributed: 0,
+            attributed_fallback: 0,
             ambiguous: 0,
             unattributed: 0,
             skipped: 0,
@@ -510,9 +517,28 @@ function emptyClaudeScan() {
         },
     };
 }
-async function isClaudeCollectionEnabled(paths) {
-    const config = await readLocalCollectorConfig(paths).catch(() => null);
-    return config?.collect_claude_jsonl !== false;
+function worktreeInventoryForRepo(current, worktrees) {
+    return worktrees
+        .filter((worktree) => worktree.repo_fingerprint
+        ? worktree.repo_fingerprint === current.repo_fingerprint
+        : worktree.repo_label === current.repo_label)
+        .map((worktree) => ({
+        repo: worktree.repo_root,
+        repo_label: worktree.repo_label,
+        repo_fingerprint: worktree.repo_fingerprint,
+        repo_origin_url: worktree.repo_origin_url ?? undefined,
+        head_sha: worktree.head_sha ?? undefined,
+        worktree_label: worktree.worktree_label,
+        worktree_fingerprint: worktree.worktree_fingerprint,
+        worktree_is_primary: worktree.worktree_is_primary,
+        branch: worktree.branch,
+    }));
+}
+function fallbackCollectionRoots(savedRoots, worktrees) {
+    return normalizeCollectionRoots([
+        ...savedRoots,
+        ...worktrees.map((worktree) => worktree.requested_path || worktree.repo_root),
+    ]);
 }
 async function fileExists(filePath) {
     const { stat } = await import("node:fs/promises");

package/dist/cursors/backfill-cursor.js

@@ -0,0 +1,130 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export const BACKFILL_CURSOR_FILENAME = "backfill.json";
+export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
+export function emptyBackfillCursorState() {
+    return {
+        schema_version: "cockpit-backfill-cursor.v1",
+        updated_at: null,
+        sources: {
+            codex: emptySourceCursor(),
+            claude_code: emptySourceCursor(),
+        },
+    };
+}
+export async function readBackfillCursor(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(backfillCursorPath(paths), "utf8"));
+        return parseBackfillCursor(raw);
+    }
+    catch {
+        return emptyBackfillCursorState();
+    }
+}
+export async function writeBackfillCursor(paths, state) {
+    const filePath = backfillCursorPath(paths);
+    await writePrivateJson(filePath, state);
+}
+export async function writeBackfillCompletionMarker(paths, marker) {
+    await writePrivateJson(backfillCompletionMarkerPath(paths), marker);
+}
+export function recordBackfillCursorObservations(cursor, observations, now) {
+    for (const observation of observations) {
+        const source = cursor.sources[observation.source] ?? emptySourceCursor();
+        const oldest = source.oldest_mtime_ms_processed;
+        if (oldest === null ||
+            observation.session_file_mtime_ms < oldest) {
+            source.oldest_mtime_ms_processed = observation.session_file_mtime_ms;
+            source.oldest_mtime_processed = observation.session_file_mtime;
+        }
+        source.state_counts[observation.state] =
+            (source.state_counts[observation.state] ?? 0) + 1;
+        source.reason_counts[observation.reason] =
+            (source.reason_counts[observation.reason] ?? 0) + 1;
+        cursor.sources[observation.source] = source;
+    }
+    cursor.updated_at = now.toISOString();
+}
+export function backfillCursorPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_CURSOR_FILENAME);
+}
+export function backfillCompletionMarkerPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
+}
+function emptySourceCursor() {
+    return {
+        oldest_mtime_ms_processed: null,
+        oldest_mtime_processed: null,
+        state_counts: {},
+        reason_counts: {},
+    };
+}
+function parseBackfillCursor(value) {
+    if (!value || typeof value !== "object")
+        return emptyBackfillCursorState();
+    const record = value;
+    const sources = record["sources"];
+    const parsed = emptyBackfillCursorState();
+    parsed.updated_at = optionalString(record["updated_at"]);
+    if (sources && typeof sources === "object") {
+        const sourceRecord = sources;
+        parsed.sources.codex = parseSourceCursor(sourceRecord["codex"]);
+        parsed.sources.claude_code = parseSourceCursor(sourceRecord["claude_code"]);
+    }
+    return parsed;
+}
+function parseSourceCursor(value) {
+    if (!value || typeof value !== "object")
+        return emptySourceCursor();
+    const record = value;
+    const oldest = optionalNumber(record["oldest_mtime_ms_processed"]);
+    return {
+        oldest_mtime_ms_processed: oldest,
+        oldest_mtime_processed: optionalString(record["oldest_mtime_processed"]) ??
+            (oldest === null ? null : new Date(oldest).toISOString()),
+        state_counts: parseNumberRecord(record["state_counts"]),
+        reason_counts: parseNumberRecord(record["reason_counts"]),
+    };
+}
+function parseNumberRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+            out[key] = Math.floor(raw);
+        }
+    }
+    return out;
+}
+async function writePrivateJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+    const serialized = `${JSON.stringify(value, null, 2)}\n`;
+    let handle = null;
+    try {
+        handle = await fs.open(tempPath, "w", 0o600);
+        await handle.writeFile(serialized);
+        await handle.sync();
+    }
+    finally {
+        await handle?.close();
+    }
+    try {
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    if (process.platform !== "win32") {
+        await fs.chmod(filePath, 0o600).catch(() => undefined);
+    }
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/local-state.js

@@ -4,7 +4,7 @@ import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { resolveRepoWorktreeIdentity, } from "./repo-identity.js";
+import { resolveRepoWorktreeIdentity, stableWorktreeFingerprint, stableWorktreeRoot, } from "./repo-identity.js";
 import { normalizeCollectionRoots } from "./root-normalization.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
 const localCollectorPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -138,6 +138,9 @@ export async function logoutLocalCollector(options = {}) {
     return { removed, session_file: paths.session_file };
 }
 export async function startLocalWorkContext(options = {}) {
+    if (options.activeTicketId && options.clearTicket) {
+        throw new Error("--ticket and --clear-ticket cannot be combined.");
+    }
     const now = options.now ?? new Date();
     const homeDir = options.homeDir ?? os.homedir();
     const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
@@ -161,6 +164,9 @@ export async function startLocalWorkContext(options = {}) {
         worktreeFingerprint: identity.worktree_fingerprint,
     });
     const existingContext = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
+    const activeTicketId = options.clearTicket
+        ? undefined
+        : (options.activeTicketId ?? existingContext?.active_ticket_id);
     const ticketBindingCandidates = options.activeTicketId
         ? [
             {
@@ -170,7 +176,9 @@ export async function startLocalWorkContext(options = {}) {
                 evidence_labels: ["cockpit_start_ticket"],
             },
         ]
-        : [];
+        : options.clearTicket
+            ? []
+            : (existingContext?.ticket_binding_candidates ?? []);
     const context = LocalWorkContextSchema.parse({
         work_context_id: workContextId,
         repo: identity.repo_root,
@@ -186,7 +194,7 @@ export async function startLocalWorkContext(options = {}) {
         session_id: sessionId,
         started_at: existingContext?.started_at ?? now.toISOString(),
         updated_at: now.toISOString(),
-        active_ticket_id: options.activeTicketId ?? undefined,
+        active_ticket_id: activeTicketId,
         ticket_binding_candidates: ticketBindingCandidates,
         topic_label: options.topicLabel,
         topic_summary_redacted: options.topicSummaryRedacted,
@@ -229,8 +237,8 @@ export async function inspectLocalCollectorStatus(options = {}) {
     const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
     const context = await readLocalWorkContextForRepo(paths, repoRoot).catch(() => null);
     const branch = options.branch ?? identity.branch;
-    const freshness = classifyCollectorFreshness(context, now);
     const uploadSpool = await summarizeLocalUploadSpool(paths);
+    const freshness = classifyCollectorFreshness(context, uploadSpool.last_upload_success_at, now);
     const uploadState = !config
         ? "not_installed"
         : uploadSpool.pending_upload_count > 0
@@ -381,14 +389,14 @@ function workContextFile(paths, worktreeFingerprint) {
     return path.join(paths.work_contexts_dir, `${worktreeFingerprint}.json`);
 }
 async function resolveIdentityOrFallback(repoRoot, branchOverride) {
-    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedRoot = await stableWorktreeRoot(repoRoot);
     const identity = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
     if (identity) {
         return branchOverride ? { ...identity, branch: branchOverride } : identity;
     }
     const repoLabel = path.basename(resolvedRoot) || "workspace";
     const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
-    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
+    const worktreeFingerprint = stableWorktreeFingerprint(resolvedRoot);
     const branch = branchOverride ?? (await resolveGitBranch(resolvedRoot));
     return {
         requested_path: resolvedRoot,
@@ -426,13 +434,24 @@ async function writeJsonFile(filePath, value) {
         await fs.chmod(filePath, 0o600).catch(() => undefined);
     }
 }
-function classifyCollectorFreshness(context, now) {
+export function classifyCollectorFreshness(context, lastUploadSuccessAt, now) {
     if (!context)
         return "missing";
-    const updatedAt = Date.parse(context.updated_at ?? context.started_at);
-    if (!Number.isFinite(updatedAt))
+    const latestActivityAt = latestTimestamp([
+        context.updated_at ?? context.started_at,
+        lastUploadSuccessAt,
+    ]);
+    if (latestActivityAt === null)
         return "stale";
-    return now.getTime() - updatedAt <= 5 * 60 * 1000 ? "fresh" : "stale";
+    return now.getTime() - latestActivityAt <= 5 * 60 * 1000 ? "fresh" : "stale";
+}
+function latestTimestamp(values) {
+    const timestamps = values
+        .map((value) => Date.parse(value ?? ""))
+        .filter((value) => Number.isFinite(value));
+    if (timestamps.length === 0)
+        return null;
+    return Math.max(...timestamps);
 }
 function normalizeDashboardUrl(value) {
     const normalized = value.trim().replace(/\/+$/, "");

package/dist/repo-identity.js

@@ -18,7 +18,7 @@ const SKIPPED_DIR_NAMES = new Set([
 export async function resolveRepoWorktreeIdentity(repoRoot) {
     const requestedPath = path.resolve(repoRoot);
     const gitRoot = await runGit(["rev-parse", "--show-toplevel"], requestedPath);
-    const resolvedRoot = path.resolve(gitRoot.trim() || requestedPath);
+    const resolvedRoot = await stableWorktreeRoot(gitRoot.trim() || requestedPath);
     const branch = await resolveGitBranchWithGit(resolvedRoot);
     const headSha = await runGit(["rev-parse", "HEAD"], resolvedRoot).then((value) => value.trim() || null, () => null);
     const absoluteGitDir = await runGit(["rev-parse", "--absolute-git-dir"], resolvedRoot)
@@ -36,11 +36,6 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
         ? `origin:${repoOriginUrl}`
         : `local:${sha256(commonGitDir ?? resolvedRoot)}`;
     const repoFingerprint = `repo-${sha256(repoMaterial).slice(0, 24)}`;
-    const worktreeMaterial = [
-        repoFingerprint,
-        resolvedRoot,
-        commonGitDir ?? "",
-    ].join("\n");
     const gitFilePath = path.join(resolvedRoot, ".git");
     const worktreeIsPrimary = await fs.stat(gitFilePath).then((stat) => stat.isDirectory(), () => false);
     return {
@@ -52,7 +47,7 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
         branch,
         head_sha: headSha,
         worktree_label: path.basename(resolvedRoot),
-        worktree_fingerprint: `wt-${sha256(worktreeMaterial).slice(0, 24)}`,
+        worktree_fingerprint: stableWorktreeFingerprint(resolvedRoot),
         worktree_is_primary: worktreeIsPrimary,
     };
 }
@@ -144,10 +139,9 @@ async function hasGitMarker(dir) {
     return fs.stat(path.join(dir, ".git")).then((stat) => stat.isDirectory() || stat.isFile(), () => false);
 }
 async function fallbackFilesystemIdentity(repoRoot) {
-    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedRoot = await stableWorktreeRoot(repoRoot);
     const repoLabel = path.basename(resolvedRoot) || "repo";
     const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
-    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
     return {
         requested_path: resolvedRoot,
         repo_root: resolvedRoot,
@@ -157,10 +151,17 @@ async function fallbackFilesystemIdentity(repoRoot) {
         branch: await resolveBranchFromHead(resolvedRoot),
         head_sha: null,
         worktree_label: repoLabel,
-        worktree_fingerprint: worktreeFingerprint,
+        worktree_fingerprint: stableWorktreeFingerprint(resolvedRoot),
         worktree_is_primary: true,
     };
 }
+export async function stableWorktreeRoot(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    return fs.realpath(resolvedRoot).catch(() => resolvedRoot);
+}
+export function stableWorktreeFingerprint(repoRoot) {
+    return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot)}`).slice(0, 24)}`;
+}
 async function resolveBranchFromHead(repoRoot) {
     try {
         const gitPath = path.join(repoRoot, ".git");
@@ -244,6 +245,10 @@ async function runGit(args, cwd) {
     });
     return stdout;
 }
+function normalizeFingerprintPath(repoRoot) {
+    const resolved = path.resolve(repoRoot);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
 function sha256(value) {
     return crypto.createHash("sha256").update(value, "utf8").digest("hex");
 }

package/dist/upload.js

@@ -1,4 +1,4 @@
-import { AgentImageArtifactReportRequestSchema, EvidenceCompletenessPayloadSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
+import { AgentImageArtifactReportRequestSchema, CODEX_SESSION_REPORT_MAX_SESSIONS, CodexSessionAttributionReportResponseSchema, 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";
@@ -101,6 +101,7 @@ export async function buildLocalAmbientEnvelope(options = {}) {
         collector_version: LOCAL_COLLECTOR_VERSION,
         session_reference: sanitizeSessionReference(session),
         work_context: uploadWorkContext,
+        worktree_inventory: options.worktreeInventory ?? [],
         source_scan_results: sanitizeSourceScanResults(sourceCollection.scans, repoLabel),
         events,
     });
@@ -278,7 +279,7 @@ export async function syncLocalAmbientEnvelope(options = {}) {
  */
 export async function postCodexSessionReport(options) {
     if (options.sessions.length === 0) {
-        return { posted: false, reason: "no_sessions_observed" };
+        return emptyCodexSessionReportResult("no_sessions_observed");
     }
     const fetchImpl = options.fetch ?? globalThis.fetch;
     if (!fetchImpl) {
@@ -290,7 +291,7 @@ export async function postCodexSessionReport(options) {
         const sessionFile = await readLocalCollectorSessionFile(paths);
         const session = await readLocalSessionReference(paths);
         if (session.session_state !== "valid") {
-            return { posted: false, reason: "collector_not_paired" };
+            return emptyCodexSessionReportResult("collector_not_paired");
         }
         const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
         const activeContext = await readLocalWorkContextForRepo(paths, repoRoot);
@@ -315,7 +316,7 @@ export async function postCodexSessionReport(options) {
         });
     }
     catch {
-        return { posted: false, reason: "collector_not_ready" };
+        return emptyCodexSessionReportResult("collector_not_ready");
     }
 }
 /**
@@ -325,33 +326,122 @@ export async function postCodexSessionReport(options) {
  */
 export async function reportCodexSessionAttributions(options) {
     if (options.sessions.length === 0) {
-        return { posted: false, reason: "no_sessions_observed" };
+        return emptyCodexSessionReportResult("no_sessions_observed");
     }
-    try {
-        const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/codex-sessions`, {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${options.deviceToken}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                schema_version: "ambient-codex-session-attributions.v1",
-                generated_at: options.generatedAt,
-                provenance: options.provenance,
-                sessions: options.sessions,
-            }),
+    const chunks = [];
+    const sessionChunks = chunkArray(options.sessions, CODEX_SESSION_REPORT_MAX_SESSIONS);
+    for (const [index, sessions] of sessionChunks.entries()) {
+        const chunk = await postCodexSessionAttributionChunk({
+            ...options,
+            sessions,
+            batchIndex: index + 1,
         });
-        if (response.status === 404) {
-            return { posted: false, reason: "codex_session_api_unavailable" };
+        chunks.push(chunk);
+    }
+    const failedCount = chunks.filter((chunk) => !chunk.posted).length;
+    const recordedCount = chunks.reduce((sum, chunk) => sum + chunk.recorded_count, 0);
+    return {
+        posted: failedCount === 0,
+        reason: failedCount === 0
+            ? "recorded"
+            : chunks.find((chunk) => !chunk.posted)?.reason ?? "report_failed",
+        chunk_count: chunks.length,
+        recorded_count: recordedCount,
+        failed_count: failedCount,
+        chunks,
+    };
+}
+async function postCodexSessionAttributionChunk(options) {
+    const maxAttempts = options.maxAttemptsPerRequest ?? 3;
+    const sleep = options.sleep ?? defaultReportSleep;
+    let lastStatus = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/codex-sessions`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${options.deviceToken}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    schema_version: "ambient-codex-session-attributions.v1",
+                    generated_at: options.generatedAt,
+                    provenance: options.provenance,
+                    sessions: options.sessions,
+                }),
+            });
+            lastStatus = response.status;
+            const body = await readResponseJson(response);
+            if (response.status === 404) {
+                return codexSessionReportChunkResult(options, {
+                    posted: false,
+                    reason: "codex_session_api_unavailable",
+                    httpStatus: response.status,
+                    recordedCount: 0,
+                });
+            }
+            if (response.ok) {
+                const parsed = CodexSessionAttributionReportResponseSchema.safeParse(body);
+                return codexSessionReportChunkResult(options, {
+                    posted: true,
+                    reason: "recorded",
+                    httpStatus: response.status,
+                    recordedCount: parsed.success ? parsed.data.recorded_count : 0,
+                });
+            }
+            if (response.status < 500 && response.status !== 429) {
+                return codexSessionReportChunkResult(options, {
+                    posted: false,
+                    reason: `report_failed_http_${response.status}`,
+                    httpStatus: response.status,
+                    recordedCount: 0,
+                });
+            }
         }
-        if (!response.ok) {
-            return { posted: false, reason: `report_failed_http_${response.status}` };
+        catch {
+            lastStatus = null;
         }
-        return { posted: true, reason: "recorded" };
+        if (attempt < maxAttempts)
+            await sleep(250 * attempt);
     }
-    catch {
-        return { posted: false, reason: "report_network_error" };
+    return codexSessionReportChunkResult(options, {
+        posted: false,
+        reason: lastStatus === null
+            ? "report_network_error"
+            : `report_failed_http_${lastStatus}`,
+        httpStatus: lastStatus,
+        recordedCount: 0,
+    });
+}
+function codexSessionReportChunkResult(options, result) {
+    return {
+        batch_index: options.batchIndex,
+        session_count: options.sessions.length,
+        posted: result.posted,
+        reason: result.reason,
+        http_status: result.httpStatus,
+        recorded_count: result.recordedCount,
+    };
+}
+function emptyCodexSessionReportResult(reason) {
+    return {
+        posted: false,
+        reason,
+        chunk_count: 0,
+        recorded_count: 0,
+        failed_count: 0,
+        chunks: [],
+    };
+}
+function chunkArray(items, size) {
+    const chunks = [];
+    for (let offset = 0; offset < items.length; offset += size) {
+        chunks.push(items.slice(offset, offset + size));
     }
+    return chunks;
+}
+function defaultReportSleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 export async function reportAgentImageArtifacts(options) {
     const artifacts = agentArtifactsFromEvidence(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "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.8"
+    "@bli-cockpit/telemetry-core": "0.1.10"
   }
 }