@bli-cockpit/telemetry-core 0.1.15 → 0.1.16

package/dist/decision-event-id.d.ts

@@ -26,10 +26,24 @@ export declare function normalizeActorLabel(rawLabel: string): string;
 export declare function unresolvedActorId(rawLabel: string): string;
 export interface DecisionEventIdInput {
     captureSource: string;
-    /** Hash of the file this was read out of; null for a live hook firing. */
-    sourceArtifactHashSha256: string | null;
-    /** Line within that file; null when the artifact is not line-oriented. */
-    sourceLineNumber: number | null;
+    /**
+     * Hash of exactly the bytes that make up this one decision; null for a live
+     * hook firing, which has no artifact at all.
+     *
+     * "This one decision" and not "the file it arrived in", which is the whole
+     * point. A verdict JSON holds one decision, so its record is the file and the
+     * two hashes coincide. `merge-log.jsonl` holds thousands and gains another
+     * every time somebody merges, so its record is the single line — hashing the
+     * file there would change every id in it on the next append, and a re-import
+     * would write a second copy of the ledger instead of updating the rows it
+     * already has.
+     *
+     * Which snapshot of which file the record came out of is still worth knowing;
+     * it is kept as `source_artifact_hash_sha256`, beside `source_line_number`, as
+     * provenance. Neither is an identity input. Conflating the two jobs in one
+     * field is what made a growing ledger un-re-importable.
+     */
+    sourceRecordHashSha256: string | null;
     kind: string;
     /**
      * Only for a live firing, which has no artifact to hash and no line to point
@@ -43,10 +57,19 @@ export interface DecisionEventIdInput {
 /**
  * The id of one decision event.
  *
- * Two consequences worth stating. Re-running the backfill is idempotent, because
- * the same line of the same file always yields the same id. And an *edited*
- * artifact produces a new id rather than mutating an old one, which keeps the
- * store append-only in the same way jarvis_corrections is — history is added to,
- * never rewritten.
+ * Three consequences worth stating. Re-running the backfill is idempotent,
+ * because the same record always yields the same id no matter how much the file
+ * around it has grown or how far down it has been pushed. An *edited* record
+ * produces a new id rather than mutating an old one, which keeps the store
+ * append-only in the same way jarvis_corrections is — history is added to, never
+ * rewritten. And two byte-identical records collapse onto one row, which is the
+ * intended reading: in a ledger, identical bytes mean a hook wrote the same
+ * decision twice. If that is ever false the ledger format is underspecified, and
+ * the fix belongs there rather than in a tiebreaker here.
+ *
+ * The line number is deliberately absent. It is the one part of a record's
+ * position that a rotation or a compaction can change without the decision
+ * itself changing at all, and an id that moves when a file is renumbered is
+ * worse than a duplicate: it silently lands on some other decision's row.
  */
 export declare function decisionEventId(input: DecisionEventIdInput): string;

package/dist/decision-event-id.js

@@ -52,19 +52,25 @@ export function unresolvedActorId(rawLabel) {
 /**
  * The id of one decision event.
  *
- * Two consequences worth stating. Re-running the backfill is idempotent, because
- * the same line of the same file always yields the same id. And an *edited*
- * artifact produces a new id rather than mutating an old one, which keeps the
- * store append-only in the same way jarvis_corrections is — history is added to,
- * never rewritten.
+ * Three consequences worth stating. Re-running the backfill is idempotent,
+ * because the same record always yields the same id no matter how much the file
+ * around it has grown or how far down it has been pushed. An *edited* record
+ * produces a new id rather than mutating an old one, which keeps the store
+ * append-only in the same way jarvis_corrections is — history is added to, never
+ * rewritten. And two byte-identical records collapse onto one row, which is the
+ * intended reading: in a ledger, identical bytes mean a hook wrote the same
+ * decision twice. If that is ever false the ledger format is underspecified, and
+ * the fix belongs there rather than in a tiebreaker here.
+ *
+ * The line number is deliberately absent. It is the one part of a record's
+ * position that a rotation or a compaction can change without the decision
+ * itself changing at all, and an id that moves when a file is renumbered is
+ * worse than a duplicate: it silently lands on some other decision's row.
  */
 export function decisionEventId(input) {
     const parts = [
         input.captureSource,
-        input.sourceArtifactHashSha256 ?? "",
-        input.sourceLineNumber === null || input.sourceLineNumber === undefined
-            ? ""
-            : String(input.sourceLineNumber),
+        input.sourceRecordHashSha256 ?? "",
         input.kind,
         input.occurredAt ?? "",
         input.subjectDiscriminator ?? "",

package/dist/decision-event.d.ts

@@ -411,6 +411,7 @@ export declare const DecisionEventSchema: z.ZodObject<{
     source_line_number: z.ZodNullable<z.ZodNumber>;
     rule_id: z.ZodNullable<z.ZodString>;
     rulebook_version: z.ZodNullable<z.ZodString>;
+    host: z.ZodNullable<z.ZodString>;
     evidence_pointers: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
             claude_state_path: "claude_state_path";
@@ -593,6 +594,7 @@ export declare const DecisionEventEnvelopeSchema: z.ZodObject<{
         source_line_number: z.ZodNullable<z.ZodNumber>;
         rule_id: z.ZodNullable<z.ZodString>;
         rulebook_version: z.ZodNullable<z.ZodString>;
+        host: z.ZodNullable<z.ZodString>;
         evidence_pointers: z.ZodArray<z.ZodObject<{
             kind: z.ZodEnum<{
                 claude_state_path: "claude_state_path";

package/dist/decision-event.js

@@ -330,7 +330,8 @@ export const DecisionEventSchema = z
     .object({
     /**
      * Deterministic, so re-running the backfill is idempotent and an edited
-     * artifact produces a new id rather than mutating an old one. See
+     * record produces a new id rather than mutating an old one. Derived from the
+     * record's own bytes, never from the file around them — see
      * `decisionEventId`.
      */
     decision_event_id: NonEmptyStringSchema.max(64),
@@ -340,7 +341,13 @@ export const DecisionEventSchema = z
     subject: DecisionSubjectSchema,
     outcome: DecisionOutcomeSchema,
     capture_source: DecisionCaptureSourceSchema,
-    /** The artifact this was read out of, so an edit is detectable. */
+    /**
+     * Which snapshot of which file this was read out of, and where in it. Both
+     * are provenance, not identity: a re-import of a ledger that has grown since
+     * refreshes them on the existing row. Identity comes from the record's own
+     * bytes instead, which is what lets that re-import update rather than
+     * duplicate — see `decisionEventId`.
+     */
     source_artifact_hash_sha256: Sha256Schema.nullable(),
     source_line_number: z.number().int().nonnegative().nullable(),
     /**
@@ -350,6 +357,20 @@ export const DecisionEventSchema = z
      */
     rule_id: NonEmptyStringSchema.max(40).nullable(),
     rulebook_version: VersionStringSchema.nullable(),
+    /**
+     * Which machine the decision was made on, straight from the ledger line.
+     *
+     * A column rather than an `attributes` key, and deliberately beside
+     * `rulebook_version`: both are provenance about the *decision* rather than
+     * about the actor, and "did the laptop behave differently from the desktop"
+     * is a group-by question. A jsonb key would answer it by digging.
+     *
+     * Nullable because both ledgers only started stamping `host` on 2026-08-04
+     * (BLI-2435). Every line before that legitimately has none, so absence is
+     * history rather than an error, and a record without one must ingest
+     * cleanly.
+     */
+    host: NonEmptyStringSchema.max(253).nullable(),
     evidence_pointers: z.array(DecisionEvidencePointerSchema).max(20),
     /**
      * Small, flat, non-narrative extras. Enforced as scalar-or-scalar-array by

package/package.json

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