@bli-cockpit/telemetry-core 0.1.26 → 0.1.28

package/dist/collector-heartbeat.d.ts

@@ -56,6 +56,8 @@ export declare const CollectorHeartbeatSchema: z.ZodObject<{
     last_sync_reason: z.ZodOptional<z.ZodString>;
     sessions_observed: z.ZodOptional<z.ZodNumber>;
     sessions_outside_root: z.ZodOptional<z.ZodNumber>;
+    sessions_new_this_tick: z.ZodOptional<z.ZodNumber>;
+    sessions_pending_upload: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type CollectorHeartbeat = z.infer<typeof CollectorHeartbeatSchema>;
 /**

package/dist/collector-heartbeat.js

@@ -89,6 +89,29 @@ export const CollectorHeartbeatSchema = z
         .nonnegative()
         .max(1_000_000)
         .optional(),
+    /**
+     * BLI-3645. Two honest counters beside the raw scan count above, both
+     * optional so a collector too old to compute them keeps posting:
+     *
+     *   - `sessions_new_this_tick` — sessions first seen since this source's
+     *     cursor as it stood before this tick, a FLOW, not the re-scanned
+     *     STOCK `sessions_observed` is.
+     *   - `sessions_pending_upload` — sessions inside an approved root with
+     *     no durable pointer yet, i.e. the "only copy" set. A FLOOR at the
+     *     moment this tick observed it, same as every other counter here.
+     */
+    sessions_new_this_tick: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(1_000_000)
+        .optional(),
+    sessions_pending_upload: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(1_000_000)
+        .optional(),
 })
     .strict();
 /**

package/dist/evidence-reconcile.d.ts

@@ -0,0 +1,88 @@
+/**
+ * "Is this pack the server has no record of actually durable, or did it just
+ * fall out of this laptop's own memory?" — the wire contract for asking.
+ *
+ * BLI-3619. The local upload ledger (`cursors/raw-evidence.json` `objects`) is
+ * capped at 5,000 rows, so a pack staged before the ledger's own memory begins
+ * reads `unknown` locally — not because it was never delivered, but because the
+ * ledger that would say so has forgotten. `unknown` is never deleted, but on a
+ * machine running for months it grows without bound. This is the one door that
+ * resolves it: ask the dashboard's own upload ledger
+ * (`ambient_raw_evidence_upload_ledger`), by content hash, whether THIS
+ * device's copy of those bytes ever landed.
+ *
+ * Deliberately keyed on `content_hash_sha256` alone, never `pack_id` — a pack
+ * id is a local directory name the server has never seen and has no column
+ * for. The collector may ask about the same hash on behalf of several packs
+ * (duplicate content is not impossible); the answer applies to the hash, and
+ * the collector applies it to every local object that hash matches.
+ *
+ * Three verdicts, not two, because collapsing them would erase the difference
+ * the doctor row needs to report honestly:
+ *   committed           a ledger row for this device, this hash, is
+ *                       `status = "committed"`. Durable. Prunable under the
+ *                       normal retention rule from here on.
+ *   not_committed       a ledger row exists for this device and this hash, but
+ *                       it never reached `committed` (pending/aborted/failed).
+ *                       The server started a transaction and it did not finish.
+ *   unknown_to_server   no ledger row at all for this device, this hash. The
+ *                       server has never heard of these bytes.
+ * Both `not_committed` and `unknown_to_server` become the collector's ordinary
+ * `uncommitted` state — never deleted — the label only changes what a person is
+ * told about why.
+ */
+import { z } from "zod";
+export declare const EVIDENCE_RECONCILE_SCHEMA_VERSION = "evidence-reconcile.v1";
+/** One request may ask about at most this many hashes. */
+export declare const EVIDENCE_RECONCILE_MAX_BATCH = 500;
+export declare const EvidenceReconcileRequestItemSchema: z.ZodObject<{
+    content_hash_sha256: z.ZodString;
+}, z.core.$strict>;
+export type EvidenceReconcileRequestItem = z.infer<typeof EvidenceReconcileRequestItemSchema>;
+export declare const EvidenceReconcileRequestSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"evidence-reconcile.v1">;
+    items: z.ZodArray<z.ZodObject<{
+        content_hash_sha256: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EvidenceReconcileRequest = z.infer<typeof EvidenceReconcileRequestSchema>;
+export declare const EvidenceReconcileVerdictSchema: z.ZodEnum<{
+    committed: "committed";
+    not_committed: "not_committed";
+    unknown_to_server: "unknown_to_server";
+}>;
+export type EvidenceReconcileVerdict = z.infer<typeof EvidenceReconcileVerdictSchema>;
+export declare const EvidenceReconcileResultSchema: z.ZodObject<{
+    content_hash_sha256: z.ZodString;
+    verdict: z.ZodEnum<{
+        committed: "committed";
+        not_committed: "not_committed";
+        unknown_to_server: "unknown_to_server";
+    }>;
+    committed_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type EvidenceReconcileResult = z.infer<typeof EvidenceReconcileResultSchema>;
+export declare const EvidenceReconcileCountsSchema: z.ZodObject<{
+    committed: z.ZodNumber;
+    not_committed: z.ZodNumber;
+    unknown_to_server: z.ZodNumber;
+}, z.core.$strict>;
+export type EvidenceReconcileCounts = z.infer<typeof EvidenceReconcileCountsSchema>;
+export declare const EvidenceReconcileResponseSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"evidence-reconcile.v1">;
+    results: z.ZodArray<z.ZodObject<{
+        content_hash_sha256: z.ZodString;
+        verdict: z.ZodEnum<{
+            committed: "committed";
+            not_committed: "not_committed";
+            unknown_to_server: "unknown_to_server";
+        }>;
+        committed_at: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    counts: z.ZodObject<{
+        committed: z.ZodNumber;
+        not_committed: z.ZodNumber;
+        unknown_to_server: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type EvidenceReconcileResponse = z.infer<typeof EvidenceReconcileResponseSchema>;

package/dist/evidence-reconcile.js

@@ -0,0 +1,79 @@
+/**
+ * "Is this pack the server has no record of actually durable, or did it just
+ * fall out of this laptop's own memory?" — the wire contract for asking.
+ *
+ * BLI-3619. The local upload ledger (`cursors/raw-evidence.json` `objects`) is
+ * capped at 5,000 rows, so a pack staged before the ledger's own memory begins
+ * reads `unknown` locally — not because it was never delivered, but because the
+ * ledger that would say so has forgotten. `unknown` is never deleted, but on a
+ * machine running for months it grows without bound. This is the one door that
+ * resolves it: ask the dashboard's own upload ledger
+ * (`ambient_raw_evidence_upload_ledger`), by content hash, whether THIS
+ * device's copy of those bytes ever landed.
+ *
+ * Deliberately keyed on `content_hash_sha256` alone, never `pack_id` — a pack
+ * id is a local directory name the server has never seen and has no column
+ * for. The collector may ask about the same hash on behalf of several packs
+ * (duplicate content is not impossible); the answer applies to the hash, and
+ * the collector applies it to every local object that hash matches.
+ *
+ * Three verdicts, not two, because collapsing them would erase the difference
+ * the doctor row needs to report honestly:
+ *   committed           a ledger row for this device, this hash, is
+ *                       `status = "committed"`. Durable. Prunable under the
+ *                       normal retention rule from here on.
+ *   not_committed       a ledger row exists for this device and this hash, but
+ *                       it never reached `committed` (pending/aborted/failed).
+ *                       The server started a transaction and it did not finish.
+ *   unknown_to_server   no ledger row at all for this device, this hash. The
+ *                       server has never heard of these bytes.
+ * Both `not_committed` and `unknown_to_server` become the collector's ordinary
+ * `uncommitted` state — never deleted — the label only changes what a person is
+ * told about why.
+ */
+import { z } from "zod";
+import { IsoDateTimeSchema, Sha256Schema } from "./common.js";
+export const EVIDENCE_RECONCILE_SCHEMA_VERSION = "evidence-reconcile.v1";
+/** One request may ask about at most this many hashes. */
+export const EVIDENCE_RECONCILE_MAX_BATCH = 500;
+export const EvidenceReconcileRequestItemSchema = z
+    .object({
+    content_hash_sha256: Sha256Schema,
+})
+    .strict();
+export const EvidenceReconcileRequestSchema = z
+    .object({
+    schema_version: z.literal(EVIDENCE_RECONCILE_SCHEMA_VERSION),
+    items: z
+        .array(EvidenceReconcileRequestItemSchema)
+        .min(1)
+        .max(EVIDENCE_RECONCILE_MAX_BATCH),
+})
+    .strict();
+export const EvidenceReconcileVerdictSchema = z.enum([
+    "committed",
+    "not_committed",
+    "unknown_to_server",
+]);
+export const EvidenceReconcileResultSchema = z
+    .object({
+    content_hash_sha256: Sha256Schema,
+    verdict: EvidenceReconcileVerdictSchema,
+    /** Present only when `verdict === "committed"`. */
+    committed_at: IsoDateTimeSchema.nullable(),
+})
+    .strict();
+export const EvidenceReconcileCountsSchema = z
+    .object({
+    committed: z.number().int().nonnegative(),
+    not_committed: z.number().int().nonnegative(),
+    unknown_to_server: z.number().int().nonnegative(),
+})
+    .strict();
+export const EvidenceReconcileResponseSchema = z
+    .object({
+    schema_version: z.literal(EVIDENCE_RECONCILE_SCHEMA_VERSION),
+    results: z.array(EvidenceReconcileResultSchema),
+    counts: EvidenceReconcileCountsSchema,
+})
+    .strict();

package/dist/evidence-upload.d.ts

@@ -354,8 +354,8 @@ export type RawEvidenceUploadCommitRequest = z.infer<typeof RawEvidenceUploadCom
 export declare const RawEvidenceUploadCommitResponseSchema: z.ZodObject<{
     ok: z.ZodLiteral<true>;
     status: z.ZodEnum<{
-        already_committed: "already_committed";
         committed: "committed";
+        already_committed: "already_committed";
     }>;
     object_key: z.ZodString;
     content_hash_sha256: z.ZodString;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from "./common.js";
 export * from "./decision-event.js";
 export * from "./decision-event-id.js";
 export * from "./evidence-completeness.js";
+export * from "./evidence-reconcile.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";

package/dist/index.js

@@ -4,6 +4,7 @@ export * from "./common.js";
 export * from "./decision-event.js";
 export * from "./decision-event-id.js";
 export * from "./evidence-completeness.js";
+export * from "./evidence-reconcile.js";
 export * from "./evidence-upload.js";
 export * from "./ingest-dto.js";
 export * from "./local-config.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/telemetry-core",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",