attenu-guard 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -6,6 +6,41 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-02
+
+### Added
+- **The bundle-level interop test vectors, and the structured failures they are scored
+  against.** The delegation-chain vectors under `test/fixtures/vectors/` have always let this
+  package score its own *token* verifier against the Python reference. There was no equivalent
+  for the *bundle* verifier, which is where the offline-verifiability claim actually lands: an
+  auditor checks a published ledger with no engine, no service and no vendor in the loop.
+  `test/fixtures/vectors/bundles/bundle_vectors_v1.json` is that file, copied byte for byte from
+  the Python repository (`tests/vectors/bundles/bundle_vectors_v1.json`, whose single writer is
+  `tests/vectors/generate_bundles.py`). Eight cases, every one derived from a single valid
+  schema-v2 bundle by exactly ONE change so each isolates one rule: `valid_bundle_v2` (accept),
+  `reject_params_mismatch`, `reject_outcome_without_allow`, `reject_outcome_before_allow`,
+  `reject_duplicate_outcome`, `reject_duplicate_call_id`, `reject_rehashed_chain` (one entry
+  edited and every later hash recomputed — the rewrite a hash chain alone cannot catch, which
+  only the signed anchor does) and `reject_tampered_entry` (the same edit with nothing
+  re-hashed, which fails AT that entry). All eight score here exactly as they score in Python,
+  with byte-identical `failures` strings. `tools/gen_fixtures.py` re-copies the file from the
+  installed Python package once a release ships it, so CI's existing fixture-drift check starts
+  guarding it with no workflow edit.
+- **`verifyBundle()` reports `failure_details`, the structured twin of `failures`** (additive;
+  `failures` is byte-identical to before, because other implementations parse those strings).
+  One entry per string, same order, same count: `{reason, seq, node, call_id, detail}`, so a
+  conformance suite can assert WHICH check failed and WHERE instead of matching prose. `reason`
+  is the token before the colon in the message, except at the two historical sites whose message
+  names a node there (`unreadable_authority`, `unreadable_granted`), which state their reason
+  explicitly. Positions match the Python implementation's: the second sighting for a re-used
+  `call_id`, the `outcome` entry for every allow/outcome binding failure, and null for a
+  genuinely chain-level failure such as a signed anchor that no longer matches the ledger head.
+  Every failure in `src/evidence.ts` now goes through one collector, so a message cannot be
+  added without its twin — `test/bundle-vectors.test.ts` asserts the two lists stay in step at
+  every failure site in the module (including the ones no vector exercises) and traps a direct
+  append. The `execution_binding` sub-report's own shape is unchanged: the twins ride alongside
+  it, never inside it.
+
 ## [0.5.0] - 2026-08-31
 
 ### Fixed

package/README.md

@@ -178,6 +178,17 @@ dual-signing mode. The 19 committed interop vectors include the separating cases
 for number spelling, raw Unicode, UTF-16 member ordering, large integers,
 duplicates, non-finite values and an unmarked canonical header.
 
+`test/fixtures/vectors/bundles/bundle_vectors_v1.json` is the second, bundle-level
+suite: whole evidence bundles for `verifyBundle`, the check an auditor runs on a
+published ledger with no engine and no vendor in the loop. The token vectors pin
+what a delegation token means; these pin what the LEDGER of a run has to satisfy.
+A bundle verifier reports a LIST of failures rather than one reject reason, so
+each rejecting case declares the minimal set of `{reason, seq, node}` that MUST
+appear, at that exact position. A conformant verifier may report more, never
+fewer and never elsewhere. `verifyBundle` returns those positions as
+`failure_details`, the structured twin of `failures`: one
+`{reason, seq, node, call_id, detail}` entry per string, in the same order.
+
 ## What it does not do
 
 - It does not decide what permissions a task needs. You state them; this library

package/dist/cjs/evidence.d.ts

@@ -18,6 +18,14 @@
  *     const bundle = exportBundle(guard.auditLog(), signer);
  *     const report = verifyBundle(bundle, signer);
  *
+ * `report.failures` is the human-readable list — its strings are a published
+ * contract, other implementations parse them — and `report.failure_details` is
+ * its machine-readable twin: one entry per string, same order, same count,
+ * `{reason, seq, node, call_id, detail}`. It exists so a conformance suite can
+ * assert WHICH check failed and WHERE, not merely that something did. The
+ * bundle-level interop vectors under `test/fixtures/vectors/bundles/` are scored
+ * against exactly that shape.
+ *
  * No engine state is consulted — the bundle is the whole input, which is the
  * point. This is byte-compatible with the Python library's
  * `attenu_guard.evidence`.
@@ -98,6 +106,23 @@ export interface ExportOptions {
  * is thrown on any field outside it.
  */
 export declare function exportBundle(auditLog: AuditLog | readonly LedgerEntry[], signer: Signer, options?: ExportOptions): Bundle;
+/**
+ * One structured failure — the machine-readable twin of one `failures` string.
+ *
+ * `reason` is a stable token: the text before the first `:` in `detail`, with
+ * the two historical exceptions whose message names a NODE there
+ * (`unreadable_authority`, `unreadable_granted`) and so state their reason
+ * explicitly. `seq`/`node` are the offending entry's own fields, both `null`
+ * when the failure is chain-level with nothing single to point at. Same field
+ * names and same values as the Python implementation's `failure_details`.
+ */
+export interface FailureDetail {
+    reason: string;
+    seq: Json;
+    node: Json;
+    call_id: Json;
+    detail: string;
+}
 export interface GraphNode {
     agent: Json;
     task: Json;
@@ -165,6 +190,12 @@ export interface VerifyReport {
     ok: boolean;
     checks: VerifyChecks;
     failures: string[];
+    /**
+     * The structured twin of `failures`: same order, same count, one
+     * `{reason, seq, node, call_id, detail}` per string, so a conformance suite can assert the
+     * reason AND the position of every failure instead of matching prose.
+     */
+    failure_details: FailureDetail[];
     nodes: number;
     actions_checked: number;
     chain_id: Json;
@@ -190,6 +221,9 @@ export interface VerifyReport {
  * the bundle's actual `(seq, hash, chainId, v)` must equal it exactly, or `checks.expected_anchor`
  * reports `"FAILED"` and the mismatch lands in `failures`. `report.verified_against` names which
  * mode ran.
+ *
+ * `failure_details` is the structured twin of `failures`: same order, same count, one
+ * `{reason, seq, node, call_id, detail}` entry per string.
  */
 export interface VerifyBundleOptions {
     /** An independently retained anchor object to verify the bundle's actual head against. */

package/dist/cjs/evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../src/evidence.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../src/evidence.ts"],"names":[],"mappings":"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"}

package/dist/cjs/evidence.js

@@ -19,6 +19,14 @@
  *     const bundle = exportBundle(guard.auditLog(), signer);
  *     const report = verifyBundle(bundle, signer);
  *
+ * `report.failures` is the human-readable list — its strings are a published
+ * contract, other implementations parse them — and `report.failure_details` is
+ * its machine-readable twin: one entry per string, same order, same count,
+ * `{reason, seq, node, call_id, detail}`. It exists so a conformance suite can
+ * assert WHICH check failed and WHERE, not merely that something did. The
+ * bundle-level interop vectors under `test/fixtures/vectors/bundles/` are scored
+ * against exactly that shape.
+ *
  * No engine state is consulted — the bundle is the whole input, which is the
  * point. This is byte-compatible with the Python library's
  * `attenu_guard.evidence`.
@@ -228,6 +236,33 @@ function orNull(value) {
     const plain = (0, canonical_js_1.toPlain)(value);
     return plain === undefined ? null : plain;
 }
+/**
+ * The verifier's failure list, kept in two shapes that cannot drift apart.
+ *
+ * `messages` is the string list `verifyBundle` has always returned as
+ * `failures`; those exact strings are a published contract, so they are never
+ * reworded here. `details` is the structured twin of each one, appended in the
+ * same call. Every failure in this module goes through `add`, so a new check
+ * cannot add a message without its twin — `test/bundle-vectors.test.ts` greps
+ * this file for a direct append to a failure list and fails on one, and asserts
+ * the two lists stay in step at every site.
+ */
+class FailureLog {
+    messages = [];
+    details = [];
+    add(reason, detail, position = {}) {
+        const { seq = null, node = null, callId = null } = position;
+        this.messages.push(detail);
+        this.details.push({ reason, seq, node, call_id: callId, detail });
+    }
+    extend(other) {
+        this.messages.push(...other.messages);
+        this.details.push(...other.details);
+    }
+    get length() {
+        return this.messages.length;
+    }
+}
 /**
  * `node -> Authority` and `node -> parent`, reconstructed from `root` and
  * `spawn` events alone. No engine state.
@@ -235,29 +270,40 @@ function orNull(value) {
 function nodeAuthorities(entries) {
     const auth = new Map();
     const parent = new Map();
-    const failures = [];
+    const failures = new FailureLog();
+    const definedBy = new Map();
     for (const e of entries) {
         const ev = (0, canonical_js_1.toPlain)(e["event"]);
         const node = (0, canonical_js_1.toPlain)(e["node"]);
         if (ev === "root") {
+            definedBy.set(node, e);
             try {
                 auth.set(node, authority_js_1.Authority.fromWire(e["authority"] ?? null));
             }
             catch (exc) {
-                failures.push(`root ${node}: unreadable authority (${exc.message})`);
+                // One of the two historical messages that name a node before their colon rather than a
+                // reason token, so the reason is stated here instead of parsed out of the string.
+                failures.add("unreadable_authority", `root ${node}: unreadable authority (${exc.message})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                });
             }
         }
         else if (ev === "spawn") {
+            definedBy.set(node, e);
             parent.set(node, (0, canonical_js_1.toPlain)(e["parent"]) ?? null);
             try {
                 auth.set(node, authority_js_1.Authority.fromWire(e["granted"] ?? null));
             }
             catch (exc) {
-                failures.push(`spawn ${node}: unreadable granted (${exc.message})`);
+                failures.add("unreadable_granted", `spawn ${node}: unreadable granted (${exc.message})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                });
             }
         }
     }
-    return { auth, parent, failures };
+    return { auth, parent, failures, definedBy };
 }
 /**
  * A view of the chain from the bundle: each node with its agent, task,
@@ -596,24 +642,31 @@ const V2_ONLY_FIELDS = [
  * invalid regardless of which field it is (merge-gate item 4/(c)).
  */
 function v2FieldLeaksOnV1(entries) {
-    const failures = [];
+    const failures = new FailureLog();
     for (const e of entries) {
         const leaked = V2_ONLY_FIELDS.filter((f) => f in e).sort();
         if (leaked.length > 0) {
-            failures.push(`v2_field_on_v1: seq=${pyRepr((0, canonical_js_1.toPlain)(e["seq"]))} event=${pyRepr((0, canonical_js_1.toPlain)(e["event"]))} ` +
-                `carries v2-only field(s) ${JSON.stringify(leaked)} on a schemaVersion: 1 entry`);
+            failures.add("v2_field_on_v1", `v2_field_on_v1: seq=${pyRepr((0, canonical_js_1.toPlain)(e["seq"]))} event=${pyRepr((0, canonical_js_1.toPlain)(e["event"]))} ` +
+                `carries v2-only field(s) ${JSON.stringify(leaked)} on a schemaVersion: 1 entry`, { seq: orNull(e["seq"]), node: orNull(e["node"]) });
         }
     }
     return failures;
 }
+/**
+ * `[the execution_binding report, its failures]`. The report's own `failures` key keeps its
+ * historical list-of-strings shape — the structured twins ride alongside it rather than inside
+ * it, so this sub-report's published shape is unchanged.
+ */
 function executionBinding(entries, bundleV) {
     if (bundleV === 1) {
         const leaked = v2FieldLeaksOnV1(entries);
-        return leaked.length > 0 ? { status: "not applicable", failures: leaked } : { status: "not applicable" };
+        return leaked.length > 0
+            ? [{ status: "not applicable", failures: leaked.messages }, leaked]
+            : [{ status: "not applicable" }, new FailureLog()];
     }
     if (bundleV !== 2)
-        return { status: "not applicable" };
-    const failures = [];
+        return [{ status: "not applicable" }, new FailureLog()];
+    const failures = new FailureLog();
     const seenCallIds = new Map(); // callId -> [event, node, seq]
     const allows = new Map();
     const outcomes = new Map();
@@ -629,8 +682,12 @@ function executionBinding(entries, bundleV) {
             if (node !== null)
                 nodes.add(node);
             const err = validateRoot(e);
-            if (err)
-                failures.push(`invalid_root: ${err} (seq ${pyRepr(seqForEvent)})`);
+            if (err) {
+                failures.add("invalid_root", `invalid_root: ${err} (seq ${pyRepr(seqForEvent)})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                });
+            }
         }
         else if (ev === "spawn") {
             if (node !== null)
@@ -644,8 +701,12 @@ function executionBinding(entries, bundleV) {
             for (const r of (0, canonical_js_1.toPlain)(e["revoked"]) ?? [])
                 revokedNodes.add(r);
             const err = validateKill(e);
-            if (err)
-                failures.push(`invalid_kill: ${err} (seq ${pyRepr(seqForEvent)})`);
+            if (err) {
+                failures.add("invalid_kill", `invalid_kill: ${err} (seq ${pyRepr(seqForEvent)})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                });
+            }
         }
         if (ev === "allow" || ev === "deny") {
             const cid = (0, canonical_js_1.toPlain)(e["call_id"]);
@@ -653,8 +714,10 @@ function executionBinding(entries, bundleV) {
             if (cid !== null && cid !== undefined) {
                 const prior = seenCallIds.get(cid);
                 if (prior !== undefined) {
-                    failures.push(`duplicate_call_id: call_id ${cid} on seq ${pyRepr(seq)} (${ev}) already used at seq ` +
-                        `${pyRepr(prior[2])} (${prior[0]})`);
+                    // Positioned on the SECOND sighting: the entry that re-used a call_id is the offending
+                    // record, the first one having been legitimate when it was written.
+                    failures.add("duplicate_call_id", `duplicate_call_id: call_id ${cid} on seq ${pyRepr(seq)} (${ev}) already used at seq ` +
+                        `${pyRepr(prior[2])} (${prior[0]})`, { seq: orNull(e["seq"]), node: orNull(e["node"]), callId: cid });
                 }
                 else {
                     seenCallIds.set(cid, [ev, node, seq]);
@@ -662,7 +725,11 @@ function executionBinding(entries, bundleV) {
             }
             const err = ev === "allow" ? validateAllow(e) : validateDeny(e);
             if (err) {
-                failures.push(`invalid_${ev}: ${err} (seq ${pyRepr(seq)})`);
+                failures.add(`invalid_${ev}`, `invalid_${ev}: ${err} (seq ${pyRepr(seq)})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                    callId: cid ?? null,
+                });
                 if (ev === "allow" && cid !== null && cid !== undefined)
                     invalidAllowIds.add(cid);
                 continue;
@@ -675,12 +742,16 @@ function executionBinding(entries, bundleV) {
             const seq = (0, canonical_js_1.toPlain)(e["seq"]);
             const err = validateOutcome(e);
             if (err) {
-                failures.push(`invalid_outcome: ${err} (seq ${pyRepr(seq)})`);
+                failures.add("invalid_outcome", `invalid_outcome: ${err} (seq ${pyRepr(seq)})`, {
+                    seq: orNull(e["seq"]),
+                    node: orNull(e["node"]),
+                    callId: cid ?? null,
+                });
                 continue;
             }
             if (cid !== null && outcomes.has(cid)) {
-                failures.push(`duplicate_outcome: call_id ${cid} at seq ${pyRepr(seq)} (first at seq ` +
-                    `${pyRepr((0, canonical_js_1.toPlain)(outcomes.get(cid)["seq"]))})`);
+                failures.add("duplicate_outcome", `duplicate_outcome: call_id ${cid} at seq ${pyRepr(seq)} (first at seq ` +
+                    `${pyRepr((0, canonical_js_1.toPlain)(outcomes.get(cid)["seq"]))})`, { seq: orNull(e["seq"]), node: orNull(e["node"]), callId: cid });
                 continue;
             }
             if (cid !== null)
@@ -694,29 +765,32 @@ function executionBinding(entries, bundleV) {
     // its recorded content disagrees with what was authorized (spec: "parameter equality is
     // established only for calls where both hashes are present; elsewhere only identity and order
     // binding was checked" — params_mismatch is that separate concern).
+    // Every failure in this loop is about a PAIR, and is positioned on the `outcome` entry: the
+    // allow was a complete, valid record when it was written, and it is the outcome that fails to
+    // bind to it (or reports different arguments than were authorized).
     const boundOk = new Set();
     for (const [cid, oc] of outcomes) {
         const allowE = allows.get(cid);
         if (allowE === undefined) {
-            failures.push(`outcome_without_allow: call_id ${cid} at seq ${pyRepr((0, canonical_js_1.toPlain)(oc["seq"]))} has no allow in this chain`);
+            failures.add("outcome_without_allow", `outcome_without_allow: call_id ${cid} at seq ${pyRepr((0, canonical_js_1.toPlain)(oc["seq"]))} has no allow in this chain`, { seq: orNull(oc["seq"]), node: orNull(oc["node"]), callId: cid });
             continue;
         }
         const nodeOk = (0, canonical_js_1.toPlain)(allowE["node"]) === (0, canonical_js_1.toPlain)(oc["node"]);
         if (!nodeOk) {
-            failures.push(`cross_ref: call_id ${cid} allow on node ${pyRepr((0, canonical_js_1.toPlain)(allowE["node"]))} but ` +
-                `outcome on node ${pyRepr((0, canonical_js_1.toPlain)(oc["node"]))}`);
+            failures.add("cross_ref", `cross_ref: call_id ${cid} allow on node ${pyRepr((0, canonical_js_1.toPlain)(allowE["node"]))} but ` +
+                `outcome on node ${pyRepr((0, canonical_js_1.toPlain)(oc["node"]))}`, { seq: orNull(oc["seq"]), node: orNull(oc["node"]), callId: cid });
         }
         const ocSeq = (0, canonical_js_1.toPlain)(oc["seq"]);
         const allowSeq = (0, canonical_js_1.toPlain)(allowE["seq"]);
         const orderOk = typeof ocSeq === "number" && typeof allowSeq === "number" && ocSeq > allowSeq;
         if (!orderOk) {
-            failures.push(`outcome_before_allow: call_id ${cid} outcome seq ${pyRepr(ocSeq ?? null)} not ` +
-                `after allow seq ${pyRepr(allowSeq ?? null)}`);
+            failures.add("outcome_before_allow", `outcome_before_allow: call_id ${cid} outcome seq ${pyRepr(ocSeq ?? null)} not ` +
+                `after allow seq ${pyRepr(allowSeq ?? null)}`, { seq: orNull(oc["seq"]), node: orNull(oc["node"]), callId: cid });
         }
         const ah = (0, canonical_js_1.toPlain)(allowE["authorized_params_hash"]);
         const ih = (0, canonical_js_1.toPlain)(oc["invoked_params_hash"]);
         if (ah !== null && ah !== undefined && ih !== null && ih !== undefined && ah !== ih) {
-            failures.push(`params_mismatch: call_id ${cid} authorized_params_hash ${ah} != invoked_params_hash ${ih}`);
+            failures.add("params_mismatch", `params_mismatch: call_id ${cid} authorized_params_hash ${ah} != invoked_params_hash ${ih}`, { seq: orNull(oc["seq"]), node: orNull(oc["node"]), callId: cid });
         }
         if (nodeOk && orderOk)
             boundOk.add(cid);
@@ -786,13 +860,52 @@ function executionBinding(entries, bundleV) {
     }
     if (Object.values(perCall).some((s) => s === "unobserved"))
         escalate("incomplete");
-    return {
-        aggregate,
-        params_coverage: paramsCoverage(allows, outcomes, invalidAllowIds),
-        per_call: perCall,
-        per_node_lifecycle: lifecycle,
+    return [
+        {
+            aggregate,
+            params_coverage: paramsCoverage(allows, outcomes, invalidAllowIds),
+            per_call: perCall,
+            per_node_lifecycle: lifecycle,
+            failures: failures.messages,
+        },
         failures,
-    };
+    ];
+}
+/**
+ * `[seq, node]` of the FIRST entry the hash chain does not reproduce at — position only.
+ *
+ * `AuditLog.verify` stays the authority on WHETHER the chain is broken and on the message this
+ * module reports; this walk exists so the structured twin of that message can say WHERE, which
+ * the message's own text does not expose in a parseable form. Mirrors `AuditLog.verify`'s walk
+ * exactly (same seq/prev_hash/hash order). `[null, null]` when nothing entry-local is wrong — a
+ * consistently re-hashed ledger fails against the signed anchor, not here, and that failure is
+ * chain-level.
+ */
+function integrityPosition(entries) {
+    let prev = audit_js_1.GENESIS;
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        const payload = {};
+        for (const [k, v] of Object.entries(e)) {
+            if (k !== "hash")
+                payload[k] = v;
+        }
+        let broken;
+        try {
+            broken =
+                orNull(e["seq"]) !== i ||
+                    orNull(payload["prev_hash"]) !== prev ||
+                    (0, audit_js_1.hashEntry)(prev, payload) !== orNull(e["hash"]);
+        }
+        catch {
+            // An unhashable payload is itself the break, at this entry.
+            return [orNull(e["seq"]), orNull(e["node"])];
+        }
+        if (broken)
+            return [orNull(e["seq"]), orNull(e["node"])];
+        prev = orNull(e["hash"]);
+    }
+    return [null, null];
 }
 function verifyBundle(bundle, signer = null, options = {}) {
     const entries = bundle.entries ?? [];
@@ -808,38 +921,41 @@ function verifyBundle(bundle, signer = null, options = {}) {
         root: false,
         expected_anchor: "not checked",
     };
-    const failures = [];
+    const log = new FailureLog();
     // (0) version: the bundle must declare a schema version this build understands, and — when
     // an anchor is present — the anchor must be anchoring THAT version, not a different one.
     const bundleV = (0, canonical_js_1.toPlain)(bundle.v);
     let versionOk = typeof bundleV === "number" && exports.SUPPORTED_BUNDLE_VERSIONS.has(bundleV);
     if (!versionOk) {
         const supported = Array.from(exports.SUPPORTED_BUNDLE_VERSIONS).sort((a, b) => a - b);
-        failures.push(`unsupported_version: bundle v=${pyRepr(bundleV)} not in [${supported.join(", ")}]`);
+        log.add("unsupported_version", `unsupported_version: bundle v=${pyRepr(bundleV)} not in [${supported.join(", ")}]`);
     }
     const anchorV = (0, canonical_js_1.toPlain)(anchor["v"]);
     if (anchorPresent && anchorV !== bundleV) {
         versionOk = false;
-        failures.push(`anchor_version_mismatch: anchor v=${pyRepr(anchorV)} != bundle v=${pyRepr(bundleV)}`);
+        log.add("anchor_version_mismatch", `anchor_version_mismatch: anchor v=${pyRepr(anchorV)} != bundle v=${pyRepr(bundleV)}`);
     }
     // (0a) exactly one root: a rootless bundle (or one splicing in a second root) would otherwise
     // sail through monotonicity/containment trivially — there is nothing to anchor those checks to.
     const rootEvents = entries.filter((e) => (0, canonical_js_1.toPlain)(e["event"]) === "root");
     checks.root = rootEvents.length === 1;
     if (!checks.root) {
-        failures.push(`missing_root: bundle has ${rootEvents.length} root event(s), expected exactly 1`);
+        log.add("missing_root", `missing_root: bundle has ${rootEvents.length} root event(s), expected exactly 1`);
     }
     const rootEntry = rootEvents.length === 1 ? rootEvents[0] : undefined;
     // 0.9.0: a chain is created at ONE schema version and never mixes (spec section 9) — the root
     // entry's v must equal the bundle's declared v, and no OTHER entry may carry a different v.
     if (rootEntry !== undefined && (0, canonical_js_1.toPlain)(rootEntry["v"]) !== bundleV) {
         versionOk = false;
-        failures.push(`root_version_mismatch: root v=${pyRepr((0, canonical_js_1.toPlain)(rootEntry["v"]))} != bundle v=${pyRepr(bundleV)}`);
+        log.add("root_version_mismatch", `root_version_mismatch: root v=${pyRepr((0, canonical_js_1.toPlain)(rootEntry["v"]))} != bundle v=${pyRepr(bundleV)}`, { seq: orNull(rootEntry["seq"]), node: orNull(rootEntry["node"]) });
     }
-    const mixed = Array.from(new Set(entries.map((e) => (0, canonical_js_1.toPlain)(e["v"])).filter((v) => v !== bundleV))).sort((a, b) => (typeof a === "number" && typeof b === "number" ? a - b : String(a).localeCompare(String(b))));
+    const mixedEntries = entries.filter((e) => (0, canonical_js_1.toPlain)(e["v"]) !== bundleV);
+    const mixed = Array.from(new Set(mixedEntries.map((e) => (0, canonical_js_1.toPlain)(e["v"])))).sort((a, b) => (typeof a === "number" && typeof b === "number" ? a - b : String(a).localeCompare(String(b))));
     if (mixed.length > 0) {
         versionOk = false;
-        failures.push(`mixed_entry_versions: entries declare v in [${mixed.map((v) => pyRepr(v)).join(", ")}], bundle v=${pyRepr(bundleV)}`);
+        // One aggregate message over every offending entry (unchanged); the twin is positioned on
+        // the first of them, which is where a reader looks.
+        log.add("mixed_entry_versions", `mixed_entry_versions: entries declare v in [${mixed.map((v) => pyRepr(v)).join(", ")}], bundle v=${pyRepr(bundleV)}`, { seq: orNull(mixedEntries[0]["seq"]), node: orNull(mixedEntries[0]["node"]) });
     }
     checks.version = versionOk;
     // (0c) independently retained expected anchor/head: verified against the BUNDLE's actual
@@ -853,7 +969,7 @@ function verifyBundle(bundle, signer = null, options = {}) {
             const [expSeq, expHash] = expectedHead;
             if (actualSeq !== expSeq || actualHead !== expHash) {
                 expectedOk = false;
-                failures.push(`expected_head_mismatch: bundle head is (seq=${actualSeq}, hash=${actualHead}) but the ` +
+                log.add("expected_head_mismatch", `expected_head_mismatch: bundle head is (seq=${actualSeq}, hash=${actualHead}) but the ` +
                     `independently retained expected head is (seq=${expSeq}, hash=${expHash})`);
             }
         }
@@ -864,7 +980,7 @@ function verifyBundle(bundle, signer = null, options = {}) {
                 (0, canonical_js_1.toPlain)(ea["chain_id"]) !== (0, canonical_js_1.toPlain)(bundle.chain_id) ||
                 (0, canonical_js_1.toPlain)(ea["v"]) !== bundleV) {
                 expectedOk = false;
-                failures.push("expected_anchor_mismatch: the bundle's actual (seq, head, chainId, v) does not match " +
+                log.add("expected_anchor_mismatch", "expected_anchor_mismatch: the bundle's actual (seq, head, chainId, v) does not match " +
                     "the independently retained expected anchor");
             }
         }
@@ -874,32 +990,40 @@ function verifyBundle(bundle, signer = null, options = {}) {
     // must all name the SAME chain. Without this a correctly-signed, internally-consistent bundle
     // for a DIFFERENT chain could be handed to a verifier who believes it is checking this one.
     const bundleChainId = orNull(bundle.chain_id);
-    const entriesOk = entries.every((e) => orNull(e["chain_id"]) === bundleChainId);
-    if (!entriesOk) {
-        failures.push(`chain_id_mismatch: an entry does not carry chain_id=${pyRepr(bundleChainId)}`);
+    const foreign = entries.find((e) => orNull(e["chain_id"]) !== bundleChainId);
+    const entriesOk = foreign === undefined;
+    if (foreign !== undefined) {
+        log.add("chain_id_mismatch", `chain_id_mismatch: an entry does not carry chain_id=${pyRepr(bundleChainId)}`, {
+            seq: orNull(foreign["seq"]),
+            node: orNull(foreign["node"]),
+        });
     }
     const anchorChainId = orNull(anchor["chain_id"]);
     const anchorChainOk = !anchorPresent || anchorChainId === bundleChainId;
     if (!anchorChainOk) {
-        failures.push(`chain_id_mismatch: anchor chain_id=${pyRepr(anchorChainId)} != bundle chain_id=${pyRepr(bundleChainId)}`);
+        log.add("chain_id_mismatch", `chain_id_mismatch: anchor chain_id=${pyRepr(anchorChainId)} != bundle chain_id=${pyRepr(bundleChainId)}`);
     }
     checks.chain_id = entriesOk && anchorChainOk;
     // (1) integrity: the hash chain, plus the signed anchor when a key is given.
     const [okChain, err] = audit_js_1.AuditLog.verify(entries);
-    if (!okChain)
-        failures.push(`integrity: ${err}`);
+    if (!okChain) {
+        const [badSeq, badNode] = integrityPosition(entries);
+        log.add("integrity", `integrity: ${err}`, { seq: badSeq, node: badNode });
+    }
     if (signer !== null) {
         const [okAnchor, aerr] = audit_js_1.AuditLog.verifyAnchor(entries, anchor, signer);
         checks.anchor = okAnchor ? "verified" : "FAILED";
+        // Chain-level by construction: the anchor commits to the head of the WHOLE ledger, so a
+        // consistently re-hashed chain has no single offending entry to point at.
         if (!okAnchor)
-            failures.push(`integrity(anchor): ${aerr}`);
+            log.add("integrity(anchor)", `integrity(anchor): ${aerr}`);
         checks.integrity = okChain && okAnchor;
     }
     else {
         checks.integrity = okChain;
     }
-    const { auth, parent, failures: afail } = nodeAuthorities(entries);
-    failures.push(...afail);
+    const { auth, parent, failures: afail, definedBy } = nodeAuthorities(entries);
+    log.extend(afail);
     // (2) monotonicity: every child ⊆ its parent.
     let mono = true;
     for (const [node, pid] of parent) {
@@ -910,8 +1034,9 @@ function verifyBundle(bundle, signer = null, options = {}) {
         const extra = Array.from(child.scopes).filter((s) => !p.scopes.has(s));
         if (!child.isNarrowerThan(p) && extra.length > 0) {
             mono = false;
-            failures.push(`monotonicity: ${node} not ⊆ parent ${pid} (child scopes ` +
-                `[${extra.sort(canonical_js_1.compareCodePoints).map((s) => `'${s}'`).join(", ")}] not held by parent)`);
+            const spawnE = definedBy.get(node);
+            log.add("monotonicity", `monotonicity: ${node} not ⊆ parent ${pid} (child scopes ` +
+                `[${extra.sort(canonical_js_1.compareCodePoints).map((s) => `'${s}'`).join(", ")}] not held by parent)`, { seq: spawnE === undefined ? null : orNull(spawnE["seq"]), node });
         }
     }
     checks.monotonicity = mono && afail.length === 0;
@@ -928,19 +1053,25 @@ function verifyBundle(bundle, signer = null, options = {}) {
         const a = auth.get(node);
         if (a === undefined) {
             contained = false;
-            failures.push(`containment: allow on unknown node ${node}`);
+            log.add("containment", `containment: allow on unknown node ${node}`, {
+                seq: orNull(e["seq"]),
+                node: orNull(e["node"]),
+                callId: orNull(e["call_id"]),
+            });
             continue;
         }
         if (!a.permits(scope, ctx).allowed) {
             contained = false;
-            failures.push(`containment: allow of '${scope}' on ${node} outside its authority ` +
-                `[${Array.from(a.scopes).sort(canonical_js_1.compareCodePoints).map((s) => `'${s}'`).join(", ")}]`);
+            log.add("containment", `containment: allow of '${scope}' on ${node} outside its authority ` +
+                `[${Array.from(a.scopes).sort(canonical_js_1.compareCodePoints).map((s) => `'${s}'`).join(", ")}]`, { seq: orNull(e["seq"]), node: orNull(e["node"]), callId: orNull(e["call_id"]) });
         }
     }
     checks.containment = contained;
-    const eb = versionOk ? executionBinding(entries, bundleV) : { status: "not applicable" };
-    if (eb.failures !== undefined)
-        failures.push(...eb.failures);
+    const [eb, ebFailures] = versionOk
+        ? executionBinding(entries, bundleV)
+        : [{ status: "not applicable" }, new FailureLog()];
+    if (eb.failures !== undefined && eb.failures.length > 0)
+        log.extend(ebFailures);
     // "anchor" and "expected_anchor" are excluded here — both carry a tri-state status string
     // ("not checked"/"verified"/"FAILED"), not a plain pass/fail boolean, and a failed check on
     // either already lands its own entry in `failures`, which the `ok` computation still gates on.
@@ -950,11 +1081,12 @@ function verifyBundle(bundle, signer = null, options = {}) {
         checks.version &&
         checks.chain_id &&
         checks.root &&
-        failures.length === 0;
+        log.length === 0;
     return {
         ok,
         checks,
-        failures,
+        failures: log.messages,
+        failure_details: log.details,
         nodes: auth.size,
         actions_checked: actions,
         chain_id: orNull(bundle.chain_id),