@agentauditai/mcp-server 0.0.0-stage → 3.0.0

package/dist/src/mcp-server.js

@@ -0,0 +1,541 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionsFromEnv = optionsFromEnv;
+exports.createServer = createServer;
+require("dotenv/config");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const ethers_1 = require("ethers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("../sdk/src/index");
+const verify_1 = require("../tools/verify/src/verify");
+const evidence_1 = require("../tools/verify/src/evidence");
+// ─── Deployment Addresses ────────────────────────────────────────────────────
+const DEPLOYMENTS_DIR = path.join(__dirname, "..", "deployments");
+const NETWORKS = ["mantle", "base", "arbitrum", "optimism", "polygon"];
+const DEPLOYMENT_FILES = {
+    mantle: "phase7-mantle.json",
+    base: "phase7-base.json",
+    arbitrum: "phase7-arbitrumOne.json",
+    optimism: "phase7-optimism.json",
+    polygon: "phase7-polygon.json",
+};
+function loadDeployment(network) {
+    const filePath = path.join(DEPLOYMENTS_DIR, DEPLOYMENT_FILES[network]);
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return raw.contracts;
+}
+const DEFAULT_RPC_URLS = {
+    mantle: "https://rpc.mantle.xyz",
+    base: "https://mainnet.base.org",
+    arbitrum: "https://arb1.arbitrum.io/rpc",
+    optimism: "https://mainnet.optimism.io",
+    polygon: "https://polygon-bor-rpc.publicnode.com",
+};
+/** Options read from the environment — what the stdio entry point uses */
+function optionsFromEnv(env = process.env) {
+    const rpcUrls = {};
+    const auditVaults = {};
+    for (const net of NETWORKS) {
+        const rpc = env[`RPC_${net.toUpperCase()}`];
+        if (rpc)
+            rpcUrls[net] = rpc;
+        const vault = env[`AUDIT_VAULT_${net.toUpperCase()}`];
+        if (vault)
+            auditVaults[net] = vault;
+    }
+    // unset or "" → default code; "false" / "off" / "0" → off; anything else → custom code
+    return { privateKey: env.PRIVATE_KEY, rpcUrls, auditVaults, builderCode: (0, index_1.builderCodeFromEnv)(env.AGENTAUDIT_BUILDER_CODE) };
+}
+// ─── ABIs ────────────────────────────────────────────────────────────────────
+const VAULT_ABI = [...verify_1.AUDIT_VAULT_V2_ABI, "function getBatchCount(address agentId) view returns (uint256)"];
+const RISK_ABI = [
+    "function openRiskCount(bytes32 agentId) external view returns (uint256)",
+    "function risksAboveSeverity(bytes32 agentId, uint8 minSeverity) external view returns (uint256)",
+    "function getAgentRisks(bytes32 agentId) external view returns (uint256[])",
+    "function risks(uint256 id) external view returns (uint256 id, bytes32 agentId, uint8 category, uint8 severity, uint8 status, string description, string evidenceUri, uint16 likelihood, uint16 impact, address identifiedBy, uint256 identifiedAt, uint256 updatedAt)",
+];
+const INCIDENT_ABI = [
+    "function registerIncident(bytes32 agentId, uint8 severity, uint8 harmType, string description, string evidenceHash, uint256 affectedPersons, uint256 occurredAt) external returns (uint256 id)",
+    "function getAgentIncidents(bytes32 agentId) external view returns (uint256[])",
+    "function incidents(uint256 id) external view returns (uint256 id, bytes32 agentId, uint8 severity, uint8 harmType, uint8 status, string description, string evidenceHash, uint256 affectedPersons, address reportedBy, uint256 occurredAt, uint256 registeredAt, uint256 reportedToAuthorityAt, address authorityAddress, string authorityRef, bool withinDeadline, string rootCauseUri, string correctionUri)",
+    "event IncidentRegistered(uint256 indexed id, bytes32 indexed agentId, uint8 severity, uint8 harmType, uint256 occurredAt, uint256 timestamp)",
+];
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+const SEVERITY_LABELS = ["NEGLIGIBLE", "LOW", "MEDIUM", "HIGH", "CRITICAL"];
+const RISK_STATUS_LABELS = ["IDENTIFIED", "ASSESSED", "MITIGATED", "TESTED", "RESIDUAL", "CLOSED"];
+// ─── Output Notices ──────────────────────────────────────────────────────────
+const EVIDENCE_DISCLAIMER = "This output lists on-chain records found by the checks above. " +
+    "It does not determine whether any obligation under the EU AI Act or any other law is satisfied. " +
+    "Not legal advice.";
+const INCIDENT_RECORD_NOTE = "This is an on-chain record, not a report to any authority. " +
+    "This tool does not calculate reporting deadlines: they depend on the type of incident, so confirm them with your legal team. Not legal advice.";
+const INCIDENT_SEVERITY_LABELS = ["LOW", "MEDIUM", "HIGH", "CRITICAL"];
+const HARM_TYPE_LABELS = ["DEATH", "SERIOUS_HEALTH_HARM", "SIGNIFICANT_PROPERTY_DAMAGE", "FUNDAMENTAL_RIGHTS_VIOLATION", "OTHER"];
+/** Integration tag stored in each audit_action record (EVIDENCE_SCHEMA §2.5) */
+const MCP_PLUGIN = "agentaudit-mcp/2.0";
+const BASE_VAULT = index_1.NETWORKS.base.auditVault;
+const networkEnum = zod_1.z.enum(NETWORKS);
+const bytes32Hex = zod_1.z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const addressHex = zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+function json(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function errorMessage(err) {
+    if (err && typeof err === "object" && "shortMessage" in err)
+        return String(err.shortMessage);
+    return err instanceof Error ? err.message : String(err);
+}
+// ─── MCP Server ──────────────────────────────────────────────────────────────
+function createServer(options = optionsFromEnv()) {
+    const rpcUrl = (net) => options.rpcUrls?.[net] ?? DEFAULT_RPC_URLS[net];
+    // Validated at startup so a bad AGENTAUDIT_BUILDER_CODE fails fast
+    const builderCode = (0, index_1.resolveBuilderCode)(options.builderCode);
+    const providers = new Map();
+    // cacheTimeout -1: back-to-back writes must not reuse a cached nonce
+    const provider = (net) => {
+        if (!providers.has(net)) {
+            providers.set(net, new ethers_1.ethers.JsonRpcProvider(rpcUrl(net), undefined, { staticNetwork: true, cacheTimeout: -1 }));
+        }
+        return providers.get(net);
+    };
+    function privateKey() {
+        if (!options.privateKey)
+            throw new Error("PRIVATE_KEY env var not set");
+        return options.privateKey;
+    }
+    const phase7Defaults = new Map();
+    function phase7Address(net, name) {
+        const override = options.phase7?.[net]?.[name];
+        if (override)
+            return override;
+        if (!phase7Defaults.has(net))
+            phase7Defaults.set(net, loadDeployment(net));
+        return phase7Defaults.get(net)[name];
+    }
+    /** Throws a clear error instead of letting a call to an empty address decode as BAD_DATA */
+    async function requireCode(net, address, name) {
+        const code = await provider(net).getCode(address);
+        if (code === "0x")
+            throw new Error(`${name} has no contract code on ${net} at ${address}`);
+    }
+    /** AuditVault v2 for a network, or a clear error — never a silent skip */
+    function auditVault(net) {
+        const override = options.auditVaults?.[net];
+        if (override)
+            return ethers_1.ethers.getAddress(override);
+        const sdkNet = index_1.NETWORKS[net];
+        if (sdkNet.vaultVersion === 2)
+            return sdkNet.auditVault;
+        const what = sdkNet.vaultVersion === 1 ? "is AuditVault v1" : "is not AuditVault v2";
+        throw new Error(`Audit logging is live on Base only: ${net} has no AuditVault v2 (default ${sdkNet.auditVault} ${what}, no commitBatch). ` +
+            `Use network "base" or set AUDIT_VAULT_${net.toUpperCase()} to an AuditVault v2 deployment.`);
+    }
+    const server = new mcp_js_1.McpServer({ name: "agentaudit", version: "3.0.0" }, { capabilities: { tools: {} } });
+    // ─── Tool 1: audit_action ────────────────────────────────────────────────────
+    server.tool("audit_action", `Anchor one or more agent actions on AuditVault v2 in one commitBatch transaction (EU AI Act Art. 12, 19). ` +
+        `Live on Base only (AuditVault v2 ${BASE_VAULT}); any other network returns an error unless AUDIT_VAULT_<NETWORK> points at an AuditVault v2. ` +
+        `Each call commits its entries immediately — nothing is buffered between calls. Payloads are SHA-256 hashed; raw content never leaves this process. ` +
+        `Returns txHash, batchIndex, merkle_root and each entry's action_ref + proof, plus the evidence bundle: keep it, the batch payload is not stored anywhere else (contentURI is memory://).`, {
+        agent_id: zod_1.z.union([zod_1.z.string().min(1), zod_1.z.number().int().nonnegative()]).describe("Agent identifier recorded in each preimage (preimage.agent_id)"),
+        entries: zod_1.z.array(zod_1.z.object({
+            action_type: zod_1.z.string().min(1).describe("Action type label, e.g. LLM_DECISION"),
+            payload: zod_1.z.union([zod_1.z.string().min(1), zod_1.z.record(zod_1.z.string(), zod_1.z.unknown())]).describe("Raw payload — only its SHA-256 (JCS for objects) is recorded"),
+            risk_level: zod_1.z.enum(["LOW", "MEDIUM", "HIGH"]).default("HIGH"),
+            timestamp_ms: zod_1.z.number().int().nonnegative().optional().describe("Unix ms; defaults to now"),
+        })).min(1).max(256).describe("Actions to commit as one batch, in leaf order"),
+        agent_address: addressHex.optional().describe("AuditVault agentId the batch is committed under; defaults to the signer address"),
+        compliance_score: zod_1.z.number().int().min(0).max(100).default(0),
+        network: networkEnum.default("base").describe("Default base — the only network with AuditVault v2"),
+    }, async ({ agent_id, entries, agent_address, compliance_score, network }) => {
+        const vault = auditVault(network);
+        await requireCode(network, vault, "AuditVault v2");
+        const sdk = new index_1.AgentAudit({
+            privateKey: privateKey(),
+            network,
+            rpcUrl: rpcUrl(network),
+            auditVaultAddress: vault,
+            builderCode: builderCode ?? false,
+        });
+        const agentAddress = agent_address ? ethers_1.ethers.getAddress(agent_address) : sdk.getAddress();
+        // One buffer per call, flushed once. The committer is one-shot so the
+        // buffer's retry timer can never resend a batch after this call returned.
+        let committed = false;
+        const committer = {
+            commitBatch: (params) => {
+                if (committed)
+                    return Promise.reject(new Error("audit_action batch already attempted"));
+                committed = true;
+                return sdk.commitBatch(params);
+            },
+        };
+        const store = new index_1.MemoryBatchStore();
+        const buffer = new index_1.BatchBuffer({
+            committer,
+            agentAddress,
+            store,
+            maxEntries: Number.MAX_SAFE_INTEGER, // never auto-flush; flush() below commits everything
+            complianceScore: compliance_score,
+            onError: () => undefined,
+        });
+        const now = Date.now();
+        const refs = [];
+        for (const e of entries) {
+            const payloadDigest = (0, index_1.sha256Hex)(typeof e.payload === "string" ? e.payload : (0, index_1.canonicalize)(e.payload));
+            const record = { plugin: MCP_PLUGIN, action_type: e.action_type, risk_level: e.risk_level, payload_hash: `sha256:${payloadDigest}` };
+            const preimage = {
+                action_type: e.action_type,
+                agent_id: String(agent_id),
+                scope: `agent_action:mcp:record_hash:${(0, index_1.sha256Hex)((0, index_1.canonicalize)(record))}`,
+                timestamp_ms: e.timestamp_ms ?? now,
+            };
+            refs.push((await buffer.add(preimage, record)).actionRef);
+        }
+        const result = (await buffer.flush());
+        if (result.batchIndex === null) {
+            throw new Error(`commitBatch tx ${result.txHash} mined on ${network} but emitted no LogBatchCommitted for root ${result.merkleRoot}`);
+        }
+        const bundle = (await store.get(result.batchId));
+        return json({
+            network,
+            vault,
+            txHash: result.txHash,
+            batchIndex: result.batchIndex,
+            merkle_root: result.merkleRoot,
+            agent_address: agentAddress,
+            contentURI: result.contentURI,
+            entries: bundle.entries.map((entry, i) => ({
+                action_ref: entry.action_ref,
+                proof: buffer.getInclusionProof(refs[i]).proof,
+                preimage: entry.preimage,
+                record: entry.record,
+            })),
+            evidence: { ...bundle, meta: { anchor: { chain: network, txHash: result.txHash, rootCommitment: result.merkleRoot } } },
+        });
+    });
+    // ─── Tool 2: get_audit_log ───────────────────────────────────────────────────
+    server.tool("get_audit_log", `Read committed AuditVault v2 batches, by commitBatch tx hash or by agent_address + batch_index (Art. 12, 19). ` +
+        `Live on Base only (AuditVault v2 ${BASE_VAULT}); other networks return an error unless AUDIT_VAULT_<NETWORK> is set.`, {
+        tx_hash: bytes32Hex.optional().describe("commitBatch transaction hash"),
+        agent_address: addressHex.optional().describe("AuditVault agentId (with batch_index)"),
+        batch_index: zod_1.z.number().int().nonnegative().optional(),
+        network: networkEnum.default("base"),
+    }, async ({ tx_hash, agent_address, batch_index, network }) => {
+        const byIndex = agent_address !== undefined && batch_index !== undefined;
+        if (!!tx_hash === byIndex)
+            throw new Error("Pass either tx_hash, or agent_address + batch_index");
+        const vault = auditVault(network);
+        await requireCode(network, vault, "AuditVault v2");
+        const contract = new ethers_1.ethers.Contract(vault, VAULT_ABI, provider(network));
+        async function readBatch(agent, index) {
+            const b = await contract.getBatch(agent, index);
+            return {
+                agent_address: agent,
+                batch_index: Number(index),
+                merkle_root: b.merkleRoot,
+                contentURI: b.contentURI,
+                event_count: Number(b.eventCount),
+                compliance_score: Number(b.complianceScore),
+                submitter: b.submitter,
+                timestamp: Number(b.timestamp),
+                block_number: Number(b.blockNumber),
+            };
+        }
+        if (byIndex) {
+            const agent = ethers_1.ethers.getAddress(agent_address);
+            const count = await contract.getBatchCount(agent);
+            if (BigInt(batch_index) >= count) {
+                throw new Error(`Batch ${batch_index} not found for ${agent} on ${network} (agent has ${count} batch${count === 1n ? "" : "es"})`);
+            }
+            return json({ network, vault, batches: [await readBatch(agent, BigInt(batch_index))] });
+        }
+        const receipt = await provider(network).getTransactionReceipt(tx_hash);
+        if (!receipt)
+            throw new Error(`Transaction ${tx_hash} not found on ${network}`);
+        if (receipt.status !== 1)
+            throw new Error(`Transaction ${tx_hash} reverted on ${network} (block ${receipt.blockNumber})`);
+        const events = receipt.logs
+            .filter((l) => ethers_1.ethers.getAddress(l.address) === vault)
+            .map((l) => { try {
+            return contract.interface.parseLog(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((p) => p?.name === "LogBatchCommitted");
+        if (events.length === 0)
+            throw new Error(`Transaction ${tx_hash} emitted no LogBatchCommitted from ${vault} on ${network}`);
+        const batches = [];
+        for (const ev of events)
+            batches.push({ ...(await readBatch(ethers_1.ethers.getAddress(ev.args.agentId), ev.args.batchIndex)), tx_hash });
+        return json({ network, vault, batches });
+    });
+    // ─── Tool 3: verify_proof ────────────────────────────────────────────────────
+    server.tool("verify_proof", `Check an audit entry's inclusion proof on-chain with AuditVault v2 verifyLog. The leaf is always recomputed from the preimage (never trusted from the caller); ` +
+        `the batch submitter is reported and can be pinned (docs/THREAT_MODEL.md KI-1, KI-2). ` +
+        `Live on Base only (AuditVault v2 ${BASE_VAULT}); other networks return an error unless AUDIT_VAULT_<NETWORK> is set.`, {
+        agent_address: addressHex.describe("AuditVault agentId the batch was committed under"),
+        batch_index: zod_1.z.number().int().nonnegative(),
+        entry: zod_1.z.object({
+            preimage: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).describe("{ action_type, agent_id, scope, timestamp_ms }"),
+            action_ref: bytes32Hex.optional().describe("Presented leaf; must match sha256(jcs(preimage)) if given"),
+        }),
+        proof: zod_1.z.array(bytes32Hex).describe("Merkle proof (sibling hashes)"),
+        expected_submitter: addressHex.optional().describe("If set, the batch submitter must equal it"),
+        network: networkEnum.default("base"),
+    }, async ({ agent_address, batch_index, entry, proof, expected_submitter, network }) => {
+        const problem = (0, evidence_1.preimageProblem)(entry.preimage);
+        if (problem)
+            throw new Error(`Invalid preimage: ${problem}`);
+        const leaf = (0, evidence_1.actionRef)(entry.preimage);
+        const vault = auditVault(network);
+        const reader = new verify_1.EthersChainReader(rpcUrl(network));
+        try {
+            if (await reader.getCode(vault) === "0x")
+                throw new Error(`AuditVault v2 has no contract code on ${network} at ${vault}`);
+            const agent = ethers_1.ethers.getAddress(agent_address);
+            const count = await new ethers_1.ethers.Contract(vault, VAULT_ABI, provider(network)).getBatchCount(agent);
+            if (BigInt(batch_index) >= count) {
+                throw new Error(`Batch ${batch_index} not found for ${agent} on ${network} (agent has ${count} batch${count === 1n ? "" : "es"})`);
+            }
+            const checks = {};
+            const reasons = [];
+            if (entry.action_ref !== undefined) {
+                checks.action_ref_matches = entry.action_ref.toLowerCase() === leaf;
+                if (!checks.action_ref_matches)
+                    reasons.push(`action_ref ${entry.action_ref} ≠ sha256(jcs(preimage)) ${leaf}`);
+            }
+            checks.verify_log = await reader.verifyLog(vault, agent, BigInt(batch_index), leaf, proof);
+            if (!checks.verify_log)
+                reasons.push("AuditVault.verifyLog returned false");
+            const submitter = ethers_1.ethers.getAddress(await reader.getBatchSubmitter(vault, agent, BigInt(batch_index)));
+            if (expected_submitter !== undefined) {
+                checks.submitter_matches = ethers_1.ethers.getAddress(expected_submitter) === submitter;
+                if (!checks.submitter_matches)
+                    reasons.push(`batch submitter ${submitter} ≠ expected ${ethers_1.ethers.getAddress(expected_submitter)}`);
+            }
+            return json({
+                valid: Object.values(checks).every(Boolean),
+                network,
+                vault,
+                agent_address: agent,
+                batch_index,
+                leaf,
+                submitter,
+                checks,
+                ...(reasons.length ? { reasons } : {}),
+            });
+        }
+        finally {
+            reader.destroy();
+        }
+    });
+    // ─── Tool 4: get_risk_score ──────────────────────────────────────────────────
+    server.tool("get_risk_score", "Query the RiskManagementSystem contract for an agent's risk profile (EU AI Act Art. 9). Deployed on mantle, base, arbitrum, optimism, polygon.", {
+        agent_id: zod_1.z.string().regex(/^0x[0-9a-fA-F]{1,64}$/).describe("Agent ID as a hex bytes32 string"),
+        network: networkEnum.default("mantle"),
+    }, async ({ agent_id, network }) => {
+        const agentId = ethers_1.ethers.zeroPadValue(agent_id, 32);
+        const addr = phase7Address(network, "RiskManagementSystem");
+        await requireCode(network, addr, "RiskManagementSystem");
+        const contract = new ethers_1.ethers.Contract(addr, RISK_ABI, provider(network));
+        const [riskIds, openCount, highCount, criticalCount] = await Promise.all([
+            contract.getAgentRisks(agentId),
+            contract.openRiskCount(agentId),
+            contract.risksAboveSeverity(agentId, 3), // HIGH = 3
+            contract.risksAboveSeverity(agentId, 4), // CRITICAL = 4
+        ]);
+        const totalRisks = riskIds.length;
+        const lines = [
+            `get_risk_score — network=${network}  agentId=${agent_id}`,
+            `contract=${addr}`,
+            "",
+            `Total risks  : ${totalRisks}`,
+            `Open risks   : ${openCount.toString()}`,
+            `HIGH+        : ${highCount.toString()}`,
+            `CRITICAL     : ${criticalCount.toString()}`,
+        ];
+        if (totalRisks > 0 && totalRisks <= 10) {
+            lines.push("", "Risk breakdown:");
+            for (const id of riskIds) {
+                const r = await contract.risks(id);
+                lines.push(`  [${id}] ${SEVERITY_LABELS[Number(r.severity)].padEnd(10)} ` +
+                    `${RISK_STATUS_LABELS[Number(r.status)].padEnd(12)} ` +
+                    `likelihood=${(Number(r.likelihood) / 100).toFixed(0)}%  ` +
+                    r.description.slice(0, 60));
+            }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    });
+    // ─── Tool 5: report_incident ─────────────────────────────────────────────────
+    server.tool("report_incident", "Record a serious AI incident on IncidentRegistry v2 (related to EU AI Act Art. 73). Live on mantle, base, arbitrum, optimism, polygon. " +
+        "This is an on-chain record only, not a report to any authority. " +
+        "Fails unless the registry has code and the transaction emits IncidentRegistered.", {
+        agent_id: zod_1.z.string().regex(/^0x[0-9a-fA-F]{1,64}$/).describe("Agent ID as a hex bytes32 string"),
+        severity: zod_1.z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).describe("Incident severity"),
+        harm_type: zod_1.z.enum(["DEATH", "SERIOUS_HEALTH_HARM", "SIGNIFICANT_PROPERTY_DAMAGE", "FUNDAMENTAL_RIGHTS_VIOLATION", "OTHER"]),
+        description: zod_1.z.string().min(1).describe("Human-readable incident description"),
+        evidence_hash: zod_1.z.string().describe("IPFS CID or hash of incident evidence"),
+        affected_persons: zod_1.z.number().int().nonnegative().describe("Number of persons affected"),
+        occurred_at: zod_1.z.number().int().positive().describe("Unix timestamp when incident occurred"),
+        network: networkEnum.default("mantle"),
+    }, async ({ agent_id, severity, harm_type, description, evidence_hash, affected_persons, occurred_at, network }) => {
+        const agentId = ethers_1.ethers.zeroPadValue(agent_id, 32);
+        const severityIdx = INCIDENT_SEVERITY_LABELS.indexOf(severity);
+        const harmTypeIdx = HARM_TYPE_LABELS.indexOf(harm_type);
+        const addr = ethers_1.ethers.getAddress(phase7Address(network, "IncidentRegistry"));
+        await requireCode(network, addr, "IncidentRegistry");
+        const signer = new ethers_1.ethers.Wallet(privateKey(), provider(network));
+        const contract = new ethers_1.ethers.Contract(addr, INCIDENT_ABI, signer);
+        const tx = await (0, index_1.sendAttributed)(contract, "registerIncident", [
+            agentId,
+            severityIdx,
+            harmTypeIdx,
+            description,
+            evidence_hash,
+            affected_persons,
+            occurred_at,
+        ], builderCode);
+        const receipt = await tx.wait();
+        // Only an IncidentRegistered from the registry itself counts as registration
+        let incidentId = null;
+        for (const log of receipt?.logs ?? []) {
+            if (ethers_1.ethers.getAddress(log.address) !== addr)
+                continue;
+            const parsed = (() => { try {
+                return contract.interface.parseLog(log);
+            }
+            catch {
+                return null;
+            } })();
+            if (parsed?.name === "IncidentRegistered") {
+                incidentId = parsed.args.id.toString();
+                break;
+            }
+        }
+        if (incidentId === null) {
+            throw new Error(`Incident NOT registered: tx ${tx.hash} on ${network} emitted no IncidentRegistered from ${addr}`);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `report_incident — IncidentRegistry v2 (related: Art. 73)`,
+                        `network=${network}  contract=${addr}`,
+                        "",
+                        `Incident ID      : ${incidentId}`,
+                        `Tx hash          : ${tx.hash}`,
+                        `Severity         : ${severity}`,
+                        `Harm type        : ${harm_type}`,
+                        `Affected persons : ${affected_persons}`,
+                        "",
+                        INCIDENT_RECORD_NOTE,
+                    ].join("\n"),
+                }],
+        };
+    });
+    // ─── Tool 6: get_evidence_report (+ deprecated get_compliance_report alias) ──
+    const evidenceReportSchema = {
+        agent_id: zod_1.z.string().regex(/^0x[0-9a-fA-F]{1,64}$/).describe("Agent ID as a hex bytes32 string"),
+        network: zod_1.z.enum([...NETWORKS, "all"]).default("all"),
+    };
+    const evidenceReportDescription = "List the on-chain records found for an agent in the Phase 7 contracts (RiskManagementSystem, IncidentRegistry) " +
+        "on one or all of mantle, base, arbitrum, optimism, polygon. Read-only. " +
+        "It does not determine whether any legal obligation is satisfied. Not legal advice.";
+    const evidenceReport = async ({ agent_id, network }) => {
+        const agentId = ethers_1.ethers.zeroPadValue(agent_id, 32);
+        const targets = network === "all" ? [...NETWORKS] : [network];
+        const lines = [
+            "═══════════════════════════════════════════════════════════",
+            "  AgentAudit — On-chain Evidence Report",
+            `  Agent   : ${agent_id}`,
+            `  Date    : ${new Date().toISOString()}`,
+            "═══════════════════════════════════════════════════════════",
+        ];
+        for (const net of targets) {
+            const p = provider(net);
+            lines.push("", `── Network: ${net.toUpperCase()} ──────────────────────────────────`);
+            // RiskManagementSystem
+            try {
+                const addr = phase7Address(net, "RiskManagementSystem");
+                await requireCode(net, addr, "RiskManagementSystem");
+                const risk = new ethers_1.ethers.Contract(addr, RISK_ABI, p);
+                const [openCount, highCount, criticalCount] = await Promise.all([
+                    risk.openRiskCount(agentId),
+                    risk.risksAboveSeverity(agentId, 3),
+                    risk.risksAboveSeverity(agentId, 4),
+                ]);
+                lines.push(`  RiskManagementSystem (related: Art. 9): open=${openCount}  HIGH+=${highCount}  CRITICAL=${criticalCount}`);
+            }
+            catch (e) {
+                lines.push(`  RiskManagementSystem (related: Art. 9): error — ${errorMessage(e)}`);
+            }
+            // IncidentRegistry
+            try {
+                const addr = phase7Address(net, "IncidentRegistry");
+                await requireCode(net, addr, "IncidentRegistry");
+                const incident = new ethers_1.ethers.Contract(addr, INCIDENT_ABI, p);
+                const ids = await incident.getAgentIncidents(agentId);
+                let openIncidents = 0;
+                for (const id of ids) {
+                    const inc = await incident.incidents(id);
+                    if (Number(inc.status) < 3)
+                        openIncidents++; // < RESOLVED
+                }
+                lines.push(`  IncidentRegistry (related: Art. 73): total=${ids.length}  open=${openIncidents}`);
+            }
+            catch (e) {
+                lines.push(`  IncidentRegistry (related: Art. 73): error — ${errorMessage(e)}`);
+            }
+        }
+        lines.push("", "═══════════════════════════════════════════════════════════", "  Contracts queried: RiskManagementSystem, IncidentRegistry", "  (Phase 7 deployment)", "", `  ${EVIDENCE_DISCLAIMER}`, "═══════════════════════════════════════════════════════════");
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    };
+    server.tool("get_evidence_report", evidenceReportDescription, evidenceReportSchema, evidenceReport);
+    server.tool("get_compliance_report", `Deprecated alias of get_evidence_report; it will be removed in a future major version. ${evidenceReportDescription}`, evidenceReportSchema, evidenceReport);
+    return server;
+}
+// ─── Start ───────────────────────────────────────────────────────────────────
+if (require.main === module) {
+    const transport = new stdio_js_1.StdioServerTransport();
+    createServer().connect(transport).catch((err) => {
+        console.error("MCP server error:", err);
+        process.exit(1);
+    });
+}

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

@@ -0,0 +1,23 @@
+export declare const SCHEMA = "agentaudit-evidence-v1";
+export declare const LEAF_HASH = "sha256(jcs(preimage))";
+export declare const NODE_HASH = "keccak256(sorted_pair)";
+export declare const ODD_NODE = "promote";
+/** The only fields that enter the preimage (docs/EVIDENCE_SCHEMA.md §1.1) */
+export declare const PREIMAGE_FIELDS: readonly ["action_type", "agent_id", "scope", "timestamp_ms"];
+/**
+ * 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.
+ */
+export declare function jcs(value: unknown): string;
+/** Why a preimage is not a valid Evidence Schema v1 preimage, or null */
+export declare function preimageProblem(preimage: unknown): string | null;
+/** 0x-prefixed lowercase SHA-256 of the UTF-8 JCS bytes */
+export declare function actionRef(preimage: unknown): string;
+/** keccak256(abi.encodePacked(min(a, b), max(a, b))) — AuditVault._verifyMerkle's step */
+export declare function hashPair(a: string, b: string): string;
+export declare function merkleRoot(leaves: string[]): string;
+/** Sibling path for leaves[index]; promoted levels contribute no element */
+export declare function merkleProof(leaves: string[], index: number): string[];
+/** Local mirror of AuditVault._verifyMerkle */
+export declare function verifyProof(leaf: string, proof: string[], root: string): boolean;