open-multi-agent-kit 0.90.7 → 0.90.9

package/dist/guardrails/evidence-system.js

@@ -1,7 +1,12 @@
-// allow: SIZE_OK - legacy evidence ledger; this change only keeps typed import/check compatibility.
+// allow: SIZE_OK - evidence ledger guardrails: tamper-evident replay chain + fail-closed parsing.
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { redactCommandDescriptor } from "./command-redaction.js";
+import { latestRelevantWorkspaceMutationSeq, parseVerifiedLedgerSnapshot, replayPayloadMatches, verifyCommandAttestation, verifyWorkspaceBinding, } from "./evidence-attestation.js";
+export { latestRelevantWorkspaceMutationSeq } from "./evidence-attestation.js";
+import { computeEvidenceCommandSha256, constantTimeSha256Equal, evidenceReceiptReplayPayload, parseSha256Hex, validateEvidenceReceipt, } from "./evidence-receipt.js";
+import { ReplayLedgerStore, replayLedgerHeadsEqual } from "./replay-ledger-store.js";
 function sha256(input) {
     return createHash("sha256").update(input).digest("hex");
 }
@@ -66,97 +71,370 @@ export class TaskContractBuilder {
         this.updatedAt = new Date().toISOString();
     }
     build() {
-        return {
+        return structuredClone({
             goalId: this.goalId,
             completionClaim: this.completionClaim,
-            requiredEvidence: [...this.requiredEvidence],
+            requiredEvidence: this.requiredEvidence,
             finalRisk: this.finalRisk,
             verdict: this.verdict,
             createdAt: this.createdAt,
             updatedAt: this.updatedAt,
-        };
+        });
     }
+    /** Parse and validate a serialized TaskContract. Fails closed on any shape violation. */
     static fromJSON(json) {
-        return JSON.parse(json);
+        const raw = JSON.parse(json);
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new Error("TaskContract JSON must be an object");
+        }
+        const { goalId, completionClaim, finalRisk, verdict, createdAt, updatedAt, requiredEvidence } = raw;
+        if (typeof goalId !== "string" ||
+            typeof completionClaim !== "string" ||
+            typeof finalRisk !== "string" ||
+            typeof createdAt !== "string" ||
+            typeof updatedAt !== "string") {
+            throw new Error("TaskContract JSON has missing or mistyped string fields");
+        }
+        if (verdict !== "pass" && verdict !== "fail" && verdict !== "conditional") {
+            throw new Error(`TaskContract verdict must be pass|fail|conditional, got ${String(verdict)}`);
+        }
+        if (!Array.isArray(requiredEvidence)) {
+            throw new Error("TaskContract requiredEvidence must be an array");
+        }
+        return {
+            goalId,
+            completionClaim,
+            finalRisk,
+            verdict,
+            createdAt,
+            updatedAt,
+            requiredEvidence: requiredEvidence.map((item, index) => parseEvidenceItem(item, index)),
+        };
     }
     static toJSON(contract) {
         return JSON.stringify(contract, null, 2);
     }
 }
+const EVIDENCE_STATUSES = new Set(["pending", "gathering", "satisfied", "failed", "waived"]);
+function optionalStringField(value, field, index) {
+    if (value !== undefined && typeof value !== "string") {
+        throw new Error(`TaskContract evidence[${index}].${field} must be a string when present`);
+    }
+    return value;
+}
+function parseEvidenceItem(raw, index) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`TaskContract evidence[${index}] must be an object`);
+    }
+    const item = raw;
+    const { claim, category, timestamp, status } = item;
+    if (typeof claim !== "string" || typeof category !== "string" || typeof timestamp !== "string") {
+        throw new Error(`TaskContract evidence[${index}] has missing or mistyped fields`);
+    }
+    if (typeof status !== "string" || !EVIDENCE_STATUSES.has(status)) {
+        throw new Error(`TaskContract evidence[${index}] has invalid status ${String(status)}`);
+    }
+    const receiptSchemaVersion = item.receiptSchemaVersion;
+    if (receiptSchemaVersion !== undefined && receiptSchemaVersion !== 3) {
+        throw new Error(`TaskContract evidence[${index}].receiptSchemaVersion must be 3 when present`);
+    }
+    const receiptCommandSha256 = optionalStringField(item.receiptCommandSha256, "receiptCommandSha256", index);
+    return {
+        claim,
+        category: category,
+        timestamp,
+        status: status,
+        artifactPath: optionalStringField(item.artifactPath, "artifactPath", index),
+        verificationCommand: optionalStringField(item.verificationCommand, "verificationCommand", index),
+        hash: optionalStringField(item.hash, "hash", index),
+        receiptId: optionalStringField(item.receiptId, "receiptId", index),
+        receiptSchemaVersion,
+        ...(receiptCommandSha256 !== undefined
+            ? { receiptCommandSha256: parseSha256Hex(receiptCommandSha256, "receiptCommandSha256") }
+            : {}),
+        receiptLaneId: optionalStringField(item.receiptLaneId, "receiptLaneId", index),
+        gapReason: optionalStringField(item.gapReason, "gapReason", index),
+    };
+}
 // ============================================================================
 // ReplayLedger
 // ============================================================================
-export class ReplayLedgerManager {
-    ledger;
-    nextSeq;
-    constructor(goalId, ledgerPath) {
-        ensureDir(ledgerPath);
-        this.ledger = {
-            goalId,
-            events: [],
-            ledgerPath,
-            lastPersistedSeq: 0,
-        };
-        this.nextSeq = 1;
-        if (existsSync(ledgerPath)) {
-            this.load();
+/** prevHash sentinel for the first event in a replay chain. */
+const GENESIS_HASH = "genesis";
+function computeEventHash(event) {
+    return sha256(JSON.stringify([
+        event.seq,
+        event.type,
+        event.timestamp,
+        event.goalId,
+        event.laneId ?? null,
+        event.payloadHash,
+        event.prevHash,
+    ]));
+}
+function parseReplayEventLine(line, lineNumber) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        throw new Error(`Replay ledger corrupted at line ${lineNumber}: invalid JSON`);
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error(`Replay ledger corrupted at line ${lineNumber}: event must be an object`);
+    }
+    const event = raw;
+    const { seq, type, timestamp, goalId, laneId, payloadHash, prevHash, eventHash } = event;
+    if (typeof seq !== "number" ||
+        typeof type !== "string" ||
+        typeof timestamp !== "string" ||
+        typeof goalId !== "string" ||
+        typeof payloadHash !== "string" ||
+        typeof prevHash !== "string" ||
+        typeof eventHash !== "string" ||
+        (laneId !== undefined && typeof laneId !== "string") ||
+        !("payload" in event)) {
+        throw new Error(`Replay ledger corrupted at line ${lineNumber}: event fields are missing or mistyped`);
+    }
+    return {
+        seq,
+        type: type,
+        timestamp,
+        goalId,
+        laneId,
+        payload: event.payload,
+        payloadHash,
+        prevHash,
+        eventHash,
+    };
+}
+function parseReplayLedgerBytes(bytes, goalId) {
+    const lines = bytes
+        .toString("utf8")
+        .split("\n")
+        .filter((line) => line.trim().length > 0);
+    const events = [];
+    let prevHash = GENESIS_HASH;
+    for (let index = 0; index < lines.length; index++) {
+        const event = parseReplayEventLine(lines[index], index + 1);
+        if (event.goalId !== goalId)
+            throw new Error(`Replay ledger goal mismatch at line ${index + 1}`);
+        if (event.seq !== index + 1) {
+            throw new Error(`Replay ledger corrupted at line ${index + 1}: expected seq ${index + 1}, got ${event.seq}`);
+        }
+        if (event.prevHash !== prevHash)
+            throw new Error(`Replay ledger chain broken at line ${index + 1}`);
+        if (sha256(JSON.stringify(event.payload)) !== event.payloadHash) {
+            throw new Error(`Replay ledger payload tampered at line ${index + 1} (seq ${event.seq})`);
         }
+        if (computeEventHash(event) !== event.eventHash) {
+            throw new Error(`Replay ledger event hash mismatch at line ${index + 1} (seq ${event.seq})`);
+        }
+        prevHash = event.eventHash;
+        events.push(event);
     }
-    append(event) {
-        const payloadStr = JSON.stringify(event.payload);
-        const fullEvent = {
+    return events;
+}
+export class ReplayLedgerManager {
+    goalId;
+    ledgerPath;
+    store;
+    events = [];
+    committedHead;
+    constructor(goalId, ledgerPath, expectedHead) {
+        this.goalId = goalId;
+        this.ledgerPath = ledgerPath;
+        this.committedHead = { fileIdentity: null, size: 0, lastSeq: 0, lastHash: GENESIS_HASH };
+        this.store = new ReplayLedgerStore(ledgerPath, (bytes) => {
+            const events = parseReplayLedgerBytes(bytes, goalId);
+            const last = events.at(-1);
+            return { lastSeq: last?.seq ?? 0, lastHash: last?.eventHash ?? GENESIS_HASH };
+        });
+        this.refresh(expectedHead);
+    }
+    refresh(expectedHead) {
+        const snapshot = this.store.load(expectedHead);
+        this.events = parseReplayLedgerBytes(snapshot.bytes, this.goalId);
+        this.committedHead = snapshot.head;
+    }
+    append(event, expectedHead = this.committedHead) {
+        if (event.goalId !== this.goalId)
+            throw new Error("Replay event goalId does not match the ledger");
+        if (!replayLedgerHeadsEqual(expectedHead, this.committedHead)) {
+            throw new Error("Replay manager expected-head CAS is stale");
+        }
+        const payloadHash = sha256(JSON.stringify(event.payload));
+        const chained = {
             ...event,
-            seq: this.nextSeq++,
+            seq: expectedHead.lastSeq + 1,
             timestamp: new Date().toISOString(),
-            payloadHash: sha256(payloadStr),
+            payloadHash,
+            prevHash: expectedHead.lastHash,
         };
-        this.ledger.events.push(fullEvent);
-        return fullEvent;
-    }
-    persist() {
-        if (this.ledger.events.length === 0)
-            return;
-        const last = this.ledger.events[this.ledger.events.length - 1];
-        if (last.seq <= this.ledger.lastPersistedSeq)
-            return;
-        const newEvents = this.ledger.events.filter((e) => e.seq > this.ledger.lastPersistedSeq);
-        const lines = `${newEvents.map((e) => JSON.stringify(e)).join("\n")}\n`;
-        appendFileSync(this.ledger.ledgerPath, lines, "utf-8");
-        this.ledger.lastPersistedSeq = last.seq;
-    }
-    load() {
-        if (!existsSync(this.ledger.ledgerPath))
-            return;
-        const content = readFileSync(this.ledger.ledgerPath, "utf-8");
-        const events = content
-            .split("\n")
-            .filter((line) => line.trim().length > 0)
-            .map((line) => JSON.parse(line));
-        this.ledger.events = events;
-        this.ledger.lastPersistedSeq = events.length > 0 ? events[events.length - 1].seq : 0;
-        this.nextSeq = this.ledger.lastPersistedSeq + 1;
+        const fullEvent = { ...chained, eventHash: computeEventHash(chained) };
+        this.committedHead = this.store.append(Buffer.from(`${JSON.stringify(fullEvent)}\n`, "utf8"), fullEvent.seq, fullEvent.eventHash, expectedHead);
+        this.events.push(fullEvent);
+        return structuredClone(fullEvent);
+    }
+    /** Compatibility no-op that still verifies the caller's expected committed head. */
+    persist(expectedHead = this.committedHead) {
+        this.getVerifiedSnapshot(expectedHead);
+    }
+    load(expectedHead = this.committedHead) {
+        this.refresh(expectedHead);
+    }
+    getCommittedHead() {
+        return structuredClone(this.committedHead);
+    }
+    getVerifiedSnapshot(expectedHead = this.committedHead) {
+        this.refresh(expectedHead);
+        return structuredClone({ events: this.events, head: this.committedHead });
     }
     getEvents() {
-        return this.ledger.events;
+        return structuredClone(this.events);
     }
     getLedger() {
-        return { ...this.ledger };
+        return structuredClone({
+            goalId: this.goalId,
+            events: this.events,
+            ledgerPath: this.ledgerPath,
+            lastPersistedSeq: this.committedHead.lastSeq,
+        });
     }
     replay(handler) {
-        const results = [];
-        for (const event of this.ledger.events) {
-            const result = handler(event);
-            if (result !== undefined) {
-                results.push(result);
-            }
-        }
-        return results;
+        return this.events.map(handler).filter((result) => result !== undefined);
     }
     exportToFile(path) {
         ensureDir(path);
-        writeFileSync(path, JSON.stringify(this.ledger.events, null, 2), "utf-8");
+        writeFileSync(path, JSON.stringify(this.events, null, 2), "utf8");
     }
 }
+function receiptCheckIssue(message, hard) {
+    return { message, hard };
+}
+function receiptIssue(item, contract, options) {
+    if (!item.receiptId) {
+        return receiptCheckIssue(`Execution receipt is missing for evidence "${item.claim}".`, false);
+    }
+    const strict = options.receiptMode === "strict";
+    if (item.receiptSchemaVersion !== 3 && (item.receiptSchemaVersion !== undefined || strict)) {
+        return receiptCheckIssue(`Execution receipt schema metadata is invalid for evidence "${item.claim}".`, true);
+    }
+    if (!options.resolveReceipt) {
+        return receiptCheckIssue(`Execution receipt resolver is missing for evidence "${item.claim}".`, false);
+    }
+    let rawReceipt;
+    try {
+        rawReceipt = options.resolveReceipt(item.receiptId);
+    }
+    catch {
+        return receiptCheckIssue(`Execution receipt resolver failed for evidence "${item.claim}".`, true);
+    }
+    if (rawReceipt === undefined) {
+        return receiptCheckIssue(`Execution receipt is missing for evidence "${item.claim}".`, false);
+    }
+    try {
+        const receipt = validateEvidenceReceipt(rawReceipt);
+        if (receipt.core.receiptId !== item.receiptId) {
+            return receiptCheckIssue(`Execution receipt ID does not match evidence "${item.claim}".`, true);
+        }
+        if (receipt.core.goalId !== contract.goalId) {
+            return receiptCheckIssue(`Execution receipt goal does not match evidence "${item.claim}".`, true);
+        }
+        if (receipt.core.claim !== item.claim) {
+            return receiptCheckIssue(`Execution receipt claim does not match evidence "${item.claim}".`, true);
+        }
+        if (receipt.core.status !== "passed" || receipt.core.exitCode !== 0) {
+            return receiptCheckIssue(`Execution receipt for evidence "${item.claim}" did not pass with exit code 0.`, true);
+        }
+        if (item.receiptCommandSha256 === undefined) {
+            return receiptCheckIssue(`Execution receipt command binding is missing for evidence "${item.claim}".`, false);
+        }
+        const receiptCommandSha256 = computeEvidenceCommandSha256(receipt.core.command);
+        if (!constantTimeSha256Equal(item.receiptCommandSha256, receiptCommandSha256)) {
+            return receiptCheckIssue(`Execution receipt command does not match evidence "${item.claim}".`, true);
+        }
+        const attestationIssue = verifyCommandAttestation({
+            receiptId: receipt.core.receiptId,
+            binding: receipt.core.commandBinding,
+            persistedCommand: receipt.core.command,
+            persistedSummary: receipt.core.commandRedaction,
+            binder: options.commandAttestationBinder,
+            resolveCommand: options.resolveAttestedCommand,
+            redact: redactCommandDescriptor,
+        });
+        if (attestationIssue !== undefined) {
+            return receiptCheckIssue(`Execution receipt command attestation ${attestationIssue.detail} for evidence "${item.claim}".`, attestationIssue.hard);
+        }
+        if (receipt.core.laneId !== undefined && item.receiptLaneId === undefined) {
+            return receiptCheckIssue(`Execution receipt lane binding is missing for evidence "${item.claim}".`, false);
+        }
+        if (item.receiptLaneId !== receipt.core.laneId) {
+            return receiptCheckIssue(`Execution receipt lane does not match evidence "${item.claim}".`, true);
+        }
+        const workspaceIssue = verifyWorkspaceBinding(receipt.core.workspaceAfter, options.captureWorkspaceFingerprint);
+        if (workspaceIssue !== undefined) {
+            return receiptCheckIssue(`Execution receipt ${workspaceIssue.detail} for evidence "${item.claim}".`, workspaceIssue.hard);
+        }
+        let snapshot;
+        if (options.resolveVerifiedLedgerSnapshot !== undefined) {
+            try {
+                snapshot = parseVerifiedLedgerSnapshot(options.resolveVerifiedLedgerSnapshot(), contract.goalId, parseReplayLedgerBytes);
+            }
+            catch {
+                return receiptCheckIssue(`Execution receipt verified ledger snapshot failed for evidence "${item.claim}".`, true);
+            }
+        }
+        else if (strict) {
+            return receiptCheckIssue(`Execution receipt verified ledger snapshot is missing for evidence "${item.claim}".`, false);
+        }
+        let latestMutationSeq = snapshot === undefined
+            ? null
+            : latestRelevantWorkspaceMutationSeq(snapshot.events, receipt.core.workspaceAfter.scope);
+        if (snapshot === undefined && options.resolveLatestWorkspaceMutationSeq !== undefined) {
+            let resolved;
+            try {
+                resolved = options.resolveLatestWorkspaceMutationSeq(receipt.core.workspaceAfter.scope);
+            }
+            catch {
+                return receiptCheckIssue(`Execution receipt workspace-mutation freshness source failed for evidence "${item.claim}".`, true);
+            }
+            if (resolved !== null && resolved !== undefined) {
+                if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+                    return receiptCheckIssue(`Execution receipt workspace-mutation freshness source is malformed for evidence "${item.claim}".`, true);
+                }
+                latestMutationSeq = resolved;
+            }
+        }
+        const binding = receipt.envelope.ledgerBinding;
+        if (!binding) {
+            return receiptCheckIssue(`Execution receipt ledger binding is missing for evidence "${item.claim}".`, latestMutationSeq !== null);
+        }
+        const event = snapshot
+            ? snapshot.events.find((candidate) => candidate.seq === binding.seq)
+            : options.resolveLedgerEvent?.(binding.seq);
+        if (!event && snapshot === undefined && !options.resolveLedgerEvent) {
+            return receiptCheckIssue(`Execution receipt ledger resolver is missing for evidence "${item.claim}".`, latestMutationSeq !== null);
+        }
+        const replayPayload = evidenceReceiptReplayPayload(receipt);
+        if (!event ||
+            event.seq !== binding.seq ||
+            event.type !== "evidence_receipt" ||
+            event.goalId !== contract.goalId ||
+            event.laneId !== receipt.core.laneId ||
+            !constantTimeSha256Equal(event.eventHash, binding.eventHash) ||
+            !replayPayloadMatches(event.payload, replayPayload.receiptId, replayPayload.coreSha256)) {
+            return receiptCheckIssue(`Execution receipt ledger binding does not match evidence "${item.claim}".`, true);
+        }
+        if (latestMutationSeq !== null && event.seq <= latestMutationSeq) {
+            return receiptCheckIssue(`Execution receipt is stale: workspace mutation seq ${latestMutationSeq} does not precede receipt ledger seq ${event.seq} for evidence "${item.claim}".`, true);
+        }
+    }
+    catch {
+        return receiptCheckIssue(`Execution receipt is invalid for evidence "${item.claim}".`, true);
+    }
+    return undefined;
+}
 export class EvidenceGate {
     options;
     constructor(options = {}) {
@@ -164,6 +442,7 @@ export class EvidenceGate {
             minEvidenceCount: 1,
             requireHash: true,
             requireVerificationCommand: true,
+            receiptMode: "prefer",
             ...options,
         };
     }
@@ -172,32 +451,42 @@ export class EvidenceGate {
         const satisfied = evidence.filter((e) => e.status === "satisfied");
         const failed = evidence.filter((e) => e.status === "failed");
         const pending = evidence.filter((e) => e.status === "pending" || e.status === "gathering");
+        const mode = this.options.receiptMode ?? "prefer";
         const checks = [];
-        // Check 1: minimum evidence count
+        let hardReceiptFailure = false;
         if (satisfied.length < (this.options.minEvidenceCount ?? 1)) {
             checks.push(`Only ${satisfied.length}/${this.options.minEvidenceCount} required evidence items satisfied.`);
         }
-        // Check 2: no failed evidence
         if (failed.length > 0) {
             checks.push(`${failed.length} evidence item(s) failed.`);
         }
-        // Check 3: require hash
-        if (this.options.requireHash) {
-            const hashed = satisfied.filter((e) => e.hash && e.hash.length > 0);
-            if (hashed.length === 0) {
-                checks.push("No satisfied evidence has a SHA-256 hash.");
+        if (mode === "legacy") {
+            if (this.options.requireHash) {
+                const hashed = satisfied.filter((e) => e.hash && e.hash.length > 0);
+                if (hashed.length === 0)
+                    checks.push("No satisfied evidence has a SHA-256 hash.");
+            }
+            if (this.options.requireVerificationCommand) {
+                const withCommand = satisfied.filter((e) => e.verificationCommand && e.verificationCommand.length > 0);
+                if (withCommand.length === 0)
+                    checks.push("No satisfied evidence has a verification command.");
             }
         }
-        // Check 4: require verification command
-        if (this.options.requireVerificationCommand) {
-            const withCommand = satisfied.filter((e) => e.verificationCommand && e.verificationCommand.length > 0);
-            if (withCommand.length === 0) {
-                checks.push("No satisfied evidence has a verification command.");
+        else {
+            const unsatisfied = evidence.filter((item) => item.status !== "satisfied");
+            if (unsatisfied.length > 0) {
+                checks.push(`${unsatisfied.length} required evidence item(s) are not satisfied.`);
+            }
+            for (const item of satisfied) {
+                const issue = receiptIssue(item, contract, this.options);
+                if (issue) {
+                    checks.push(issue.message);
+                    hardReceiptFailure ||= issue.hard;
+                }
             }
         }
-        // Check 5: contract verdict
-        if (contract.verdict === "fail") {
-            checks.push("Task contract verdict is 'fail'.");
+        if (contract.verdict === "fail" || (mode !== "legacy" && contract.verdict !== "pass")) {
+            checks.push(`Task contract verdict is '${contract.verdict}'.`);
         }
         let status;
         let reason;
@@ -207,9 +496,9 @@ export class EvidenceGate {
             reason = `Evidence gate passed: ${satisfied.length}/${evidence.length} evidence items satisfied.`;
         }
         else {
-            // If there are pending items and no hard failures, it's conditional; otherwise blocked
-            const hasHardFailure = failed.length > 0 || contract.verdict === "fail";
-            status = pending.length > 0 && !hasHardFailure ? "conditional" : "blocked";
+            const contractFailure = mode === "legacy" ? contract.verdict === "fail" : contract.verdict !== "pass";
+            const hasHardFailure = failed.length > 0 || contractFailure || hardReceiptFailure || mode === "strict";
+            status = hasHardFailure ? "blocked" : mode === "prefer" || pending.length > 0 ? "conditional" : "blocked";
             reason = checks.join("; ");
             suggestion = `Gather remaining evidence (${pending.length} pending) and re-run verification.`;
         }
@@ -260,6 +549,13 @@ export class FailClosedMergeGate {
         };
     }
 }
+// ============================================================================
+// Verify Reporter v2
+// ============================================================================
+/** Escape pipes/newlines so untrusted claim or command text cannot restructure the report table. */
+function escapeTableCell(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
 export class VerifyReporterV2 {
     options;
     constructor(options) {
@@ -273,9 +569,9 @@ export class VerifyReporterV2 {
             "",
             `| Field | Value |`,
             `|-------|-------|`,
-            `| Claim | ${contract.completionClaim} |`,
+            `| Claim | ${escapeTableCell(contract.completionClaim)} |`,
             `| Verdict | ${contract.verdict} |`,
-            `| Final Risk | ${contract.finalRisk} |`,
+            `| Final Risk | ${escapeTableCell(contract.finalRisk)} |`,
             "",
             "### Evidence",
             "",
@@ -283,9 +579,9 @@ export class VerifyReporterV2 {
             `|-------|--------|----------|----------|`,
         ];
         for (const ev of contract.requiredEvidence) {
-            lines.push(`| ${ev.claim} | ${ev.status} | ${ev.artifactPath ?? "—"} | ${ev.verificationCommand ?? "—"} |`);
+            lines.push(`| ${escapeTableCell(ev.claim)} | ${ev.status} | ${escapeTableCell(ev.artifactPath ?? "—")} | ${escapeTableCell(ev.verificationCommand ?? "—")} |`);
         }
-        lines.push("", "### Merge Gate", "", `| Gate | Status | Reason |`, `|------|--------|--------|`, `| ${mergeGate.gateId} | ${mergeGate.status} | ${mergeGate.reason} |`, "");
+        lines.push("", "### Merge Gate", "", `| Gate | Status | Reason |`, `|------|--------|--------|`, `| ${mergeGate.gateId} | ${mergeGate.status} | ${escapeTableCell(mergeGate.reason)} |`, "");
         if (mergeGate.suggestion) {
             lines.push(`**Suggestion:** ${mergeGate.suggestion}`, "");
         }