@agentauditai/mcp-server 0.0.0-stage → 2.0.0

package/dist/tools/verify/src/evidence.js

@@ -0,0 +1,152 @@
+"use strict";
+// AgentAudit AI — Evidence Schema v1 primitives for the standalone verifier:
+// JCS (RFC 8785) canonicalization, action_ref and the AuditVault v2 Merkle tree.
+// Self-contained on purpose: no import from sdk/ or packages/, so the verifier
+// re-derives everything independently of the code that produced the bundle.
+// EU AI Act: Art. 12 (record-keeping), Art. 19 (log retention)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREIMAGE_FIELDS = exports.ODD_NODE = exports.NODE_HASH = exports.LEAF_HASH = exports.SCHEMA = void 0;
+exports.jcs = jcs;
+exports.preimageProblem = preimageProblem;
+exports.actionRef = actionRef;
+exports.hashPair = hashPair;
+exports.merkleRoot = merkleRoot;
+exports.merkleProof = merkleProof;
+exports.verifyProof = verifyProof;
+const crypto_1 = require("crypto");
+const ethers_1 = require("ethers");
+// ─── Constants ────────────────────────────────────────────────────────────────
+exports.SCHEMA = "agentaudit-evidence-v1";
+exports.LEAF_HASH = "sha256(jcs(preimage))";
+exports.NODE_HASH = "keccak256(sorted_pair)";
+exports.ODD_NODE = "promote";
+/** The only fields that enter the preimage (docs/EVIDENCE_SCHEMA.md §1.1) */
+exports.PREIMAGE_FIELDS = ["action_type", "agent_id", "scope", "timestamp_ms"];
+const BYTES32_RE = /^0x[0-9a-f]{64}$/;
+// ─── JCS (RFC 8785) ───────────────────────────────────────────────────────────
+function hasLoneSurrogate(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const next = s.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                i++;
+                continue;
+            }
+            return true;
+        }
+        if (c >= 0xdc00 && c <= 0xdfff)
+            return true;
+    }
+    return false;
+}
+function jcsString(s) {
+    // RFC 8785 §3.2.2.2: strings must be valid Unicode; JSON.stringify's escaping
+    // (\b \t \n \f \r \" \\, other C0 as lowercase \u00xx) is exactly JCS's.
+    if (hasLoneSurrogate(s))
+        throw new Error("JCS: string contains a lone surrogate");
+    return JSON.stringify(s);
+}
+/**
+ * RFC 8785 canonical JSON. Numbers use ECMAScript Number serialization (what
+ * JSON.stringify emits for finite numbers, -0 → 0); object keys are sorted by
+ * UTF-16 code units, which is Array.prototype.sort's default order.
+ */
+function jcs(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("JCS: non-finite number");
+        return JSON.stringify(value);
+    }
+    if (typeof value === "string")
+        return jcsString(value);
+    if (Array.isArray(value))
+        return "[" + value.map(jcs).join(",") + "]";
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return "{" + keys.map((k) => jcsString(k) + ":" + jcs(obj[k])).join(",") + "}";
+    }
+    throw new Error(`JCS: unsupported type ${typeof value}`);
+}
+// ─── action_ref ───────────────────────────────────────────────────────────────
+/** Why a preimage is not a valid Evidence Schema v1 preimage, or null */
+function preimageProblem(preimage) {
+    if (typeof preimage !== "object" || preimage === null || Array.isArray(preimage)) {
+        return "preimage is not an object";
+    }
+    const p = preimage;
+    const extra = Object.keys(p).filter((k) => !exports.PREIMAGE_FIELDS.includes(k));
+    if (extra.length > 0)
+        return `preimage has non-schema field(s): ${extra.join(", ")}`;
+    for (const f of ["action_type", "agent_id", "scope"]) {
+        if (typeof p[f] !== "string")
+            return `preimage.${f} must be a string`;
+    }
+    if (!Number.isSafeInteger(p.timestamp_ms))
+        return "preimage.timestamp_ms must be a safe integer";
+    return null;
+}
+/** 0x-prefixed lowercase SHA-256 of the UTF-8 JCS bytes */
+function actionRef(preimage) {
+    return "0x" + (0, crypto_1.createHash)("sha256").update(jcs(preimage), "utf8").digest("hex");
+}
+// ─── Merkle tree (AuditVault v2) ──────────────────────────────────────────────
+/** keccak256(abi.encodePacked(min(a, b), max(a, b))) — AuditVault._verifyMerkle's step */
+function hashPair(a, b) {
+    const [lo, hi] = a <= b ? [a, b] : [b, a];
+    return ethers_1.ethers.keccak256(ethers_1.ethers.concat([lo, hi]));
+}
+function assertLeaves(leaves) {
+    if (leaves.length === 0)
+        throw new Error("Merkle tree needs at least one leaf");
+    for (const l of leaves) {
+        if (!BYTES32_RE.test(l))
+            throw new Error(`leaf is not lowercase 0x-bytes32: ${l}`);
+    }
+}
+/** Every level, leaves first; an unpaired last node is promoted unchanged */
+function levels(leaves) {
+    assertLeaves(leaves);
+    const out = [leaves];
+    while (out[out.length - 1].length > 1) {
+        const cur = out[out.length - 1];
+        const next = [];
+        for (let i = 0; i < cur.length; i += 2) {
+            next.push(i + 1 < cur.length ? hashPair(cur[i], cur[i + 1]) : cur[i]);
+        }
+        out.push(next);
+    }
+    return out;
+}
+function merkleRoot(leaves) {
+    const lv = levels(leaves);
+    return lv[lv.length - 1][0];
+}
+/** Sibling path for leaves[index]; promoted levels contribute no element */
+function merkleProof(leaves, index) {
+    const lv = levels(leaves);
+    if (!Number.isInteger(index) || index < 0 || index >= leaves.length) {
+        throw new Error(`leaf index ${index} out of range`);
+    }
+    const proof = [];
+    let i = index;
+    for (let d = 0; d < lv.length - 1; d++) {
+        const sibling = i ^ 1;
+        if (sibling < lv[d].length)
+            proof.push(lv[d][sibling]);
+        i >>= 1;
+    }
+    return proof;
+}
+/** Local mirror of AuditVault._verifyMerkle */
+function verifyProof(leaf, proof, root) {
+    let computed = leaf.toLowerCase();
+    for (const p of proof)
+        computed = hashPair(computed, p.toLowerCase());
+    return computed === root.toLowerCase();
+}

package/dist/tools/verify/src/verify.d.ts

@@ -0,0 +1,58 @@
+export type CheckStatus = "PASS" | "FAIL";
+export interface Check {
+    name: string;
+    status: CheckStatus;
+    detail: string;
+}
+export interface VerifyResult {
+    ok: boolean;
+    checks: Check[];
+    /** Context that is reported but not pass/fail (e.g. submitter when not pinned) */
+    info: string[];
+}
+export interface LogLike {
+    address: string;
+    topics: readonly string[];
+    data: string;
+}
+export interface ReceiptLike {
+    status: number | null;
+    blockNumber: number;
+    logs: readonly LogLike[];
+}
+/** The chain reads the verifier needs; EthersChainReader is the real one */
+export interface ChainReader {
+    chainId(): Promise<bigint>;
+    getCode(address: string): Promise<string>;
+    getReceipt(txHash: string): Promise<ReceiptLike | null>;
+    getBatchSubmitter(vault: string, agentId: string, batchIndex: bigint): Promise<string>;
+    verifyLog(vault: string, agentId: string, batchIndex: bigint, leaf: string, proof: string[]): Promise<boolean>;
+}
+export interface VerifyOptions {
+    reader: ChainReader;
+    /** AuditVault v2 address; defaults to the known deployment for meta.anchor.chain */
+    vault?: string;
+    /** If set, LogBatch.submitter must equal it (THREAT_MODEL KI-1) */
+    submitter?: string;
+}
+export declare const AUDIT_VAULT_V2_ABI: string[];
+/** Chains with a known chain id and, where deployed, AuditVault v2 */
+export declare const KNOWN_CHAINS: Record<string, {
+    chainId: bigint;
+    vault?: string;
+}>;
+export declare class EthersChainReader implements ChainReader {
+    private readonly provider;
+    constructor(rpcUrl: string, timeoutMs?: number);
+    chainId(): Promise<bigint>;
+    getCode(address: string): Promise<string>;
+    getReceipt(txHash: string): Promise<ReceiptLike | null>;
+    getBatchSubmitter(vault: string, agentId: string, batchIndex: bigint): Promise<string>;
+    verifyLog(vault: string, agentId: string, batchIndex: bigint, leaf: string, proof: string[]): Promise<boolean>;
+    destroy(): void;
+}
+/**
+ * Runs every check it can and never throws: a failed prerequisite turns its
+ * dependent checks into FAILs with the reason, so the report is always complete.
+ */
+export declare function verifyBundle(bundleInput: unknown, opts: VerifyOptions): Promise<VerifyResult>;

package/dist/tools/verify/src/verify.js

@@ -0,0 +1,312 @@
+"use strict";
+// AgentAudit AI — verifies an Evidence Schema v1 bundle end to end: preimages →
+// action_refs → Merkle root → AuditVault v2 LogBatchCommitted → verifyLog.
+// Applies the verifier mitigations in docs/THREAT_MODEL.md (KI-1, KI-2).
+// EU AI Act: Art. 12 (record-keeping), Art. 19 (log retention)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthersChainReader = exports.KNOWN_CHAINS = exports.AUDIT_VAULT_V2_ABI = void 0;
+exports.verifyBundle = verifyBundle;
+const ethers_1 = require("ethers");
+const evidence_1 = require("./evidence");
+// ─── Constants ────────────────────────────────────────────────────────────────
+exports.AUDIT_VAULT_V2_ABI = [
+    "event LogBatchCommitted(address indexed agentId, uint256 indexed batchIndex, bytes32 merkleRoot, string contentURI, uint256 eventCount, uint8 complianceScore, uint256 timestamp)",
+    "function verifyLog(address agentId, uint256 batchIndex, bytes32 logHash, bytes32[] proof) view returns (bool)",
+    "function getBatch(address agentId, uint256 batchIndex) view returns (tuple(bytes32 merkleRoot, string contentURI, uint256 timestamp, uint256 blockNumber, uint256 eventCount, address submitter, uint8 complianceScore))",
+];
+/** Chains with a known chain id and, where deployed, AuditVault v2 */
+exports.KNOWN_CHAINS = {
+    base: { chainId: 8453n, vault: "0xCeE831070aa9081422f30df5559c125aa47A75DB" },
+    anvil: { chainId: 31337n },
+};
+const BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
+const iface = new ethers_1.ethers.Interface(exports.AUDIT_VAULT_V2_ABI);
+const BATCH_TOPIC = iface.getEvent("LogBatchCommitted").topicHash;
+// ─── Chain reader ─────────────────────────────────────────────────────────────
+class EthersChainReader {
+    constructor(rpcUrl, timeoutMs = 30000) {
+        const req = new ethers_1.ethers.FetchRequest(rpcUrl);
+        req.timeout = timeoutMs;
+        // staticNetwork: an unreachable RPC fails the call instead of retrying network detection forever
+        this.provider = new ethers_1.ethers.JsonRpcProvider(req, undefined, { staticNetwork: true });
+    }
+    async chainId() {
+        return BigInt(await this.provider.send("eth_chainId", []));
+    }
+    getCode(address) {
+        return this.provider.getCode(address);
+    }
+    async getReceipt(txHash) {
+        return this.provider.getTransactionReceipt(txHash);
+    }
+    async getBatchSubmitter(vault, agentId, batchIndex) {
+        const batch = await new ethers_1.ethers.Contract(vault, exports.AUDIT_VAULT_V2_ABI, this.provider).getBatch(agentId, batchIndex);
+        return batch.submitter;
+    }
+    async verifyLog(vault, agentId, batchIndex, leaf, proof) {
+        return (await new ethers_1.ethers.Contract(vault, exports.AUDIT_VAULT_V2_ABI, this.provider).verifyLog(agentId, batchIndex, leaf, proof));
+    }
+    destroy() {
+        this.provider.destroy();
+    }
+}
+exports.EthersChainReader = EthersChainReader;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function errorMessage(err) {
+    if (err && typeof err === "object" && "shortMessage" in err)
+        return String(err.shortMessage);
+    return err instanceof Error ? err.message : String(err);
+}
+function short(hex) {
+    return hex.length > 18 ? `${hex.slice(0, 10)}…${hex.slice(-6)}` : hex;
+}
+function asObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+}
+/** Bare or 0x 64-hex → 0x lowercase, else null */
+function normRoot(v) {
+    if (typeof v !== "string")
+        return null;
+    const hex = v.startsWith("0x") ? v : "0x" + v;
+    return BYTES32_RE.test(hex) ? hex.toLowerCase() : null;
+}
+// ─── Functions ────────────────────────────────────────────────────────────────
+/**
+ * Runs every check it can and never throws: a failed prerequisite turns its
+ * dependent checks into FAILs with the reason, so the report is always complete.
+ */
+async function verifyBundle(bundleInput, opts) {
+    const checks = [];
+    const info = [];
+    const pass = (name, detail) => checks.push({ name, status: "PASS", detail });
+    const fail = (name, detail) => checks.push({ name, status: "FAIL", detail });
+    const done = () => ({ ok: checks.length > 0 && checks.every((c) => c.status === "PASS"), checks, info });
+    // ── 1. Bundle shape ──
+    const bundle = asObject(bundleInput);
+    if (!bundle) {
+        fail("bundle.schema", "bundle is not a JSON object");
+        return done();
+    }
+    const entries = Array.isArray(bundle.entries) ? bundle.entries : null;
+    const shapeProblems = [];
+    if (bundle.schema !== evidence_1.SCHEMA)
+        shapeProblems.push(`schema is ${JSON.stringify(bundle.schema)}, expected "${evidence_1.SCHEMA}"`);
+    if (bundle.leaf_hash !== evidence_1.LEAF_HASH)
+        shapeProblems.push(`leaf_hash is ${JSON.stringify(bundle.leaf_hash)}, expected "${evidence_1.LEAF_HASH}"`);
+    if (bundle.node_hash !== evidence_1.NODE_HASH)
+        shapeProblems.push(`node_hash is ${JSON.stringify(bundle.node_hash)}, expected "${evidence_1.NODE_HASH}"`);
+    if (bundle.odd_node !== evidence_1.ODD_NODE)
+        shapeProblems.push(`odd_node is ${JSON.stringify(bundle.odd_node)}, expected "${evidence_1.ODD_NODE}"`);
+    if (!entries || entries.length === 0)
+        shapeProblems.push("entries is missing or empty");
+    const claimedRoot = normRoot(bundle.merkle_root);
+    if (!claimedRoot)
+        shapeProblems.push("merkle_root is not a 32-byte hex string");
+    if (shapeProblems.length > 0) {
+        // Without the v1 tree rules nothing below is meaningful
+        fail("bundle.schema", shapeProblems.join("; "));
+        return done();
+    }
+    pass("bundle.schema", `${evidence_1.SCHEMA}, ${entries.length} entries`);
+    // ── 2. action_ref per entry (recomputed — never trust the presented leaf, KI-2) ──
+    const leaves = [];
+    entries.forEach((raw, i) => {
+        const name = `entry[${i}].action_ref`;
+        const entry = asObject(raw);
+        if (!entry) {
+            fail(name, "entry is not an object");
+            leaves.push(null);
+            return;
+        }
+        const problem = (0, evidence_1.preimageProblem)(entry.preimage);
+        if (problem) {
+            fail(name, problem);
+            leaves.push(null);
+            return;
+        }
+        let computed;
+        try {
+            computed = (0, evidence_1.actionRef)(entry.preimage);
+        }
+        catch (err) {
+            fail(name, errorMessage(err));
+            leaves.push(null);
+            return;
+        }
+        leaves.push(computed);
+        const presented = typeof entry.action_ref === "string" ? entry.action_ref.toLowerCase() : entry.action_ref;
+        if (presented === computed)
+            pass(name, computed);
+        else
+            fail(name, `sha256(jcs(preimage)) = ${computed}, bundle says ${String(entry.action_ref)}`);
+    });
+    // ── 3. Merkle root ──
+    const allLeaves = leaves.every((l) => l !== null);
+    if (!allLeaves) {
+        fail("merkle_root", "cannot rebuild the tree: some preimages are invalid");
+    }
+    else {
+        const rebuilt = (0, evidence_1.merkleRoot)(leaves);
+        if (rebuilt === claimedRoot)
+            pass("merkle_root", `rebuilt ${rebuilt}`);
+        else
+            fail("merkle_root", `rebuilt ${rebuilt}, bundle says ${claimedRoot}`);
+    }
+    // ── 4. Anchor reference ──
+    const anchor = asObject(asObject(bundle.meta)?.anchor);
+    const txHash = typeof anchor?.txHash === "string" ? anchor.txHash : null;
+    const chain = typeof anchor?.chain === "string" ? anchor.chain : null;
+    if (!anchor || !txHash || !/^0x[0-9a-fA-F]{64}$/.test(txHash)) {
+        fail("anchor.reference", "meta.anchor.txHash is missing or not a 32-byte 0x hex string");
+        return done();
+    }
+    const rootCommitment = normRoot(anchor.rootCommitment);
+    if (anchor.rootCommitment !== undefined && rootCommitment !== claimedRoot) {
+        fail("anchor.reference", `meta.anchor.rootCommitment ${String(anchor.rootCommitment)} ≠ merkle_root ${claimedRoot}`);
+    }
+    else {
+        pass("anchor.reference", `chain ${chain ?? "(unset)"}, tx ${txHash}`);
+    }
+    const known = chain ? exports.KNOWN_CHAINS[chain] : undefined;
+    const vault = opts.vault ?? known?.vault;
+    if (!vault || !ethers_1.ethers.isAddress(vault)) {
+        fail("anchor.vault", vault ? `--vault ${vault} is not an address` : `no known AuditVault v2 for chain ${JSON.stringify(chain)}; pass --vault`);
+        return done();
+    }
+    const vaultAddr = ethers_1.ethers.getAddress(vault);
+    const { reader } = opts;
+    // ── 5. RPC chain + vault code ──
+    try {
+        const id = await reader.chainId();
+        if (known && id !== known.chainId)
+            fail("rpc.chain", `RPC is chain ${id}, meta.anchor.chain "${chain}" is ${known.chainId}`);
+        else
+            pass("rpc.chain", known ? `chain id ${id} = ${chain}` : `chain id ${id} (chain "${chain}" not in the known list, not cross-checked)`);
+        const code = await reader.getCode(vaultAddr);
+        if (code === "0x") {
+            fail("anchor.vault", `no contract code at ${vaultAddr}`);
+            return done();
+        }
+        pass("anchor.vault", `${vaultAddr}${opts.vault ? "" : ` (default for ${chain})`}`);
+    }
+    catch (err) {
+        fail("rpc.chain", `RPC error: ${errorMessage(err)}`);
+        return done();
+    }
+    // ── 6. Receipt + LogBatchCommitted ──
+    let receipt;
+    try {
+        receipt = await reader.getReceipt(txHash);
+    }
+    catch (err) {
+        fail("anchor.receipt", `RPC error: ${errorMessage(err)}`);
+        return done();
+    }
+    if (!receipt) {
+        fail("anchor.receipt", `transaction ${txHash} not found (no receipt)`);
+        return done();
+    }
+    if (receipt.status !== 1) {
+        fail("anchor.receipt", `transaction reverted (status ${receipt.status}) in block ${receipt.blockNumber}`);
+        return done();
+    }
+    pass("anchor.receipt", `status 1, block ${receipt.blockNumber}`);
+    const batchLogs = receipt.logs
+        .filter((l) => ethers_1.ethers.getAddress(l.address) === vaultAddr && l.topics[0] === BATCH_TOPIC)
+        .map((l) => iface.parseLog({ topics: [...l.topics], data: l.data }));
+    if (batchLogs.length === 0) {
+        fail("anchor.event", `transaction emitted no LogBatchCommitted from ${vaultAddr}`);
+        return done();
+    }
+    // A tx could commit several batches; prefer the one carrying our root
+    const ev = batchLogs.find((l) => l.args.merkleRoot.toLowerCase() === claimedRoot) ?? batchLogs[0];
+    const onChainRoot = ev.args.merkleRoot.toLowerCase();
+    const agentId = ethers_1.ethers.getAddress(ev.args.agentId);
+    const batchIndex = ev.args.batchIndex;
+    const eventCount = ev.args.eventCount;
+    info.push(`batch agentId ${agentId}, batchIndex ${batchIndex}, contentURI ${String(ev.args.contentURI)}`);
+    if (onChainRoot === claimedRoot)
+        pass("anchor.event", `LogBatchCommitted root ${onChainRoot}`);
+    else
+        fail("anchor.event", `on-chain root ${onChainRoot} ≠ merkle_root ${claimedRoot}`);
+    if (eventCount === BigInt(entries.length))
+        pass("anchor.event_count", `${eventCount}`);
+    else
+        fail("anchor.event_count", `on-chain eventCount ${eventCount}, bundle has ${entries.length} entries`);
+    // ── 7. Submitter (KI-1) ──
+    try {
+        const submitter = ethers_1.ethers.getAddress(await reader.getBatchSubmitter(vaultAddr, agentId, batchIndex));
+        if (!opts.submitter) {
+            info.push(`submitter ${submitter} — not checked (commitBatch is permissionless; pin it with --submitter)`);
+        }
+        else if (ethers_1.ethers.isAddress(opts.submitter) && ethers_1.ethers.getAddress(opts.submitter) === submitter) {
+            pass("anchor.submitter", submitter);
+        }
+        else {
+            fail("anchor.submitter", `LogBatch.submitter is ${submitter}, expected ${opts.submitter}`);
+        }
+    }
+    catch (err) {
+        if (opts.submitter)
+            fail("anchor.submitter", `getBatch failed: ${errorMessage(err)}`);
+        else
+            info.push(`submitter unavailable: ${errorMessage(err)}`);
+    }
+    // ── 8. verifyLog per entry ──
+    // The leaf is always the recomputed action_ref. Proof siblings are only path
+    // data, so besides the recomputed tree we may also try the tree of the
+    // presented action_refs: after one tampered preimage, every recomputed path
+    // runs through the tampered subtree, and only the presented values let the
+    // intact entries still prove inclusion — which localizes the bad one.
+    const presented = entries.map((raw) => {
+        const ref = asObject(raw)?.action_ref;
+        return typeof ref === "string" && BYTES32_RE.test(ref) ? ref.toLowerCase() : null;
+    });
+    const siblingTrees = [];
+    if (allLeaves)
+        siblingTrees.push(["derived proof", leaves]);
+    if (presented.every((p) => p !== null) && !(allLeaves && presented.every((p, i) => p === leaves[i]))) {
+        siblingTrees.push(["proof from bundle action_refs", presented]);
+    }
+    for (let i = 0; i < entries.length; i++) {
+        const name = `entry[${i}].verifyLog`;
+        const leaf = leaves[i];
+        if (!leaf) {
+            fail(name, "skipped: action_ref could not be recomputed");
+            continue;
+        }
+        const entry = asObject(entries[i]);
+        let candidates;
+        if (entry.proof !== undefined) {
+            if (!Array.isArray(entry.proof) || !entry.proof.every((p) => typeof p === "string" && BYTES32_RE.test(p))) {
+                fail(name, "entry.proof is not an array of bytes32 hex strings");
+                continue;
+            }
+            candidates = [["bundle proof", entry.proof]];
+        }
+        else if (siblingTrees.length > 0) {
+            candidates = siblingTrees.map(([source, tree]) => [source, (0, evidence_1.merkleProof)(tree, i)]);
+        }
+        else {
+            fail(name, "skipped: no entry.proof and no tree to derive one from");
+            continue;
+        }
+        try {
+            let passed;
+            for (const [source, proof] of candidates) {
+                if (await reader.verifyLog(vaultAddr, agentId, batchIndex, leaf, proof)) {
+                    passed = [source, proof];
+                    break;
+                }
+            }
+            if (passed)
+                pass(name, `true (${passed[0]}, ${passed[1].length} node${passed[1].length === 1 ? "" : "s"}, leaf ${short(leaf)})`);
+            else
+                fail(name, `AuditVault.verifyLog returned false (${candidates.map((c) => c[0]).join(", ")}; leaf ${short(leaf)})`);
+        }
+        catch (err) {
+            fail(name, `call failed: ${errorMessage(err)}`);
+        }
+    }
+    return done();
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@agentauditai/mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "MCP server for AgentAudit: EU AI Act audit logging on AuditVault v2 (Base), incident reporting (Art. 73) and compliance reads.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentauditAI/AgentAudit.git",
+    "directory": "packages/mcp-server"
+  },
+  "homepage": "https://github.com/agentauditAI/AgentAudit/tree/main/packages/mcp-server#readme",
+  "keywords": ["mcp", "model-context-protocol", "eu-ai-act", "audit", "agentaudit", "base"],
+  "main": "dist/src/mcp-server.js",
+  "types": "dist/src/mcp-server.d.ts",
+  "bin": {
+    "agentaudit-mcp": "dist/src/mcp-server.js"
+  },
+  "files": [
+    "dist/src",
+    "dist/sdk/src",
+    "dist/tools/verify/src",
+    "dist/deployments",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/clean.js && tsc -p tsconfig.build.json && node scripts/copy-deployments.js",
+    "prepack": "npm run build",
+    "smoke": "node scripts/smoke.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "dotenv": "^16.0.0",
+    "ethers": "^6.16.0",
+    "zod": "^4.4.3"
+  },
+  "engines": { "node": ">=18" }
+}