@mikeargento/bitgraph 1.9.1 → 1.10.0

package/src/__tests__/fuse-verify.test.ts

@@ -1,278 +0,0 @@
-// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
-
-/**
- * BitGraph Fuse: verifier paths (spec 15.4, 15.5, 15.8) on real fixture
- * proofs minted through the unmodified enclave. Every negative case runs.
- */
-
-import { describe, test } from "node:test";
-import * as assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { sha256 } from "@noble/hashes/sha256";
-import { verifyFuse, assembledAfterCommit, verifyProofIntegrity, bytesToBase64, resetEpochLinkState } from "@mikeargento/bitgraph-verify";
-import type { BitGraphProof, FuseVerifyResult } from "@mikeargento/bitgraph-verify";
-
-const FIX = fileURLToPath(new URL("../../src/__tests__/fuse-fixtures/", import.meta.url));
-const bytes = (name: string) => new Uint8Array(readFileSync(FIX + name));
-const proofOf = (name: string) => JSON.parse(readFileSync(FIX + name, "utf8")) as BitGraphProof;
-const text = (name: string) => readFileSync(FIX + name, "utf8");
-
-const original = bytes("original.txt");
-const png = bytes("image.png");
-const unrelated = new TextEncoder().encode("a file nobody recorded\n");
-
-async function run(proofName: string, file: Uint8Array, extra: Partial<Parameters<typeof verifyFuse>[0]> = {}): Promise<FuseVerifyResult> {
-  resetEpochLinkState();
-  return verifyFuse({ proof: proofOf(proofName), bytes: file, ...extra });
-}
-
-describe("path 3: the file is the committed bytes", () => {
-  test("an ordinary proof with its file is RECORDED, with the recorded statement", async () => {
-    const r = await run("recorded.proof.json", original);
-    assert.equal(r.category, "RECORDED");
-    assert.equal(r.proof.valid, true);
-    assert.equal(r.marker, null);
-    assert.match(r.statements[0]!, /existed no later than commit position/);
-  });
-
-  for (const [proofName, fusedName, placement] of [
-    ["trailer.proof.json", "fused-trailer.bin", "trailer/1"],
-    ["container.proof.json", "fused-container.tar", "container/1"],
-    ["produced-origin.proof.json", "produced-origin.json", "produced/1"],
-    ["produced-bare.proof.json", "produced-bare.json", "produced/1"],
-  ] as const) {
-    test(`${placement}: fused bytes verify FUSED_DIRECT`, async () => {
-      const r = await run(proofName, bytes(fusedName));
-      assert.equal(r.category, "FUSED_DIRECT", r.reason ?? "");
-      assert.equal(r.placement, placement);
-      assert.equal(r.marker?.source, "attribution");
-      assert.ok(r.span);
-      assert.ok(BigInt(r.span!.positions) >= 1n);
-      assert.equal(r.span!.chainId, "bitgraph:main");
-      assert.match(r.statements.at(-1)!, /could not feasibly have been finalized before their signed slot allocation at position/);
-      assert.equal(r.policy.spanExceeded, false);
-    });
-  }
-
-  test("the origin statement names what was checked: consistency on the direct path, reconstruction on the origin path", async () => {
-    const direct = await run("trailer.proof.json", bytes("fused-trailer.bin"));
-    assert.equal(direct.category, "FUSED_DIRECT");
-    assert.equal(direct.statements.length, 2);
-    assert.match(direct.statements[0]!, /origin digest that matches the signed marker/);
-    assert.match(direct.statements[0]!, /was not supplied and was not checked/);
-    assert.doesNotMatch(direct.statements[0]!, /supplied original/, "no original was supplied on the direct path");
-    const fromOrigin = await run("trailer.proof.json", original);
-    assert.equal(fromOrigin.category, "FUSED_FROM_ORIGIN");
-    assert.equal(fromOrigin.statements.length, 2);
-    assert.match(fromOrigin.statements[0]!, /supplied original rebuilds the committed fused artifact byte for byte/);
-    const bare = await run("produced-bare.proof.json", bytes("produced-bare.json"));
-    assert.equal(bare.statements.length, 1);
-    assert.equal(bare.originDigestB64, null);
-  });
-
-  test("a fused file committed under a different slot is INVALID_SLOT_COMMITMENT, never RECORDED", async () => {
-    const r = await run("wrong-slot.proof.json", bytes("fused-wrong-slot.bin"));
-    assert.equal(r.category, "INVALID_SLOT_COMMITMENT");
-    assert.equal(r.proof.valid, true, "the underlying proof is sound; only the commitment is wrong");
-    assert.match(r.reason!, /does not match the proof's slot record/);
-  });
-
-  test("an unregistered placement id is UNDETERMINED_PLACEMENT", async () => {
-    const r = await run("unregistered.proof.json", bytes("fused-unregistered.bin"));
-    assert.equal(r.category, "UNDETERMINED_PLACEMENT");
-    assert.match(r.reason!, /xmp\/9/);
-  });
-
-  test("a manifest origin hint that contradicts the origin inside the bytes is INVALID_ORIGIN_ATTRIBUTION", async () => {
-    // The signed attribution of the undeclared fixture names no origin, so the
-    // Frame's manifest supplies the hint. Trailer bytes carry the original as
-    // their prefix, and the hint (the PNG) contradicts what the bytes say.
-    const frameText = JSON.stringify({
-      type: "bitgraph-fuse/1",
-      manifest: { placement: "trailer/1", origin: { algorithm: "sha256", digest: Buffer.from(sha256(png)).toString("hex") }, artifact: { algorithm: "sha256", digest: Buffer.from(sha256(bytes("fused-trailer-undeclared.bin"))).toString("hex") }, fusedFile: null },
-      proof: proofOf("trailer-undeclared.proof.json"),
-    });
-    const r = await run("trailer-undeclared.proof.json", bytes("fused-trailer-undeclared.bin"), { frame: frameText });
-    assert.equal(r.category, "INVALID_ORIGIN_ATTRIBUTION");
-    assert.equal(r.marker?.source, "attribution", "the proof itself is signed fused");
-    assert.equal(r.marker?.originSource, "manifest", "the contradicted origin came from the manifest");
-    assert.match(r.reason!, /manifest/);
-  });
-
-  test("a manifest marker that agrees with the bytes verifies FUSED_DIRECT", async () => {
-    const r = await run("trailer-undeclared.proof.json", bytes("fused-trailer-undeclared.bin"), {
-      frame: { type: "bitgraph-fuse/1", manifest: { placement: "trailer/1", origin: { algorithm: "sha256", digest: Buffer.from(sha256(original)).toString("hex") }, artifact: { algorithm: "sha256", digest: "00".repeat(32) }, fusedFile: null }, proof: proofOf("trailer-undeclared.proof.json") },
-    });
-    assert.equal(r.category, "FUSED_DIRECT");
-    assert.equal(r.statements.length, 2);
-  });
-});
-
-describe("path 4: the file is the original", () => {
-  test("trailer/1: the original alone rebuilds and verifies FUSED_FROM_ORIGIN", async () => {
-    const r = await run("trailer.proof.json", original);
-    assert.equal(r.category, "FUSED_FROM_ORIGIN", r.reason ?? "");
-    assert.equal(r.placement, "trailer/1");
-    assert.equal(r.originDigestB64, bytesToBase64(sha256(original)));
-    assert.equal(r.statements.length, 2);
-  });
-
-  test("container/1: the PNG alone rebuilds the archive", async () => {
-    const r = await run("container.proof.json", png);
-    assert.equal(r.category, "FUSED_FROM_ORIGIN", r.reason ?? "");
-    assert.equal(r.placement, "container/1");
-  });
-
-  test("produced/1 names a source but is not rebuildable from it: RECONSTRUCTION_MISMATCH", async () => {
-    const r = await run("produced-origin.proof.json", original);
-    assert.equal(r.category, "RECONSTRUCTION_MISMATCH");
-    assert.equal(r.placement, "produced/1");
-  });
-
-  test("a manifest origin hint on a signed fused proof lets the original rebuild", async () => {
-    const r = await run("trailer-undeclared.proof.json", original, {
-      frame: { type: "bitgraph-fuse/1", manifest: { placement: "trailer/1", origin: { algorithm: "sha256", digest: Buffer.from(sha256(original)).toString("hex") }, artifact: { algorithm: "sha256", digest: "00".repeat(32) }, fusedFile: null }, proof: proofOf("trailer-undeclared.proof.json") },
-    });
-    assert.equal(r.category, "FUSED_FROM_ORIGIN");
-    assert.equal(r.placement, "trailer/1");
-    assert.equal(r.marker?.originSource, "manifest");
-  });
-
-  test("an undeclared placement resolves through the registry in fixed order and reports the match", async () => {
-    // A proof whose signed attribution has no title cannot be minted through the
-    // parent (it requires one), so undeclared placement arrives only through a
-    // Frame: strip the title here to exercise the registry scan on both paths.
-    const p = structuredClone(proofOf("trailer-undeclared.proof.json"));
-    // The title is signed; removing it breaks the signature, so instead present a
-    // Frame with no placement and rely on the signed marker having one. To reach
-    // the scan we need BOTH undeclared, which only a hypothetical name-only
-    // attribution gives; construct that case by verifying against a Frame whose
-    // proof is name-only and whose signature we re-establish is impossible here,
-    // so exercise the scan through the registry helper directly instead.
-    const frame = { type: "bitgraph-fuse/1", manifest: { origin: { algorithm: "sha256", digest: Buffer.from(sha256(original)).toString("hex") }, artifact: { algorithm: "sha256", digest: "00".repeat(32) }, fusedFile: null }, proof: p };
-    const r = await run("trailer-undeclared.proof.json", original, { frame });
-    // The signed title (trailer/1) still declares the placement; the scan is not reached.
-    assert.equal(r.category, "FUSED_FROM_ORIGIN");
-    assert.equal(r.placement, "trailer/1");
-  });
-
-  test("an unsigned manifest with a FALSE origin is RECONSTRUCTION_MISMATCH: reconstruction makes the hint self-proving", async () => {
-    // The manifest claims the PNG is the origin of the undeclared trailer fixture. The
-    // PNG's hash matches the hint, so path 4 runs, and rebuilding from the PNG cannot
-    // reproduce the signed artifact digest.
-    const r = await run("trailer-undeclared.proof.json", png, {
-      frame: { type: "bitgraph-fuse/1", manifest: { placement: "trailer/1", origin: { algorithm: "sha256", digest: Buffer.from(sha256(png)).toString("hex") }, artifact: { algorithm: "sha256", digest: "00".repeat(32) }, fusedFile: null }, proof: proofOf("trailer-undeclared.proof.json") },
-    });
-    assert.equal(r.category, "RECONSTRUCTION_MISMATCH");
-    assert.equal(r.marker?.source, "attribution", "the proof is signed fused");
-    assert.equal(r.marker?.originSource, "manifest", "the false origin was the manifest's hint");
-  });
-
-  test("an unregistered declared placement cannot rebuild: UNDETERMINED_PLACEMENT", async () => {
-    const r = await run("unregistered.proof.json", original);
-    assert.equal(r.category, "UNDETERMINED_PLACEMENT");
-  });
-
-  test("the wrong-slot fixture from its original: rebuilt bytes carry the proof's own commitment, so the hash differs", async () => {
-    const r = await run("wrong-slot.proof.json", original);
-    assert.equal(r.category, "RECONSTRUCTION_MISMATCH");
-  });
-});
-
-describe("path 5 and the underlying proof", () => {
-  test("a file matching neither digest is NO_MATCH", async () => {
-    for (const name of ["recorded.proof.json", "trailer.proof.json", "produced-bare.proof.json"]) {
-      const r = await run(name, unrelated);
-      assert.equal(r.category, "NO_MATCH", name);
-    }
-    // The fused bytes of one fixture against another fixture's proof: also NO_MATCH.
-    assert.equal((await run("container.proof.json", bytes("fused-trailer.bin"))).category, "NO_MATCH");
-  });
-
-  test("tampering with the nested proof is INVALID_UNDERLYING_PROOF and never downgrades", async () => {
-    const proof = proofOf("trailer.proof.json");
-    const cases: Array<[string, (p: BitGraphProof) => void]> = [
-      ["counter", (p) => { p.commit.counter = String(Number(p.commit.counter) + 1); }],
-      ["attribution.message (origin)", (p) => { p.attribution!.message = bytesToBase64(sha256(png)); }],
-      ["attribution.title (placement)", (p) => { p.attribution!.title = "container/1"; }],
-      ["artifact digest", (p) => { p.artifact.digestB64 = bytesToBase64(sha256(unrelated)); }],
-      ["slot record nonce", (p) => { p.slotAllocation!.nonceB64 = bytesToBase64(new Uint8Array(32)); }],
-      ["signature", (p) => { p.signer.signatureB64 = bytesToBase64(new Uint8Array(64)); }],
-    ];
-    for (const [label, mutate] of cases) {
-      const p = structuredClone(proof);
-      mutate(p);
-      resetEpochLinkState();
-      const r = await verifyFuse({ proof: p, bytes: bytes("fused-trailer.bin") });
-      assert.equal(r.category, "INVALID_UNDERLYING_PROOF", label);
-      assert.equal(r.proof.valid, false, label);
-      assert.equal(r.statements.length, 0, label);
-    }
-  });
-
-  test("tampering with the fused bytes is NO_MATCH (the digest no longer matches)", async () => {
-    const f = bytes("fused-trailer.bin");
-    f[3] = f[3]! ^ 1;
-    assert.equal((await run("trailer.proof.json", f)).category, "NO_MATCH");
-    const c = bytes("fused-trailer.bin");
-    c[c.length - 1] = c[c.length - 1]! ^ 1; // a commitment byte
-    assert.equal((await run("trailer.proof.json", c)).category, "NO_MATCH");
-  });
-
-  test("reformatting only the outer Frame changes nothing", async () => {
-    const pretty = text("trailer.bitgraph-fuse.json");
-    const compact = JSON.stringify(JSON.parse(pretty));
-    const a = await run("trailer.proof.json", bytes("fused-trailer.bin"), { frame: pretty });
-    const b = await run("trailer.proof.json", bytes("fused-trailer.bin"), { frame: compact });
-    assert.deepEqual(a, b);
-    assert.equal(a.category, "FUSED_DIRECT");
-  });
-
-  test("the ordinary verifier still accepts every fixture proof unchanged", async () => {
-    for (const name of ["recorded", "trailer", "container", "produced-origin", "produced-bare", "trailer-undeclared", "wrong-slot", "unregistered"]) {
-      resetEpochLinkState();
-      const v = await verifyProofIntegrity({ proof: proofOf(`${name}.proof.json`) });
-      assert.equal(v.valid, true, `${name}: ${v.reason ?? ""}`);
-    }
-  });
-
-  test("the span policy reports separately and never changes the category", async () => {
-    const r = await run("trailer.proof.json", bytes("fused-trailer.bin"), { maxPositions: 0 });
-    assert.equal(r.category, "FUSED_DIRECT");
-    assert.equal(r.policy.spanExceeded, true);
-    assert.equal(r.policy.maxPositions, "0");
-    const ok = await run("trailer.proof.json", bytes("fused-trailer.bin"), { maxPositions: 1_000_000 });
-    assert.equal(ok.policy.spanExceeded, false);
-  });
-
-  test("a trust policy still applies to the underlying proof", async () => {
-    const r = await run("trailer.proof.json", bytes("fused-trailer.bin"), { trustAnchors: { allowedMeasurements: ["00".repeat(48)] } });
-    assert.equal(r.category, "INVALID_UNDERLYING_PROOF");
-    assert.match(r.reason!, /measurement/i);
-  });
-});
-
-describe("strict ordering (spec 12.2)", () => {
-  test("recorded A, then fused B allocated after A committed: B assembled after A", () => {
-    const a = proofOf("recorded.proof.json");
-    const b = proofOf("trailer.proof.json");
-    assert.equal(assembledAfterCommit(a, b), true);
-  });
-  test("slot held across an ordinary commit: the strict rule does not claim B after A", () => {
-    const a = proofOf("order-held.proof.json");
-    const b = proofOf("order-fused-during-hold.proof.json");
-    assert.ok(BigInt(b.commit.slotCounter!) < BigInt(a.commit.counter!), "fixture: B's slot precedes A's commit");
-    assert.ok(BigInt(a.commit.counter!) < BigInt(b.commit.counter!), "fixture: A committed before B");
-    assert.equal(assembledAfterCommit(a, b), false);
-  });
-  test("incomparable proofs answer null", () => {
-    const a = proofOf("recorded.proof.json");
-    const b = structuredClone(proofOf("trailer.proof.json"));
-    b.commit.epochId = bytesToBase64(new Uint8Array(32).fill(5));
-    assert.equal(assembledAfterCommit(a, b), null);
-    const c = structuredClone(proofOf("trailer.proof.json"));
-    c.signer.publicKeyB64 = bytesToBase64(new Uint8Array(32).fill(6));
-    assert.equal(assembledAfterCommit(a, c), null);
-  });
-});

package/src/__tests__/hello-world.test.ts

@@ -1,10 +0,0 @@
-// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
-
-import { describe, test } from "node:test";
-import * as assert from "node:assert/strict";
-
-describe("hello world", () => {
-  test("passes", () => {
-    assert.strictEqual("hello world", "hello world");
-  });
-});

package/src/__tests__/mock-proof-fixture.ts

@@ -1,36 +0,0 @@
-/**
- * Shared mock proof fixture.
- *
- * Extracted verbatim from proof-hash.test.ts (values unchanged, byte for
- * byte) so other suites can import the fixture without importing a test
- * file (which would re-register its suites under node:test).
- *
- * Placeholder values throughout: the digest, keys, and signatures are not
- * real base64 crypto material. It is a canonical-hash and ingest fixture;
- * it fails full verification by design, always for a precise non-version
- * reason (the placeholder digest is not strict base64), never as a pass.
- */
-
-import type { BitGraphProof } from "../index.js";
-
-export const MOCK_PROOF: BitGraphProof = {
-  version: "bitgraph/1",
-  artifact: { hashAlg: "sha256", digestB64: "abc123==" },
-  commit: {
-    nonceB64: "nonce==",
-    counter: "42",
-    slotCounter: "41",
-    epochId: "epoch==",
-    prevB64: "prev==",
-  },
-  signer: {
-    publicKeyB64: "pubkey==",
-    signatureB64: "sig==",
-  },
-  environment: {
-    enforcement: "measured-tee",
-    measurement: "pcr0hash",
-    attestation: { format: "aws-nitro", reportB64: "report==" },
-  },
-  attribution: { name: "test", message: "hello" },
-};

package/src/__tests__/policy-enforcement.test.ts

@@ -1,226 +0,0 @@
-// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
-// End-to-end test for the BitGraph policy enforcement pipeline.
-
-import { test, describe } from "node:test";
-import * as assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { Constructor } from "../constructor.js";
-import { canonicalize } from "../index.js";
-import { hashPolicy, createPolicyBinding } from "../policy.js";
-import { sha256 } from "@noble/hashes/sha256";
-
-// Inline stub host for test isolation — dynamic import avoids tsc dist conflicts
-async function createTestHost(statePath: string) {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const mod = await import("bitgraph-stub" as string) as any;
-  const StubHost = mod.StubHost ?? mod.default?.StubHost;
-  return StubHost.createPersistent({
-    statePath,
-    measurement: "test",
-    enableTime: true,
-    enableCounter: true,
-  });
-}
-
-const TEST_POLICY = `# Policy: Test Policy
-version: 2.0
-
-## Allowed Tools
-- search
-- read_file
-
-## Limits
-- max_actions: 100
-- rate_limit: 10/min
-`;
-
-const TEST_POLICY_REVOKED = `# Policy: Test Policy Revoked
-version: 3.0
-
-## Allowed Tools
-- search
-
-## Limits
-- max_actions: 50
-`;
-
-describe("Policy Enforcement Pipeline", () => {
-  test("policy binding is created from markdown", () => {
-    const binding = createPolicyBinding(TEST_POLICY);
-    assert.ok(binding.digestB64, "should have digestB64");
-    assert.equal(binding.name, "Test Policy");
-    assert.equal(binding.version, "2.0");
-  });
-
-  test("policy committed as slot 0 with binding in proof", async () => {
-    const testDir = join(tmpdir(), `bitgraph-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    const stub = await createTestHost(join(testDir, "state.json"));
-
-    const constructor = await Constructor.initialize({
-      host: stub.host,
-      policy: { requireCounter: true, requireTime: true },
-    });
-
-    const binding = createPolicyBinding(TEST_POLICY);
-    const policyDigest = hashPolicy(TEST_POLICY);
-
-    const policyProof = await constructor.commitDigest({
-      digestB64: policyDigest,
-      metadata: { kind: "policy-commitment", policyName: binding.name },
-      policy: binding,
-    });
-
-    assert.ok(policyProof, "should return a proof");
-    assert.equal(policyProof.commit.counter, "1");
-    assert.ok(policyProof.policy, "proof should have policy field");
-    assert.equal(policyProof.policy!.digestB64, policyDigest);
-    assert.equal(policyProof.policy!.name, "Test Policy");
-
-    const proofHash = Buffer.from(sha256(canonicalize(policyProof))).toString("base64");
-    binding.authorProofDigestB64 = proofHash;
-    assert.ok(binding.authorProofDigestB64);
-  });
-
-  test("action proofs carry the policy binding", async () => {
-    const testDir = join(tmpdir(), `bitgraph-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    const stub = await createTestHost(join(testDir, "state.json"));
-
-    const constructor = await Constructor.initialize({
-      host: stub.host,
-      policy: { requireCounter: true, requireTime: true },
-    });
-
-    const binding = createPolicyBinding(TEST_POLICY);
-    const policyDigest = hashPolicy(TEST_POLICY);
-
-    const policyProof = await constructor.commitDigest({
-      digestB64: policyDigest,
-      metadata: { kind: "policy-commitment" },
-      policy: binding,
-    });
-
-    const proofHash = Buffer.from(sha256(canonicalize(policyProof))).toString("base64");
-    binding.authorProofDigestB64 = proofHash;
-
-    const actionDigest = Buffer.from(sha256(new TextEncoder().encode("search:query"))).toString("base64");
-    const actionProof = await constructor.commitDigest({
-      digestB64: actionDigest,
-      metadata: { kind: "tool-execution", tool: "search" },
-      prevProofHashB64: proofHash,
-      policy: binding,
-    });
-
-    assert.ok(actionProof.policy, "action proof should have policy");
-    assert.equal(actionProof.policy!.digestB64, policyDigest);
-    assert.equal(actionProof.policy!.authorProofDigestB64, proofHash);
-    assert.equal(actionProof.commit.counter, "2");
-  });
-
-  test("policy revocation updates binding", async () => {
-    const testDir = join(tmpdir(), `bitgraph-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    const stub = await createTestHost(join(testDir, "state.json"));
-
-    const constructor = await Constructor.initialize({
-      host: stub.host,
-      policy: { requireCounter: true, requireTime: true },
-    });
-
-    // Slot 0: original policy
-    const originalBinding = createPolicyBinding(TEST_POLICY);
-    const originalDigest = hashPolicy(TEST_POLICY);
-
-    const slot0Proof = await constructor.commitDigest({
-      digestB64: originalDigest,
-      metadata: { kind: "policy-commitment" },
-      policy: originalBinding,
-    });
-    const slot0Hash = Buffer.from(sha256(canonicalize(slot0Proof))).toString("base64");
-    originalBinding.authorProofDigestB64 = slot0Hash;
-
-    // Action under original policy
-    const action1 = await constructor.commitDigest({
-      digestB64: Buffer.from(sha256(new TextEncoder().encode("action1"))).toString("base64"),
-      metadata: { kind: "tool-execution", tool: "read_file" },
-      prevProofHashB64: slot0Hash,
-      policy: originalBinding,
-    });
-    assert.equal(action1.policy!.digestB64, originalDigest);
-
-    // Revoke: commit new policy
-    const revokedBinding = createPolicyBinding(TEST_POLICY_REVOKED);
-    const revokedDigest = hashPolicy(TEST_POLICY_REVOKED);
-
-    const action1Hash = Buffer.from(sha256(canonicalize(action1))).toString("base64");
-    const revokeProof = await constructor.commitDigest({
-      digestB64: revokedDigest,
-      metadata: { kind: "policy-change", removed: ["read_file"] },
-      prevProofHashB64: action1Hash,
-      policy: revokedBinding,
-    });
-    const revokeHash = Buffer.from(sha256(canonicalize(revokeProof))).toString("base64");
-    revokedBinding.authorProofDigestB64 = revokeHash;
-
-    // Action under new (revoked) policy
-    const action2 = await constructor.commitDigest({
-      digestB64: Buffer.from(sha256(new TextEncoder().encode("action2"))).toString("base64"),
-      metadata: { kind: "tool-execution", tool: "search" },
-      prevProofHashB64: revokeHash,
-      policy: revokedBinding,
-    });
-
-    assert.equal(action2.policy!.digestB64, revokedDigest);
-    assert.equal(action2.policy!.authorProofDigestB64, revokeHash);
-    assert.notEqual(action2.policy!.digestB64, originalDigest);
-  });
-
-  test("causal ordering: policy counter < action counter", async () => {
-    const testDir = join(tmpdir(), `bitgraph-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    const stub = await createTestHost(join(testDir, "state.json"));
-
-    const constructor = await Constructor.initialize({
-      host: stub.host,
-      policy: { requireCounter: true, requireTime: true },
-    });
-
-    const binding = createPolicyBinding(TEST_POLICY);
-
-    const policyProof = await constructor.commitDigest({
-      digestB64: hashPolicy(TEST_POLICY),
-      metadata: { kind: "policy-commitment" },
-      policy: binding,
-    });
-    const policyCounter = BigInt(policyProof.commit.counter ?? "0");
-
-    const proofHash = Buffer.from(sha256(canonicalize(policyProof))).toString("base64");
-    binding.authorProofDigestB64 = proofHash;
-
-    for (let i = 1; i <= 3; i++) {
-      const actionProof = await constructor.commitDigest({
-        digestB64: Buffer.from(sha256(new TextEncoder().encode(`action-${i}`))).toString("base64"),
-        metadata: { kind: "tool-execution", tool: "search" },
-        policy: binding,
-      });
-      const actionCounter = BigInt(actionProof.commit.counter ?? "0");
-      assert.ok(actionCounter > policyCounter, `action ${i} counter (${actionCounter}) > policy counter (${policyCounter})`);
-    }
-  });
-
-  test("hashPolicy produces consistent digest", () => {
-    const digest1 = hashPolicy(TEST_POLICY);
-    const digest2 = hashPolicy(TEST_POLICY);
-    assert.equal(digest1, digest2);
-
-    const digest3 = hashPolicy(TEST_POLICY_REVOKED);
-    assert.notEqual(digest1, digest3);
-  });
-});

package/src/__tests__/proof-hash-regression.test.ts

@@ -1,107 +0,0 @@
-/**
- * Regression test: all code paths must produce identical proofHash.
- *
- * Simulates the hash computation as done by:
- *   1. computeProofHash() from bitgraph (canonical)
- *   2. Inline signed-body + canonicalize + sha256 (how ledger s3.ts USED to do it)
- *   3. Any other path
- *
- * If these ever diverge, this test fails.
- */
-import { describe, it } from "node:test";
-import * as assert from "node:assert/strict";
-import { sha256 } from "@noble/hashes/sha256";
-import { computeProofHash, canonicalize } from "../index.js";
-// Fixture extracted verbatim to a shared non-test module so other suites
-// (audit attestation honesty tests) can import it without re-registering
-// this file's suites. Values unchanged.
-import { REALISTIC_PROOF } from "./realistic-proof-fixture.js";
-
-/**
- * Inline signed-body hash — the OLD way ledger s3.ts computed it.
- * This must produce the same result as computeProofHash().
- */
-function inlineSignedBodyHash(proof: Record<string, unknown>): string {
-  const signer = proof.signer as { publicKeyB64: string };
-  const env = proof.environment as { enforcement: string; measurement: string; attestation?: { format: string } };
-
-  const signedBody: Record<string, unknown> = {
-    version: proof.version,
-    artifact: proof.artifact,
-    commit: proof.commit,
-    publicKeyB64: signer.publicKeyB64,
-    enforcement: env.enforcement,
-    measurement: env.measurement,
-  };
-  if (proof.attribution) signedBody.attribution = proof.attribution;
-  if (env.attestation) signedBody.attestationFormat = env.attestation.format;
-
-  return Buffer.from(sha256(canonicalize(signedBody))).toString("base64");
-}
-
-describe("proof hash regression — all paths must agree", () => {
-  it("computeProofHash matches inline signed-body hash (with attribution)", () => {
-    const canonical = computeProofHash(REALISTIC_PROOF);
-    const inline = inlineSignedBodyHash(REALISTIC_PROOF);
-    assert.equal(canonical, inline, "hash drift detected: computeProofHash vs inline");
-  });
-
-  it("computeProofHash matches inline signed-body hash (without attribution)", () => {
-    const noAttr = { ...REALISTIC_PROOF } as Record<string, unknown>;
-    delete noAttr.attribution;
-    const canonical = computeProofHash(noAttr);
-    const inline = inlineSignedBodyHash(noAttr);
-    assert.equal(canonical, inline, "hash drift detected without attribution");
-  });
-
-  it("computeProofHash matches inline signed-body hash (without attestation)", () => {
-    const noAttest = {
-      ...REALISTIC_PROOF,
-      environment: {
-        enforcement: REALISTIC_PROOF.environment.enforcement,
-        measurement: REALISTIC_PROOF.environment.measurement,
-      },
-    };
-    const canonical = computeProofHash(noAttest);
-    const inline = inlineSignedBodyHash(noAttest);
-    assert.equal(canonical, inline, "hash drift detected without attestation");
-  });
-
-  it("anchor proof and user proof use the same hash function", () => {
-    // User proof (no attribution)
-    const userProof = { ...REALISTIC_PROOF } as Record<string, unknown>;
-    delete userProof.attribution;
-
-    // Anchor proof (has attribution)
-    const anchorProof = REALISTIC_PROOF;
-
-    // Both should work with the same function
-    const userHash = computeProofHash(userProof);
-    const anchorHash = computeProofHash(anchorProof);
-
-    // They should be different (different inputs) but both valid
-    assert.notEqual(userHash, anchorHash, "user and anchor proofs with different data should differ");
-    assert.equal(Buffer.from(userHash, "base64").length, 32, "user hash should be SHA-256");
-    assert.equal(Buffer.from(anchorHash, "base64").length, 32, "anchor hash should be SHA-256");
-  });
-
-  it("adding slotAllocation or metadata does not change hash", () => {
-    const bare = { ...REALISTIC_PROOF } as Record<string, unknown>;
-    delete bare.slotAllocation;
-
-    const withSlot = { ...REALISTIC_PROOF };
-
-    const withMetadata = {
-      ...REALISTIC_PROOF,
-      metadata: { type: "ethereum-anchor", extra: true },
-      timestamps: { artifact: { time: 1234567890 } },
-    };
-
-    const bareHash = computeProofHash(bare);
-    const withSlotHash = computeProofHash(withSlot);
-    const withMetaHash = computeProofHash(withMetadata);
-
-    assert.equal(bareHash, withSlotHash, "slotAllocation should not affect hash");
-    assert.equal(bareHash, withMetaHash, "metadata/timestamps should not affect hash");
-  });
-});