@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/upload-evidence-delivery-summary.js

@@ -95,18 +95,9 @@ export function hasRetryableEvidenceGap(facts, outcomes) {
     return facts.evidence_completeness.skip_reasons.some(({ reason }) => isRetryableEvidenceSkipReason(reason));
 }
 /**
- * Skip reasons a later sync can still turn into evidence.
- *
- * `delivery_backoff_holding` is one of them, and it has to be: a source held by
- * backoff is missing collection right now. If it did not land here the sync
- * would read clean while a transcript sat undelivered for nine days, which is
- * the exact shape of BLI-3066.
- *
- * BLI-4022 did NOT change that. A hold still queues the retry and still travels
- * to the status output; what changed is downstream, at the ledger in
- * `commands/session-sync-failures.ts`, which no longer files it as a FAILED
- * tick. Retryable and failed are two questions, and answering both with this
- * one set is what painted a collecting machine red for eight ticks.
+ * Queue retries for collection skips a later sync can rescue, including backoff.
+ * Retryable and failed are separate questions: a hold remains missing evidence
+ * without making the scheduled tick itself a failed attempt.
  */
 function isRetryableEvidenceSkipReason(reason) {
     if (reason === DELIVERY_BACKOFF_HOLDING_REASON)
@@ -158,17 +149,7 @@ export function summarizeRawEvidenceDelivery(built, outcomes, uploadedChunkCount
     const retryReason = retryRequired
         ? retryableEvidenceGapReason(built.raw_evidence_facts, outcomes)
         : null;
-    const cursorReusedOutcomes = cursorReused.map((entry) => ({
-        object_key: cursor.objects[entry.content_hash_sha256]?.object_key ?? "",
-        raw_evidence_pointer_id: cursor.objects[entry.content_hash_sha256]?.object_key ?? "",
-        kind: entry.kind,
-        codex_session_id: entry.codex_session_id,
-        ...(entry.artifact_metadata
-            ? { artifact_metadata: entry.artifact_metadata }
-            : {}),
-        upload_state: "reused_existing",
-        reason: "cursor_content_match",
-    }));
+    const cursorReusedOutcomes = summarizeCursorReuse(cursorReused, cursor);
     return {
         raw_evidence_file_count: built.raw_evidence_upload_files.length,
         raw_evidence_uploaded_object_count: outcomes.filter((outcome) => outcome.upload_state === "uploaded").length,
@@ -188,17 +169,7 @@ export function summarizeRawEvidenceDelivery(built, outcomes, uploadedChunkCount
                 .filter(Boolean)
             : [],
         raw_evidence_outcomes: [
-            ...outcomes.map((outcome) => ({
-                object_key: outcome.object_key,
-                raw_evidence_pointer_id: outcome.pointer.raw_evidence_pointer_id,
-                kind: outcome.kind,
-                codex_session_id: outcome.codex_session_id,
-                ...(outcome.artifact_metadata
-                    ? { artifact_metadata: outcome.artifact_metadata }
-                    : {}),
-                upload_state: outcome.upload_state,
-                reason: outcome.reason,
-            })),
+            ...outcomes.map(summarizeUploadOutcome),
             ...cursorReusedOutcomes,
         ],
         raw_evidence_deferred_byte_budget: built.raw_evidence_facts?.deferred_byte_budget_count ?? 0,
@@ -212,4 +183,31 @@ export function summarizeRawEvidenceDelivery(built, outcomes, uploadedChunkCount
         raw_evidence_held_next_attempt_at: stuck.held_next_attempt_at,
         raw_evidence_held_last_reason: stuck.held_last_reason,
     };
+}
+function summarizeUploadOutcome(outcome) {
+    return {
+        object_key: outcome.object_key,
+        raw_evidence_pointer_id: outcome.pointer.raw_evidence_pointer_id,
+        kind: outcome.kind,
+        codex_session_id: outcome.codex_session_id,
+        ...(outcome.artifact_metadata
+            ? { artifact_metadata: outcome.artifact_metadata }
+            : {}),
+        upload_state: outcome.upload_state,
+        reason: outcome.reason,
+    };
+}
+function summarizeCursorReuse(cursorReused, cursor) {
+    const cursorReusedOutcomes = cursorReused.map((entry) => ({
+        object_key: cursor.objects[entry.content_hash_sha256]?.object_key ?? "",
+        raw_evidence_pointer_id: cursor.objects[entry.content_hash_sha256]?.object_key ?? "",
+        kind: entry.kind,
+        codex_session_id: entry.codex_session_id,
+        ...(entry.artifact_metadata
+            ? { artifact_metadata: entry.artifact_metadata }
+            : {}),
+        upload_state: "reused_existing",
+        reason: "cursor_content_match",
+    }));
+    return cursorReusedOutcomes;
 }

package/dist/upload-ingest-receipt.js

@@ -51,31 +51,12 @@ export async function postEnvelopeToIngest(options) {
     return response;
 }
 /**
- * The receipt that proves ingest persisted exactly what was submitted.
- *
- * Anything short of a 202 whose counts match the envelope's own totals is
- * treated as no receipt at all — a proxy's 200, a truncated body, or a
- * dashboard that accepted fewer rows than were sent all land here. They used to
- * land here under the SAME sentence, which is the BLI-3483 complaint: a
- * network appliance answering on the dashboard's behalf and a dashboard that
- * genuinely persisted three of four rows are opposite repairs. They are now two
- * reasons, and the second one names the field that disagreed and by how much.
+ * Advance retry state only for a 202 receipt matching every submitted count.
+ * Distinguish proxy/unreadable replies from partial persistence, naming each
+ * mismatched field and its submitted/received counts.
  */
 function assertAmbientIngestReceipt(response, value, envelope) {
-    if (response.status !== 202 || !value || typeof value !== "object") {
-        const detail = response.status !== 202
-            ? `http ${response.status}; the ingest route answers 202, so something in front of it replied`
-            : "202 with a body that is not an object";
-        console.error("[cockpit-sync] ingest answered without a durable receipt", JSON.stringify({
-            reason: "ingest_receipt_not_202",
-            http_status: response.status,
-            body_is_object: Boolean(value) && typeof value === "object",
-        }));
-        throw new SyncDeliveryError("ingest_receipt_not_202", {
-            httpStatus: response.status,
-            detail,
-        });
-    }
+    assertReceiptResponse(response, value);
     const record = value;
     const ingest = record["ingest"] && typeof record["ingest"] === "object"
         ? record["ingest"]
@@ -107,6 +88,22 @@ function assertAmbientIngestReceipt(response, value, envelope) {
         detail: mismatches.join("; "),
     });
 }
+function assertReceiptResponse(response, value) {
+    if (response.status !== 202 || !value || typeof value !== "object") {
+        const detail = response.status !== 202
+            ? `http ${response.status}; the ingest route answers 202, so something in front of it replied`
+            : "202 with a body that is not an object";
+        console.error("[cockpit-sync] ingest answered without a durable receipt", JSON.stringify({
+            reason: "ingest_receipt_not_202",
+            http_status: response.status,
+            body_is_object: Boolean(value) && typeof value === "object",
+        }));
+        throw new SyncDeliveryError("ingest_receipt_not_202", {
+            httpStatus: response.status,
+            detail,
+        });
+    }
+}
 /**
  * `submitted 4, receipt 3` — the sentence that tells partial persistence from a
  * receipt that never carried the field at all. Counts are numbers this

package/dist/upload-session-reports-queue.js

@@ -66,8 +66,11 @@ export async function flushPendingCodexSessionReports(options) {
     if (session.session_state !== "valid") {
         return await failPendingSessionReports(paths, state.pending_session_reports, attemptedAt, "collector_not_paired");
     }
+    return drainSessionReports(options, paths, state.pending_session_reports, sessionFile, session, attemptedAt, fetchImpl);
+}
+async function drainSessionReports(options, paths, pendingReports, sessionFile, session, attemptedAt, fetchImpl) {
     const results = [];
-    for (const pending of state.pending_session_reports) {
+    for (const pending of pendingReports) {
         const result = await reportCodexSessionAttributions({
             fetchImpl,
             dashboardUrl: normalizeDashboardUrl(pending.dashboard_url || sessionFile.dashboard_url),

package/dist/upload-session-reports-wire.js

@@ -1,14 +1,6 @@
 /**
- * The wire: posting Codex session attribution rows and reading back a receipt.
- *
- * - `postCodexSessionReport` — the one-shot path, for a harvest that already
- *   has a repo in hand; builds its own provenance and posts immediately.
- * - `reportCodexSessionAttributions` — chunk at the endpoint's session cap,
- *   then attempt each chunk under `postCodexSessionAttributionChunk`'s
- *   decision table of "final answer" versus "worth another attempt".
- *
- * `upload-session-reports-queue.ts` calls `reportCodexSessionAttributions`
- * once per queued report; nothing here touches the durable queue.
+ * Deliver attribution chunks with bounded retries and complete acknowledgements.
+ * HTTP refusals and transport failures retain distinct reason/status metadata.
  */
 import { CODEX_SESSION_REPORT_MAX_SESSIONS, CodexSessionAttributionReportResponseSchema, } from "@bli-cockpit/telemetry-core";
 import path from "node:path";
@@ -111,21 +103,9 @@ export async function reportCodexSessionAttributions(options) {
     };
 }
 /**
- * One chunk, up to three attempts, as a decision table on what came back:
- *
- * | what came back                      | verdict                                |
- * |-------------------------------------|----------------------------------------|
- * | 404                                 | this dashboard has no endpoint; stop    |
- * | 2xx with a readable, full receipt    | recorded; stop                         |
- * | 2xx malformed or short of the count  | keep the reason, try again             |
- * | 4xx other than 429                   | the server's final answer; stop         |
- * | 429 or 5xx                          | keep the reason, try again             |
- * | transport error                      | keep the reason, try again, no status  |
- *
- * The row that looks wrong is the third one, and it is the important one: a 2xx
- * we cannot read is retried because the server may have died between persisting
- * the rows and answering. Only a schema-valid receipt that accounts for every
- * distinct session is safe to delete a durable pending report against.
+ * Retry a chunk up to three times: 404 or final 4xx stops; 429, 5xx, transport
+ * errors and unreadable/short 2xx receipts retry. Only a schema-valid receipt
+ * covering every distinct session permits removal of the durable queued report.
  */
 async function postCodexSessionAttributionChunk(options) {
     const maxAttempts = options.maxAttemptsPerRequest ?? DEFAULT_REPORT_ATTEMPTS;
@@ -138,51 +118,13 @@ async function postCodexSessionAttributionChunk(options) {
             const response = await postSessionAttributionRequest(options);
             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 receipt = readSessionReportReceipt(body, requiredAcknowledgements);
-                if (receipt.accepted) {
-                    return codexSessionReportChunkResult(options, {
-                        posted: true,
-                        reason: "recorded",
-                        httpStatus: response.status,
-                        recordedCount: receipt.recorded_count,
-                    });
-                }
-                lastFailureReason = receipt.reason;
-            }
-            else {
-                lastFailureReason = `report_failed_http_${response.status}`;
-                if (isFinalHttpFailure(response.status)) {
-                    return codexSessionReportChunkResult(options, {
-                        posted: false,
-                        reason: lastFailureReason,
-                        httpStatus: response.status,
-                        recordedCount: 0,
-                    });
-                }
-            }
+            const decision = decideSessionReportResponse(options, response, body, requiredAcknowledgements);
+            if (decision.result)
+                return decision.result;
+            lastFailureReason = decision.reason;
         }
         catch (error) {
-            // Logged per attempt, on purpose: the interesting failure is the one
-            // that repeats. Three identical ECONNRESETs and one DNS failure followed
-            // by two resets are different stories, and `report_network_error` alone
-            // tells neither (BLI-3238).
-            console.error("[session-reports] report attempt failed before a status came back", JSON.stringify({
-                reason: "report_network_error",
-                attempt,
-                max_attempts: maxAttempts,
-                batch_index: options.batchIndex,
-                session_count: options.sessions.length,
-                ...describeError(error),
-            }));
+            logSessionReportTransportFailure(options, error, attempt, maxAttempts);
             lastStatus = null;
             lastFailureReason = "report_network_error";
         }
@@ -200,6 +142,60 @@ async function postCodexSessionAttributionChunk(options) {
         recordedCount: 0,
     });
 }
+function decideSessionReportResponse(options, response, body, requiredAcknowledgements) {
+    if (response.status === 404) {
+        return {
+            result: codexSessionReportChunkResult(options, {
+                posted: false,
+                reason: "codex_session_api_unavailable",
+                httpStatus: response.status,
+                recordedCount: 0,
+            })
+        };
+    }
+    if (response.ok) {
+        const receipt = readSessionReportReceipt(body, requiredAcknowledgements);
+        if (receipt.accepted) {
+            return {
+                result: codexSessionReportChunkResult(options, {
+                    posted: true,
+                    reason: "recorded",
+                    httpStatus: response.status,
+                    recordedCount: receipt.recorded_count,
+                })
+            };
+        }
+        return { reason: receipt.reason };
+    }
+    else {
+        const reason = `report_failed_http_${response.status}`;
+        if (isFinalHttpFailure(response.status)) {
+            return {
+                result: codexSessionReportChunkResult(options, {
+                    posted: false,
+                    reason,
+                    httpStatus: response.status,
+                    recordedCount: 0,
+                })
+            };
+        }
+        return { reason };
+    }
+}
+function logSessionReportTransportFailure(options, error, attempt, maxAttempts) {
+    // Logged per attempt, on purpose: the interesting failure is the one
+    // that repeats. Three identical ECONNRESETs and one DNS failure followed
+    // by two resets are different stories, and `report_network_error` alone
+    // tells neither (BLI-3238).
+    console.error("[session-reports] report attempt failed before a status came back", JSON.stringify({
+        reason: "report_network_error",
+        attempt,
+        max_attempts: maxAttempts,
+        batch_index: options.batchIndex,
+        session_count: options.sessions.length,
+        ...describeError(error),
+    }));
+}
 function postSessionAttributionRequest(options) {
     return options.fetchImpl(`${options.dashboardUrl}/api/ambient/codex-sessions`, {
         method: "POST",