@mcp-audit-gateway/core 0.1.0 → 0.4.0

package/test/vectors/verify.mjs

@@ -0,0 +1,346 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const vectors = JSON.parse(
+  readFileSync(join(__dirname, "canonicalization.json"), "utf-8"),
+);
+
+function sha256Hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+function canonicalizeValue(value) {
+  if (value === null || value === undefined) return null;
+  switch (typeof value) {
+    case "string":
+      for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code >= 0xD800 && code <= 0xDBFF) {
+          const next = i + 1 < value.length ? value.charCodeAt(i + 1) : 0;
+          if (next < 0xDC00 || next > 0xDFFF)
+            throw new Error(`unpaired surrogate at index ${i}`);
+          i++;
+        } else if (code >= 0xDC00 && code <= 0xDFFF) {
+          throw new Error(`unpaired surrogate at index ${i}`);
+        }
+      }
+      return value;
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isSafeInteger(value)) throw new Error(`unsafe number ${value}`);
+      return value;
+    case "object": {
+      if (Array.isArray(value)) return ["L", value.map(canonicalizeValue)];
+      const keys = Object.keys(value).sort().filter((k) => value[k] !== undefined);
+      return ["M", keys.map((k) => [k, canonicalizeValue(value[k])])];
+    }
+    default:
+      throw new Error(`unsupported type ${typeof value}`);
+  }
+}
+
+function canonicalizeFromRecord(record, fieldOrder) {
+  const ordered = fieldOrder.map((key) => [key, record[key] ?? null]);
+  let insertAt = 11;
+  if (record.decisionContextDigest != null) {
+    ordered.splice(10, 0, ["decisionContextDigest", record.decisionContextDigest]);
+    insertAt = 12;
+  }
+  if (record.extensionsDigest != null) {
+    ordered.splice(insertAt, 0, ["extensionsDigest", record.extensionsDigest]);
+    insertAt++;
+  }
+  if (record.aiInvocation != null) {
+    ordered.splice(insertAt, 0, ["aiInvocation", canonicalizeValue(record.aiInvocation)]);
+    insertAt++;
+  }
+  if (record.parties != null) {
+    ordered.splice(insertAt, 0, ["parties", record.parties]);
+  }
+  return JSON.stringify(ordered);
+}
+
+let passed = 0;
+let failed = 0;
+
+console.log(`Format version: ${vectors.format_version}`);
+console.log(`Encoding: ${vectors.encoding}`);
+console.log(`Hash: ${vectors.hash_algorithm} (${vectors.hash_output})`);
+console.log();
+
+// --- Canonicalization vectors ---
+console.log("=== Canonicalization Vectors ===\n");
+
+for (const v of vectors.canonicalization) {
+  const canonical = canonicalizeFromRecord(v.record, vectors.field_order);
+  const hash = sha256Hex(canonical);
+
+  const canonMatch = canonical === v.canonical;
+  const hashMatch = hash === v.sha256_canonical;
+
+  if (canonMatch && hashMatch) {
+    console.log(`  PASS: ${v.name}`);
+    passed++;
+  } else {
+    console.log(`  FAIL: ${v.name}`);
+    if (!canonMatch) {
+      console.log(`    canonical expected: ${v.canonical}`);
+      console.log(`    canonical got:      ${canonical}`);
+    }
+    if (!hashMatch) {
+      console.log(`    hash expected: ${v.sha256_canonical}`);
+      console.log(`    hash got:      ${hash}`);
+    }
+    failed++;
+  }
+}
+
+// --- Chain vectors ---
+console.log("\n=== Chain Vectors ===\n");
+
+for (let i = 0; i < vectors.chain.records.length; i++) {
+  const entry = vectors.chain.records[i];
+  const record = entry.record;
+
+  // Verify canonical form
+  const canonical = canonicalizeFromRecord(record, vectors.field_order);
+  const canonHash = sha256Hex(canonical);
+  const canonMatch = canonical === entry.canonical;
+  const canonHashMatch = canonHash === entry.sha256_canonical;
+
+  if (canonMatch && canonHashMatch) {
+    console.log(`  PASS: chain[${i}] canonical (${record.toolName})`);
+    passed++;
+  } else {
+    console.log(`  FAIL: chain[${i}] canonical (${record.toolName})`);
+    if (!canonMatch) console.log(`    canonical mismatch`);
+    if (!canonHashMatch) console.log(`    canonical hash mismatch`);
+    failed++;
+  }
+
+  // Verify chain hash via full_record_json
+  const refHash = sha256Hex(entry.full_record_json);
+  if (refHash === entry.record_hash) {
+    console.log(`  PASS: chain[${i}] record_hash (${record.toolName})`);
+    passed++;
+  } else {
+    console.log(`  FAIL: chain[${i}] record_hash (${record.toolName})`);
+    console.log(`    expected: ${entry.record_hash}`);
+    console.log(`    got:      ${refHash}`);
+    failed++;
+  }
+
+  // Verify native JSON.stringify produces same hash
+  const nativeJson = JSON.stringify(record);
+  const nativeHash = sha256Hex(nativeJson);
+  if (nativeHash === entry.record_hash) {
+    console.log(`  PASS: chain[${i}] native stringify match (${record.toolName})`);
+    passed++;
+  } else {
+    console.log(`  FAIL: chain[${i}] native stringify diverges (${record.toolName})`);
+    console.log(`    reference: ${entry.full_record_json}`);
+    console.log(`    native:    ${nativeJson}`);
+    failed++;
+  }
+
+  // Verify linkage
+  let linkageOk;
+  if (i === 0) {
+    linkageOk = record.previousHash === vectors.chain.genesis_seed;
+  } else {
+    const prev = vectors.chain.records[i - 1];
+    linkageOk =
+      record.previousHash === prev.record_hash &&
+      entry.previous_record_hash === prev.record_hash;
+  }
+
+  if (linkageOk) {
+    console.log(`  PASS: chain[${i}] linkage (${record.toolName})`);
+    passed++;
+  } else {
+    console.log(`  FAIL: chain[${i}] linkage (${record.toolName})`);
+    failed++;
+  }
+}
+
+// --- Dual-hash demonstration ---
+console.log("\n=== Dual-Hash Demonstration ===\n");
+
+const demo = vectors.dual_hash_demo;
+
+const canonA = canonicalizeFromRecord(demo.record_a.record, vectors.field_order);
+const canonB = canonicalizeFromRecord(demo.record_b.record, vectors.field_order);
+const hashA = sha256Hex(canonA);
+const hashB = sha256Hex(canonB);
+
+if (hashA === hashB && hashA === demo.record_a.sha256_canonical) {
+  console.log("  PASS: canonical hashes match (attestation excluded)");
+  passed++;
+} else {
+  console.log("  FAIL: canonical hashes should match");
+  failed++;
+}
+
+const chainA = sha256Hex(demo.record_a.full_record_json);
+const chainB = sha256Hex(demo.record_b.full_record_json);
+
+if (chainA !== chainB && chainA === demo.record_a.record_hash && chainB === demo.record_b.record_hash) {
+  console.log("  PASS: chain hashes differ (attestation included)");
+  passed++;
+} else {
+  console.log("  FAIL: chain hashes should differ");
+  failed++;
+}
+
+if (demo.assertions.canonical_hashes_match === true) {
+  console.log("  PASS: assertions.canonical_hashes_match");
+  passed++;
+} else {
+  console.log("  FAIL: assertions.canonical_hashes_match should be true");
+  failed++;
+}
+
+if (demo.assertions.chain_hashes_differ === true) {
+  console.log("  PASS: assertions.chain_hashes_differ");
+  passed++;
+} else {
+  console.log("  FAIL: assertions.chain_hashes_differ should be true");
+  failed++;
+}
+
+// --- Party Attribution vectors ---
+if (vectors.party_attribution) {
+  console.log("\n=== Party Attribution Vectors ===\n");
+
+  for (const v of vectors.party_attribution.vectors) {
+    const canonical = canonicalizeFromRecord(v.record, vectors.field_order);
+    const hash = sha256Hex(canonical);
+
+    const canonMatch = canonical === v.canonical;
+    const hashMatch = hash === v.sha256_canonical;
+
+    if (canonMatch && hashMatch) {
+      console.log(`  PASS: ${v.name}`);
+      passed++;
+    } else {
+      console.log(`  FAIL: ${v.name}`);
+      if (!canonMatch) {
+        console.log(`    canonical expected: ${v.canonical}`);
+        console.log(`    canonical got:      ${canonical}`);
+      }
+      if (!hashMatch) {
+        console.log(`    hash expected: ${v.sha256_canonical}`);
+        console.log(`    hash got:      ${hash}`);
+      }
+      failed++;
+    }
+  }
+}
+
+// --- Chain with Parties ---
+if (vectors.party_attribution?.chain_with_parties) {
+  console.log("\n=== Chain with Parties ===\n");
+
+  const cwp = vectors.party_attribution.chain_with_parties;
+  for (let i = 0; i < cwp.records.length; i++) {
+    const entry = cwp.records[i];
+    const record = entry.record;
+
+    const canonical = canonicalizeFromRecord(record, vectors.field_order);
+    const canonHash = sha256Hex(canonical);
+    if (canonical === entry.canonical && canonHash === entry.sha256_canonical) {
+      console.log(`  PASS: chain_with_parties[${i}] canonical (${record.toolName})`);
+      passed++;
+    } else {
+      console.log(`  FAIL: chain_with_parties[${i}] canonical (${record.toolName})`);
+      failed++;
+    }
+
+    const refHash = sha256Hex(entry.full_record_json);
+    if (refHash === entry.record_hash) {
+      console.log(`  PASS: chain_with_parties[${i}] record_hash (${record.toolName})`);
+      passed++;
+    } else {
+      console.log(`  FAIL: chain_with_parties[${i}] record_hash (${record.toolName})`);
+      console.log(`    expected: ${entry.record_hash}`);
+      console.log(`    got:      ${refHash}`);
+      failed++;
+    }
+
+    let linkageOk;
+    if (i === 0) {
+      linkageOk = record.previousHash === cwp.genesis_seed;
+    } else {
+      const prev = cwp.records[i - 1];
+      linkageOk =
+        record.previousHash === prev.record_hash &&
+        entry.previous_record_hash === prev.record_hash;
+    }
+    if (linkageOk) {
+      console.log(`  PASS: chain_with_parties[${i}] linkage (${record.toolName})`);
+      passed++;
+    } else {
+      console.log(`  FAIL: chain_with_parties[${i}] linkage (${record.toolName})`);
+      failed++;
+    }
+  }
+}
+
+// --- Scope Order Significance ---
+if (vectors.party_attribution) {
+  const paVecs = vectors.party_attribution.vectors;
+  const origVec = paVecs.find((v) => v.name === "scope_order_original");
+  const sortVec = paVecs.find((v) => v.name === "scope_order_sorted");
+  if (origVec && sortVec) {
+    console.log("\n=== Scope Order Significance ===\n");
+    const hOrig = sha256Hex(canonicalizeFromRecord(origVec.record, vectors.field_order));
+    const hSort = sha256Hex(canonicalizeFromRecord(sortVec.record, vectors.field_order));
+    if (hOrig !== hSort) {
+      console.log("  PASS: different scope order produces different hash");
+      passed++;
+    } else {
+      console.log("  FAIL: scope order should produce different hashes");
+      failed++;
+    }
+  }
+}
+
+
+// --- aiInvocation signing vectors ---
+if (vectors.ai_invocation_signing) {
+  console.log("\n=== aiInvocation Signing ===\n");
+  for (const v of vectors.ai_invocation_signing.vectors) {
+    const canonical = canonicalizeFromRecord(v.record, vectors.field_order);
+    if (canonical === v.canonical) { console.log(`  PASS: ${v.name} canonical form`); passed++; }
+    else { console.log(`  FAIL: ${v.name} canonical form`); failed++; }
+    if (sha256Hex(canonical) === v.sha256_canonical) { console.log(`  PASS: ${v.name} digest`); passed++; }
+    else { console.log(`  FAIL: ${v.name} digest`); failed++; }
+  }
+  const mn = vectors.ai_invocation_signing.mutation_negative;
+  const hOrig = sha256Hex(canonicalizeFromRecord(mn.original.record, vectors.field_order));
+  const hMut = sha256Hex(canonicalizeFromRecord(mn.mutated.record, vectors.field_order));
+  if (hOrig === mn.original.sha256_canonical && hMut === mn.mutated.sha256_canonical) {
+    console.log("  PASS: mutation pair digests reproduce"); passed++;
+  } else { console.log("  FAIL: mutation pair digests reproduce"); failed++; }
+  if (hOrig !== hMut) { console.log("  PASS: mutated aiInvocation changes signing digest"); passed++; }
+  else { console.log("  FAIL: mutated aiInvocation must change signing digest"); failed++; }
+}
+
+// --- extensionsDigest base-suite vectors ---
+if (vectors.extensions_digest_base) {
+  console.log("\n=== extensionsDigest (base suite) ===\n");
+  for (const v of vectors.extensions_digest_base.vectors) {
+    const canonical = canonicalizeFromRecord(v.record, vectors.field_order);
+    if (canonical === v.canonical) { console.log(`  PASS: ${v.name} canonical form`); passed++; }
+    else { console.log(`  FAIL: ${v.name} canonical form`); failed++; }
+    if (sha256Hex(canonical) === v.sha256_canonical) { console.log(`  PASS: ${v.name} digest`); passed++; }
+    else { console.log(`  FAIL: ${v.name} digest`); failed++; }
+  }
+}
+
+console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
+process.exit(failed > 0 ? 1 : 0);

package/test/vectors/verify.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+Cross-language verification of mcp-audit-gateway conformance vectors.
+
+Proves the tuple-array canonical form is reproducible outside the
+original JavaScript implementation. Chain hashes are verified against
+the full_record_json reference string (avoiding insertion-order issues).
+"""
+
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+vectors_path = Path(__file__).parent / "canonicalization.json"
+vectors = json.loads(vectors_path.read_text())
+
+FIELD_ORDER = vectors["field_order"]
+
+
+def assert_well_formed(value: str) -> None:
+    for i, ch in enumerate(value):
+        if 0xD800 <= ord(ch) <= 0xDFFF:
+            raise ValueError(f"unpaired surrogate at index {i}")
+
+
+def canonicalize_value(value):
+    if value is None:
+        return None
+    if isinstance(value, str):
+        assert_well_formed(value)
+        return value
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        if abs(value) > 2**53 - 1:
+            raise ValueError(f"unsafe number {value}")
+        return value
+    if isinstance(value, float):
+        raise ValueError(f"unsafe number {value}")
+    if isinstance(value, list):
+        return ["L", [canonicalize_value(v) for v in value]]
+    if isinstance(value, dict):
+        keys = sorted(value.keys(), key=lambda k: k.encode("utf-16-be"))
+        for k in keys:
+            assert_well_formed(k)
+        return ["M", [[k, canonicalize_value(value[k])] for k in keys]]
+    raise ValueError(f"unsupported type {type(value)}")
+
+
+def canonicalize(record: dict) -> str:
+    """Reproduce the tuple-array canonical form in Python."""
+    ordered = []
+    for key in FIELD_ORDER:
+        value = record.get(key)
+        ordered.append([key, value])
+    insert_at = 11
+    if record.get("decisionContextDigest") is not None:
+        ordered.insert(10, ["decisionContextDigest", record["decisionContextDigest"]])
+        insert_at = 12
+    if record.get("extensionsDigest") is not None:
+        ordered.insert(insert_at, ["extensionsDigest", record["extensionsDigest"]])
+        insert_at += 1
+    if record.get("aiInvocation") is not None:
+        ordered.insert(insert_at, ["aiInvocation", canonicalize_value(record["aiInvocation"])])
+        insert_at += 1
+    if record.get("parties") is not None:
+        ordered.insert(insert_at, ["parties", record["parties"]])
+    return json.dumps(ordered, separators=(",", ":"), ensure_ascii=False)
+
+
+def sha256_hex(data: str) -> str:
+    return hashlib.sha256(data.encode("utf-8")).hexdigest()
+
+
+passed = 0
+failed = 0
+
+print(f"Format version: {vectors['format_version']}")
+print(f"Encoding: {vectors['encoding']}")
+print(f"Hash: {vectors['hash_algorithm']} ({vectors['hash_output']})")
+print(f"Null rule: {vectors['null_rule']}")
+print()
+
+# --- Canonicalization vectors ---
+print("=== Canonicalization Vectors ===\n")
+
+for v in vectors["canonicalization"]:
+    canonical = canonicalize(v["record"])
+    h = sha256_hex(canonical)
+
+    canon_match = canonical == v["canonical"]
+    hash_match = h == v["sha256_canonical"]
+
+    if canon_match and hash_match:
+        print(f"  PASS: {v['name']}")
+        passed += 1
+    else:
+        print(f"  FAIL: {v['name']}")
+        if not canon_match:
+            print(f"    canonical expected: {v['canonical']}")
+            print(f"    canonical got:      {canonical}")
+        if not hash_match:
+            print(f"    hash expected: {v['sha256_canonical']}")
+            print(f"    hash got:      {h}")
+        failed += 1
+
+# --- Chain vectors ---
+print("\n=== Chain Vectors ===\n")
+
+for i, entry in enumerate(vectors["chain"]["records"]):
+    record = entry["record"]
+
+    # Verify canonical form (cross-language safe)
+    canonical = canonicalize(record)
+    canon_hash = sha256_hex(canonical)
+    canon_match = canonical == entry["canonical"]
+    canon_hash_match = canon_hash == entry["sha256_canonical"]
+
+    if canon_match and canon_hash_match:
+        print(f"  PASS: chain[{i}] canonical ({record['toolName']})")
+        passed += 1
+    else:
+        print(f"  FAIL: chain[{i}] canonical ({record['toolName']})")
+        if not canon_match:
+            print(f"    canonical mismatch")
+        if not canon_hash_match:
+            print(f"    canonical hash mismatch")
+        failed += 1
+
+    # Verify chain hash against full_record_json reference
+    reference_json = entry["full_record_json"]
+    reference_hash = sha256_hex(reference_json)
+    chain_match = reference_hash == entry["record_hash"]
+
+    if chain_match:
+        print(f"  PASS: chain[{i}] record_hash via reference JSON ({record['toolName']})")
+        passed += 1
+    else:
+        print(f"  FAIL: chain[{i}] record_hash via reference JSON")
+        print(f"    expected: {entry['record_hash']}")
+        print(f"    got:      {reference_hash}")
+        failed += 1
+
+    # Verify chain linkage
+    if i == 0:
+        linkage_ok = record["previousHash"] == vectors["chain"]["genesis_seed"]
+    else:
+        prev = vectors["chain"]["records"][i - 1]
+        linkage_ok = (
+            record["previousHash"] == prev["record_hash"]
+            and entry.get("previous_record_hash") == prev["record_hash"]
+        )
+
+    if linkage_ok:
+        print(f"  PASS: chain[{i}] linkage ({record['toolName']})")
+        passed += 1
+    else:
+        print(f"  FAIL: chain[{i}] linkage ({record['toolName']})")
+        failed += 1
+
+# --- Dual-hash demonstration ---
+print("\n=== Dual-Hash Demonstration ===\n")
+
+demo = vectors["dual_hash_demo"]
+a = demo["record_a"]
+b = demo["record_b"]
+
+# Canonical hashes should match (attestation excluded)
+canon_a = canonicalize(a["record"])
+canon_b = canonicalize(b["record"])
+hash_a = sha256_hex(canon_a)
+hash_b = sha256_hex(canon_b)
+
+if hash_a == hash_b and hash_a == a["sha256_canonical"] and hash_b == b["sha256_canonical"]:
+    print("  PASS: canonical hashes match (attestation excluded from signing)")
+    passed += 1
+else:
+    print("  FAIL: canonical hashes should match")
+    print(f"    a: {hash_a}")
+    print(f"    b: {hash_b}")
+    failed += 1
+
+# Chain hashes should differ (attestation included)
+chain_a = sha256_hex(a["full_record_json"])
+chain_b = sha256_hex(b["full_record_json"])
+
+if chain_a != chain_b and chain_a == a["record_hash"] and chain_b == b["record_hash"]:
+    print("  PASS: chain hashes differ (attestation included in chain)")
+    passed += 1
+else:
+    print("  FAIL: chain hashes should differ")
+    print(f"    a: {chain_a}")
+    print(f"    b: {chain_b}")
+    failed += 1
+
+# Verify assertions field
+if demo["assertions"]["canonical_hashes_match"] is True:
+    print("  PASS: assertions.canonical_hashes_match confirmed")
+    passed += 1
+else:
+    print("  FAIL: assertions.canonical_hashes_match should be true")
+    failed += 1
+
+if demo["assertions"]["chain_hashes_differ"] is True:
+    print("  PASS: assertions.chain_hashes_differ confirmed")
+    passed += 1
+else:
+    print("  FAIL: assertions.chain_hashes_differ should be true")
+    failed += 1
+
+# --- Party Attribution vectors ---
+if "party_attribution" in vectors:
+    print("\n=== Party Attribution Vectors ===\n")
+
+    for v in vectors["party_attribution"]["vectors"]:
+        canonical = canonicalize(v["record"])
+        h = sha256_hex(canonical)
+
+        canon_match = canonical == v["canonical"]
+        hash_match = h == v["sha256_canonical"]
+
+        if canon_match and hash_match:
+            print(f"  PASS: {v['name']}")
+            passed += 1
+        else:
+            print(f"  FAIL: {v['name']}")
+            if not canon_match:
+                print(f"    canonical expected: {v['canonical']}")
+                print(f"    canonical got:      {canonical}")
+            if not hash_match:
+                print(f"    hash expected: {v['sha256_canonical']}")
+                print(f"    hash got:      {h}")
+            failed += 1
+
+# --- Chain with Parties vectors ---
+if "party_attribution" in vectors and "chain_with_parties" in vectors["party_attribution"]:
+    print("\n=== Chain with Parties ===\n")
+
+    cwp = vectors["party_attribution"]["chain_with_parties"]
+    for i, entry in enumerate(cwp["records"]):
+        record = entry["record"]
+
+        canonical = canonicalize(record)
+        canon_hash = sha256_hex(canonical)
+        canon_match = canonical == entry["canonical"]
+        canon_hash_match = canon_hash == entry["sha256_canonical"]
+
+        if canon_match and canon_hash_match:
+            print(f"  PASS: chain_with_parties[{i}] canonical ({record['toolName']})")
+            passed += 1
+        else:
+            print(f"  FAIL: chain_with_parties[{i}] canonical ({record['toolName']})")
+            if not canon_match:
+                print(f"    canonical mismatch")
+            if not canon_hash_match:
+                print(f"    canonical hash mismatch")
+            failed += 1
+
+        reference_json = entry["full_record_json"]
+        reference_hash = sha256_hex(reference_json)
+        chain_match = reference_hash == entry["record_hash"]
+
+        if chain_match:
+            print(f"  PASS: chain_with_parties[{i}] record_hash ({record['toolName']})")
+            passed += 1
+        else:
+            print(f"  FAIL: chain_with_parties[{i}] record_hash ({record['toolName']})")
+            print(f"    expected: {entry['record_hash']}")
+            print(f"    got:      {reference_hash}")
+            failed += 1
+
+        if i == 0:
+            linkage_ok = record["previousHash"] == cwp["genesis_seed"]
+        else:
+            prev = cwp["records"][i - 1]
+            linkage_ok = (
+                record["previousHash"] == prev["record_hash"]
+                and entry.get("previous_record_hash") == prev["record_hash"]
+            )
+
+        if linkage_ok:
+            print(f"  PASS: chain_with_parties[{i}] linkage ({record['toolName']})")
+            passed += 1
+        else:
+            print(f"  FAIL: chain_with_parties[{i}] linkage ({record['toolName']})")
+            failed += 1
+
+# --- Scope Order Significance ---
+if "party_attribution" in vectors:
+    pa_vectors = vectors["party_attribution"]["vectors"]
+    scope_orig = next((v for v in pa_vectors if v["name"] == "scope_order_original"), None)
+    scope_sort = next((v for v in pa_vectors if v["name"] == "scope_order_sorted"), None)
+    if scope_orig and scope_sort:
+        print("\n=== Scope Order Significance ===\n")
+        h_orig = sha256_hex(canonicalize(scope_orig["record"]))
+        h_sort = sha256_hex(canonicalize(scope_sort["record"]))
+        if h_orig != h_sort:
+            print("  PASS: different scope order produces different hash")
+            passed += 1
+        else:
+            print("  FAIL: scope order should produce different hashes")
+            failed += 1
+
+
+# --- aiInvocation signing vectors ---
+if vectors.get("ai_invocation_signing"):
+    print("\n=== aiInvocation Signing ===\n")
+    for v in vectors["ai_invocation_signing"]["vectors"]:
+        canonical = canonicalize(v["record"])
+        if canonical == v["canonical"]:
+            print(f"  PASS: {v['name']} canonical form"); passed += 1
+        else:
+            print(f"  FAIL: {v['name']} canonical form"); failed += 1
+        if sha256_hex(canonical) == v["sha256_canonical"]:
+            print(f"  PASS: {v['name']} digest"); passed += 1
+        else:
+            print(f"  FAIL: {v['name']} digest"); failed += 1
+    mn = vectors["ai_invocation_signing"]["mutation_negative"]
+    h_orig = sha256_hex(canonicalize(mn["original"]["record"]))
+    h_mut = sha256_hex(canonicalize(mn["mutated"]["record"]))
+    if h_orig == mn["original"]["sha256_canonical"] and h_mut == mn["mutated"]["sha256_canonical"]:
+        print("  PASS: mutation pair digests reproduce"); passed += 1
+    else:
+        print("  FAIL: mutation pair digests reproduce"); failed += 1
+    if h_orig != h_mut:
+        print("  PASS: mutated aiInvocation changes signing digest"); passed += 1
+    else:
+        print("  FAIL: mutated aiInvocation must change signing digest"); failed += 1
+
+# --- extensionsDigest base-suite vectors ---
+if vectors.get("extensions_digest_base"):
+    print("\n=== extensionsDigest (base suite) ===\n")
+    for v in vectors["extensions_digest_base"]["vectors"]:
+        canonical = canonicalize(v["record"])
+        if canonical == v["canonical"]:
+            print(f"  PASS: {v['name']} canonical form"); passed += 1
+        else:
+            print(f"  FAIL: {v['name']} canonical form"); failed += 1
+        if sha256_hex(canonical) == v["sha256_canonical"]:
+            print(f"  PASS: {v['name']} digest"); passed += 1
+        else:
+            print(f"  FAIL: {v['name']} digest"); failed += 1
+
+# --- Summary ---
+print(f"\n=== Results: {passed} passed, {failed} failed ===")
+
+if failed > 0:
+    sys.exit(1)
+else:
+    print("\nAll vectors verified cross-language (Python).")
+    print("Canonical form: tuple-array, cross-language safe.")
+    print("Chain hash: verified via full_record_json reference string.")
+    sys.exit(0)