witnora 0.8.1 → 0.9.0

package/dist/release-gate.js

@@ -0,0 +1,457 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export const AGENTCERT_RELEASE_GATE_SCHEMA_VERSION = "agentcert.release_gate.v0.1";
+export const RELEASE_GATE_CONTROL_IDS = [
+    "permission-boundary",
+    "data-boundary",
+    "tool-contract",
+    "state-verification",
+    "human-handoff",
+    "rate-loop-cost-limits",
+    "idempotency-retry-safety",
+    "observability-auditability",
+    "rollback-kill-switch",
+    "supply-chain-dependency-boundary",
+];
+const CONTROL_DEFINITIONS = [
+    {
+        id: "permission-boundary",
+        name: "Identity, authorization, and least privilege",
+        mode: "evidence-required",
+        evaluate: evaluatePermissionBoundary,
+    },
+    {
+        id: "data-boundary",
+        name: "Sensitive data boundary",
+        mode: "evidence-required",
+        evaluate: evaluateDataBoundary,
+    },
+    {
+        id: "tool-contract",
+        name: "Tool and MCP contract",
+        mode: "automated",
+        evaluate: (bundle) => evaluateProduct(bundle, "mcpbench", "MCPBench tool contract evidence is not present."),
+    },
+    {
+        id: "state-verification",
+        name: "Observed state verification",
+        mode: "automated",
+        evaluate: evaluateStateVerification,
+    },
+    {
+        id: "human-handoff",
+        name: "High-risk action approval and handoff",
+        mode: "evidence-required",
+        evaluate: evaluateHumanHandoff,
+    },
+    {
+        id: "rate-loop-cost-limits",
+        name: "Rate, loop, timeout, and cost limits",
+        mode: "evidence-required",
+        evaluate: () => unresolved("needs-evidence", "Provide configured step, timeout, retry, and budget limits."),
+    },
+    {
+        id: "idempotency-retry-safety",
+        name: "Idempotency and retry safety",
+        mode: "manual",
+        evaluate: () => unresolved("manual-review", "A named owner must review duplicate execution and partial failure behavior."),
+    },
+    {
+        id: "observability-auditability",
+        name: "Observability, incident trace, and accountability",
+        mode: "automated",
+        evaluate: evaluateObservability,
+    },
+    {
+        id: "rollback-kill-switch",
+        name: "Rollback and kill switch",
+        mode: "manual",
+        evaluate: () => unresolved("manual-review", "A named owner must provide a rollback or kill-switch runbook."),
+    },
+    {
+        id: "supply-chain-dependency-boundary",
+        name: "Supply-chain and dependency boundary",
+        mode: "manual",
+        evaluate: () => unresolved("manual-review", "A named owner must review models, packages, MCP servers, and adapters."),
+    },
+];
+export async function buildReleaseGateReport(bundle, options = {}) {
+    const strict = options.strict ?? false;
+    const controls = CONTROL_DEFINITIONS.map((definition) => {
+        const evaluated = definition.evaluate(bundle);
+        return applyAttestation({ id: definition.id, name: definition.name, mode: definition.mode, ...evaluated }, options.attestations?.[definition.id]);
+    });
+    const regression = compareWithBaseline(bundle, options.baseline, {
+        requireBaseline: options.requireBaseline ?? false,
+        maxScoreDrop: options.maxScoreDrop ?? 0,
+    });
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const sourceArtifacts = await digestArtifacts(options.sourceArtifacts ?? {}, cwd);
+    const evidenceBundle = options.evidenceBundlePath
+        ? await digestArtifact("agentcert-evidence", options.evidenceBundlePath, cwd)
+        : undefined;
+    const blockers = collectBlockers(bundle, controls, regression, strict, options.requireBaseline ?? false, sourceArtifacts, evidenceBundle);
+    return {
+        schemaVersion: AGENTCERT_RELEASE_GATE_SCHEMA_VERSION,
+        kind: "agentcert.release_gate",
+        runId: `release_gate_${createHash("sha256").update(`${bundle.runId}:${JSON.stringify(controls)}`).digest("hex").slice(0, 12)}`,
+        generatedAt: new Date().toISOString(),
+        subject: bundle.subject,
+        strict,
+        verdict: {
+            passed: blockers.length === 0,
+            blockers,
+            passedControls: controls.filter((control) => control.status === "pass").length,
+            failedControls: controls.filter((control) => control.status === "fail").length,
+            needsEvidenceControls: controls.filter((control) => control.status === "needs-evidence").length,
+            manualReviewControls: controls.filter((control) => control.status === "manual-review").length,
+        },
+        bundleVerdict: bundle.verdict,
+        controls,
+        regression,
+        provenance: { evidenceBundle, sourceArtifacts },
+    };
+}
+export async function writeReleaseGateArtifacts(outDir, report) {
+    const resolvedOutDir = resolve(outDir);
+    await mkdir(resolvedOutDir, { recursive: true });
+    const paths = {
+        json: resolve(resolvedOutDir, "agentcert-release-gate.json"),
+        markdown: resolve(resolvedOutDir, "agentcert-release-gate.md"),
+        html: resolve(resolvedOutDir, "agentcert-release-gate.html"),
+        junit: resolve(resolvedOutDir, "agentcert-release-gate-junit.xml"),
+        badge: resolve(resolvedOutDir, "release-gate-badge.svg"),
+    };
+    await Promise.all([
+        writeFile(paths.json, `${JSON.stringify(report, null, 2)}\n`),
+        writeFile(paths.markdown, renderReleaseGateMarkdown(report)),
+        writeFile(paths.html, renderReleaseGateHtml(report)),
+        writeFile(paths.junit, renderReleaseGateJunit(report)),
+        writeFile(paths.badge, renderReleaseGateBadge(report)),
+    ]);
+    return paths;
+}
+export function renderReleaseGateSummary(report) {
+    const lines = [
+        "# Witnora Release Gate",
+        "",
+        `Subject: ${report.subject.name}`,
+        `Verdict: ${report.verdict.passed ? "PASS" : "FAIL"}`,
+        `Controls: ${report.verdict.passedControls}/10 passed, ${report.verdict.failedControls} failed, ${report.verdict.needsEvidenceControls} need evidence, ${report.verdict.manualReviewControls} need manual review`,
+        `Regression: ${report.regression.status}`,
+    ];
+    if (report.verdict.blockers.length > 0) {
+        lines.push("", "Blockers:", ...report.verdict.blockers.map((blocker) => `- ${blocker}`));
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function validateReleaseGateReport(input) {
+    const errors = [];
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return ["$ must be an object."];
+    const value = input;
+    if (value.schemaVersion !== AGENTCERT_RELEASE_GATE_SCHEMA_VERSION) {
+        errors.push(`schemaVersion must be ${JSON.stringify(AGENTCERT_RELEASE_GATE_SCHEMA_VERSION)}.`);
+    }
+    if (value.kind !== "agentcert.release_gate")
+        errors.push('kind must be "agentcert.release_gate".');
+    if (typeof value.runId !== "string" || value.runId.length === 0)
+        errors.push("runId must be a non-empty string.");
+    if (!Array.isArray(value.controls) || value.controls.length !== RELEASE_GATE_CONTROL_IDS.length) {
+        errors.push(`controls must contain ${RELEASE_GATE_CONTROL_IDS.length} entries.`);
+    }
+    else {
+        const seen = new Set();
+        for (const [index, controlInput] of value.controls.entries()) {
+            const control = record(controlInput);
+            if (typeof control.id !== "string" || !RELEASE_GATE_CONTROL_IDS.includes(control.id)) {
+                errors.push(`controls[${index}].id is not a supported release control.`);
+            }
+            else {
+                seen.add(control.id);
+            }
+            if (!["automated", "evidence-required", "manual"].includes(control.mode)) {
+                errors.push(`controls[${index}].mode is invalid.`);
+            }
+            if (!["pass", "fail", "needs-evidence", "manual-review"].includes(control.status)) {
+                errors.push(`controls[${index}].status is invalid.`);
+            }
+            if (!Array.isArray(control.evidence))
+                errors.push(`controls[${index}].evidence must be an array.`);
+        }
+        if (seen.size !== RELEASE_GATE_CONTROL_IDS.length)
+            errors.push("controls must contain every release control exactly once.");
+    }
+    if (!value.verdict || typeof value.verdict !== "object" || Array.isArray(value.verdict)) {
+        errors.push("verdict must be an object.");
+    }
+    else if (typeof record(value.verdict).passed !== "boolean") {
+        errors.push("verdict.passed must be a boolean.");
+    }
+    if (!value.regression || typeof value.regression !== "object" || Array.isArray(value.regression))
+        errors.push("regression must be an object.");
+    if (!value.provenance || typeof value.provenance !== "object" || Array.isArray(value.provenance))
+        errors.push("provenance must be an object.");
+    return errors;
+}
+function evaluatePermissionBoundary(bundle) {
+    const decision = bundle.evidence.find((item) => item.kind === "authorization_decision");
+    if (!decision) {
+        return unresolved("needs-evidence", "No runtime authorization decision proves the principal and granted permissions.");
+    }
+    const metadata = record(decision.metadata);
+    const allowed = metadata.decision === "ALLOW";
+    return {
+        status: allowed ? "pass" : "fail",
+        summary: allowed ? "Runtime authorization allowed the recorded principal within granted permissions." : "Runtime authorization denied the action.",
+        evidence: evidenceReferences([decision]),
+    };
+}
+function evaluateDataBoundary(bundle) {
+    const exposures = bundle.evidence.filter((item) => item.kind === "sensitive_data_exposure" ||
+        item.kind === "secret_exposure" ||
+        /sensitive|secret|credential|pii/i.test(item.kind));
+    if (exposures.some((item) => item.severity === "critical" || item.severity === "high")) {
+        return { status: "fail", summary: "Sensitive-data evidence contains a blocking finding.", evidence: evidenceReferences(exposures) };
+    }
+    return unresolved("needs-evidence", "No blocking leak was observed, but an explicit data-boundary test or attestation is required.");
+}
+function evaluateProduct(bundle, product, missingSummary) {
+    const result = bundle.results.find((item) => item.product === product);
+    if (!result)
+        return unresolved("needs-evidence", missingSummary);
+    return {
+        status: result.passed ? "pass" : "fail",
+        summary: result.summary ?? `${product} ${result.passed ? "passed" : "failed"}.`,
+        evidence: resultEvidence(result),
+    };
+}
+function evaluateStateVerification(bundle) {
+    const results = bundle.results.filter((result) => result.product === "tripwire-ci" || result.product === "onegent-runtime");
+    if (results.length === 0) {
+        return unresolved("needs-evidence", "No Tripwire or Onegent result proves expected state against observed state.");
+    }
+    const failed = results.filter((result) => !result.passed);
+    return {
+        status: failed.length === 0 ? "pass" : "fail",
+        summary: failed.length === 0 ? "Configured browser/runtime state verification passed." : `${failed.map((item) => item.product).join(", ")} state verification failed.`,
+        evidence: results.flatMap(resultEvidence),
+    };
+}
+function evaluateHumanHandoff(bundle) {
+    const onegent = bundle.results.find((result) => result.product === "onegent-runtime");
+    if (!onegent)
+        return unresolved("needs-evidence", "No runtime approval or human-handoff record is present.");
+    const approval = onegent.evidence.find((item) => item.kind === "approval_record");
+    const risk = onegent.evidence.find((item) => item.kind === "runtime_risk_assessment");
+    const requiresApproval = record(risk?.metadata).requiresHumanApproval;
+    if (!approval && requiresApproval === false) {
+        return { status: "pass", summary: "Recorded risk assessment did not require human approval.", evidence: evidenceReferences(risk ? [risk] : []) };
+    }
+    if (!approval)
+        return unresolved("needs-evidence", "The runtime result does not contain an approval decision.");
+    const status = record(approval.metadata).status;
+    return {
+        status: status === "APPROVED" ? "pass" : "fail",
+        summary: status === "APPROVED" ? "The high-risk action has a recorded human approval." : `Approval status ${String(status ?? "UNKNOWN")} does not allow execution.`,
+        evidence: evidenceReferences([approval]),
+    };
+}
+function evaluateObservability(bundle) {
+    const missingArtifacts = bundle.results.filter((result) => Object.values(result.artifacts).filter(Boolean).length === 0);
+    if (!bundle.runId || !bundle.generatedAt || bundle.results.length === 0 || missingArtifacts.length > 0) {
+        return { status: "fail", summary: "The bundle is missing traceable run metadata or product artifacts.", evidence: [] };
+    }
+    return {
+        status: "pass",
+        summary: "Run identity, timestamps, normalized results, findings, and artifact pointers are present.",
+        evidence: bundle.results.flatMap(resultEvidence),
+    };
+}
+function applyAttestation(control, attestation) {
+    if (!attestation)
+        return control;
+    const attestationEvidence = Array.isArray(attestation.evidence) ? attestation.evidence.filter(Boolean) : [];
+    const complete = Boolean(attestation.owner && attestation.reviewedAt && attestationEvidence.length > 0);
+    if (!complete) {
+        return {
+            ...control,
+            status: control.status === "fail" ? "fail" : control.mode === "manual" ? "manual-review" : "needs-evidence",
+            summary: `${control.summary} The configured attestation is incomplete; owner, reviewedAt, and evidence are required.`,
+        };
+    }
+    if (control.status === "fail") {
+        return { ...control, evidence: [...control.evidence, ...attestationEvidence], owner: attestation.owner, reviewedAt: attestation.reviewedAt };
+    }
+    if (control.mode === "automated" && control.status !== "pass") {
+        return {
+            ...control,
+            summary: `${control.summary} An attestation cannot replace missing automated evidence.`,
+            evidence: [...control.evidence, ...attestationEvidence],
+            owner: attestation.owner,
+            reviewedAt: attestation.reviewedAt,
+        };
+    }
+    return {
+        ...control,
+        status: attestation.status,
+        summary: attestation.note ?? `Control attested ${attestation.status} by ${attestation.owner}.`,
+        evidence: [...control.evidence, ...attestationEvidence],
+        owner: attestation.owner,
+        reviewedAt: attestation.reviewedAt,
+    };
+}
+function compareWithBaseline(current, baseline, options) {
+    if (!baseline) {
+        return {
+            status: options.requireBaseline ? "fail" : "not-configured",
+            currentRunId: current.runId,
+            maxScoreDrop: options.maxScoreDrop,
+            regressions: options.requireBaseline ? ["A baseline evidence bundle is required but was not provided."] : [],
+        };
+    }
+    const regressions = [];
+    const scoreDelta = current.verdict.score - baseline.verdict.score;
+    if (current.subject.name !== baseline.subject.name) {
+        regressions.push(`Baseline subject ${baseline.subject.name} does not match current subject ${current.subject.name}.`);
+    }
+    if (baseline.verdict.passed && !current.verdict.passed)
+        regressions.push("Overall verdict changed from pass to fail.");
+    if (scoreDelta < -options.maxScoreDrop) {
+        regressions.push(`Overall score dropped by ${Math.abs(scoreDelta)} points; allowed drop is ${options.maxScoreDrop}.`);
+    }
+    for (const baselineResult of baseline.results) {
+        const currentResult = current.results.find((item) => item.product === baselineResult.product);
+        if (!currentResult) {
+            regressions.push(`${baselineResult.product} evidence is missing from the current run.`);
+        }
+        else if (baselineResult.passed && !currentResult.passed) {
+            regressions.push(`${baselineResult.product} changed from pass to fail.`);
+        }
+    }
+    return {
+        status: regressions.length === 0 ? "pass" : "fail",
+        baselineRunId: baseline.runId,
+        currentRunId: current.runId,
+        scoreDelta,
+        maxScoreDrop: options.maxScoreDrop,
+        regressions,
+    };
+}
+function collectBlockers(bundle, controls, regression, strict, requireBaseline, sourceArtifacts, evidenceBundle) {
+    const blockers = [];
+    if (!bundle.verdict.passed)
+        blockers.push("The unified Witnora evidence bundle verdict failed.");
+    for (const control of controls) {
+        if (control.status === "fail")
+            blockers.push(`${control.name}: ${control.summary}`);
+        if (strict && control.status === "needs-evidence")
+            blockers.push(`${control.name}: evidence is required in strict mode.`);
+        if (strict && control.status === "manual-review")
+            blockers.push(`${control.name}: manual review is required in strict mode.`);
+    }
+    if (regression.status === "fail" && (regression.baselineRunId || requireBaseline))
+        blockers.push(...regression.regressions);
+    for (const artifact of [...sourceArtifacts, ...(evidenceBundle ? [evidenceBundle] : [])]) {
+        if (artifact.status === "missing")
+            blockers.push(`Referenced artifact is missing: ${artifact.path}`);
+    }
+    return [...new Set(blockers)];
+}
+async function digestArtifacts(input, cwd) {
+    const entries = Object.entries(input).filter((entry) => Boolean(entry[1]));
+    return Promise.all(entries.map(([name, path]) => digestArtifact(name, path, cwd)));
+}
+async function digestArtifact(name, path, cwd) {
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(path))
+        return { name, path, status: "remote" };
+    const fullPath = resolve(cwd, path);
+    try {
+        await access(fullPath);
+        if ((await stat(fullPath)).isDirectory()) {
+            return { name, path: path.replace(/\\/g, "/"), status: "verified" };
+        }
+        const bytes = await readFile(fullPath);
+        return { name, path: path.replace(/\\/g, "/"), sha256: createHash("sha256").update(bytes).digest("hex"), status: "verified" };
+    }
+    catch {
+        return { name, path: path.replace(/\\/g, "/"), status: "missing" };
+    }
+}
+function resultEvidence(result) {
+    const evidence = evidenceReferences(result.evidence);
+    const artifacts = Object.values(result.artifacts).filter(Boolean);
+    return [...new Set([...evidence, ...artifacts])];
+}
+function evidenceReferences(evidence) {
+    return evidence.map((item) => item.artifactPath ?? `${item.source ?? "agentcert"}:${item.id}`);
+}
+function unresolved(status, summary) {
+    return { status, summary, evidence: [] };
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function renderReleaseGateMarkdown(report) {
+    const lines = [
+        "# Witnora Release Gate",
+        "",
+        `Subject: ${report.subject.name}`,
+        `Generated: ${report.generatedAt}`,
+        `Verdict: ${report.verdict.passed ? "PASS" : "FAIL"}`,
+        `Mode: ${report.strict ? "strict" : "advisory"}`,
+        "",
+        "## Controls",
+        "",
+        "| Control | Mode | Status | Summary |",
+        "|---|---|---|---|",
+        ...report.controls.map((control) => `| ${control.name} | ${control.mode} | ${control.status} | ${control.summary.replaceAll("|", "\\|")} |`),
+        "",
+        "## Regression",
+        "",
+        `Status: ${report.regression.status}`,
+        ...(report.regression.regressions.length > 0 ? report.regression.regressions.map((item) => `- ${item}`) : ["No regression detected or no baseline configured."]),
+        "",
+        "## Blockers",
+        "",
+        ...(report.verdict.blockers.length > 0 ? report.verdict.blockers.map((item) => `- ${item}`) : ["No release blockers."]),
+        "",
+        "## Provenance",
+        "",
+        ...[...(report.provenance.evidenceBundle ? [report.provenance.evidenceBundle] : []), ...report.provenance.sourceArtifacts].map((artifact) => `- ${artifact.name}: \`${artifact.path}\` (${artifact.status}${artifact.sha256 ? `, sha256 ${artifact.sha256}` : ""})`),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function renderReleaseGateHtml(report) {
+    const rows = report.controls.map((control) => `<tr><td>${escapeHtml(control.name)}</td><td>${escapeHtml(control.mode)}</td><td><strong class="${control.status}">${escapeHtml(control.status)}</strong></td><td>${escapeHtml(control.summary)}</td></tr>`).join("");
+    const blockers = report.verdict.blockers.length > 0 ? report.verdict.blockers.map((item) => `<li>${escapeHtml(item)}</li>`).join("") : "<li>No release blockers.</li>";
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Witnora Release Gate</title><style>:root{--ink:#132033;--muted:#617083;--line:#d7dee8;--bg:#f5f7fa;--pass:#087f5b;--fail:#c92a2a;--warn:#a45a00}body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.5 system-ui,sans-serif}main{width:min(1100px,calc(100% - 32px));margin:auto;padding:36px 0}h1{font-size:42px;margin:0}.verdict{font-size:28px;color:${report.verdict.passed ? "var(--pass)" : "var(--fail)"}}section{background:#fff;border:1px solid var(--line);border-radius:8px;padding:20px;margin-top:16px;overflow:auto}table{width:100%;border-collapse:collapse;min-width:760px}th,td{text-align:left;padding:10px;border-bottom:1px solid var(--line);vertical-align:top}.pass{color:var(--pass)}.fail{color:var(--fail)}.needs-evidence,.manual-review{color:var(--warn)}p{color:var(--muted)}</style></head><body><main><p>Witnora Assurance Control Plane</p><h1>${escapeHtml(report.subject.name)}</h1><strong class="verdict">${report.verdict.passed ? "RELEASE READY" : "RELEASE BLOCKED"}</strong><p>${escapeHtml(report.generatedAt)} · ${report.strict ? "strict" : "advisory"} mode · baseline ${escapeHtml(report.regression.status)}</p><section><h2>Ten release controls</h2><table><thead><tr><th>Control</th><th>Mode</th><th>Status</th><th>Decision</th></tr></thead><tbody>${rows}</tbody></table></section><section><h2>Blockers</h2><ul>${blockers}</ul></section></main></body></html>\n`;
+}
+function renderReleaseGateJunit(report) {
+    const failures = report.controls.filter((control) => control.status === "fail" || (report.strict && control.status !== "pass")).length + (report.regression.status === "fail" ? 1 : 0);
+    const skipped = (report.strict ? 0 : report.controls.filter((control) => control.status === "needs-evidence" || control.status === "manual-review").length) + (report.regression.status === "not-configured" ? 1 : 0);
+    const tests = report.controls.length + 1;
+    const cases = report.controls.map((control) => {
+        const body = control.status === "fail" || (report.strict && control.status !== "pass")
+            ? `<failure message="${escapeXml(control.summary)}"/>`
+            : control.status === "needs-evidence" || control.status === "manual-review"
+                ? `<skipped message="${escapeXml(control.summary)}"/>`
+                : "";
+        return `<testcase classname="agentcert.release-gate" name="${escapeXml(control.id)}">${body}</testcase>`;
+    });
+    const regressionBody = report.regression.status === "fail" ? `<failure message="${escapeXml(report.regression.regressions.join(" "))}"/>` : report.regression.status === "not-configured" ? '<skipped message="No baseline configured."/>' : "";
+    cases.push(`<testcase classname="agentcert.release-gate" name="continuous-regression">${regressionBody}</testcase>`);
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuite name="Witnora release gate" tests="${tests}" failures="${failures}" skipped="${skipped}">\n  ${cases.join("\n  ")}\n</testsuite>\n`;
+}
+function renderReleaseGateBadge(report) {
+    const status = report.verdict.passed ? "ready" : "blocked";
+    const color = report.verdict.passed ? "#087f5b" : "#c92a2a";
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="188" height="20" role="img" aria-label="agentcert release: ${status}"><title>agentcert release: ${status}</title><rect width="112" height="20" rx="3" fill="#132033"/><rect x="109" width="79" height="20" rx="3" fill="${color}"/><g fill="#fff" text-anchor="middle" font-family="Verdana,sans-serif" font-size="11"><text x="56" y="14">agentcert release</text><text x="149" y="14">${status}</text></g></svg>\n`;
+}
+function escapeHtml(value) {
+    return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function escapeXml(value) {
+    return escapeHtml(value).replaceAll("'", "&apos;");
+}

package/dist/report.js

@@ -0,0 +1,165 @@
+export function renderMarkdownReport(bundle) {
+    const lines = [
+        "# Witnora Evidence Report",
+        "",
+        `Subject: ${bundle.subject.name}`,
+        `Generated: ${bundle.generatedAt}`,
+        `Verdict: ${bundle.verdict.passed ? "PASS" : "FAIL"}`,
+        `Score: ${bundle.verdict.score}`,
+        `Evidence strength: ${bundle.evidenceStrength?.level ?? "reported"}`,
+        "",
+        "## Evidence Strength",
+        "",
+        ...(bundle.evidenceStrength?.claims ?? ["A producer supplied a result for this run."]).map((claim) => `- Claim: ${claim}`),
+        ...(bundle.evidenceStrength?.limitations ?? ["This legacy bundle does not declare stronger source controls."]).map((limitation) => `- Limitation: ${limitation}`),
+        "",
+        "## Results",
+        "",
+    ];
+    for (const result of bundle.results) {
+        lines.push(`- ${result.product}: ${result.passed ? "PASS" : "FAIL"} (${result.score}/100, ${result.phase})`, `  ${result.summary ?? ""}`.trimEnd());
+    }
+    lines.push("", "## Evidence", "");
+    if (bundle.evidence.length === 0) {
+        lines.push("No blocking evidence recorded.");
+    }
+    else {
+        for (const evidence of bundle.evidence) {
+            lines.push(`- [${evidence.severity}] ${evidence.kind}: ${evidence.message}`);
+        }
+    }
+    lines.push("", "## Standards Mapping", "");
+    for (const standard of bundle.standards) {
+        lines.push(`- ${standard.name}: ${standard.note}`);
+    }
+    lines.push("", "## Artifacts", "");
+    for (const [name, path] of Object.entries(bundle.artifacts)) {
+        lines.push(`- ${name}: \`${path}\``);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function renderHtmlReport(bundle) {
+    const strength = bundle.evidenceStrength ?? {
+        level: "reported",
+        claims: ["A producer supplied a result for this run."],
+        limitations: ["This legacy bundle does not declare stronger source controls."],
+    };
+    const resultCards = bundle.results
+        .map((result) => `<article class="card ${result.passed ? "pass" : "fail"}">
+        <span>${escapeHtml(result.phase)}</span>
+        <h2>${escapeHtml(result.product)}</h2>
+        <strong>${result.passed ? "PASS" : "FAIL"} ${result.score}/100</strong>
+        <p>${escapeHtml(result.summary ?? "No summary provided.")}</p>
+      </article>`)
+        .join("");
+    const evidenceRows = bundle.evidence.length === 0
+        ? `<tr><td colspan="4">No blocking evidence recorded.</td></tr>`
+        : bundle.evidence
+            .map((evidence) => `<tr>
+              <td><span class="severity ${escapeHtml(evidence.severity)}">${escapeHtml(evidence.severity)}</span></td>
+              <td>${escapeHtml(evidence.kind)}</td>
+              <td>${escapeHtml(evidence.message)}</td>
+              <td>${evidence.artifactPath ? artifactLink(evidence.artifactPath) : "-"}</td>
+            </tr>`)
+            .join("");
+    const artifactRows = Object.entries(bundle.artifacts)
+        .map(([name, path]) => `<tr><td>${escapeHtml(name)}</td><td>${artifactLink(path)}</td></tr>`)
+        .join("");
+    const standardItems = bundle.standards
+        .map((standard) => `<li><strong>${escapeHtml(standard.name)}</strong><span>${escapeHtml(standard.note)}</span></li>`)
+        .join("");
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Witnora Evidence Report</title>
+    <style>
+      :root { color-scheme: light; --ink: #102033; --muted: #5d6978; --line: #d9e0e8; --bg: #f6f8fb; --panel: #fff; --pass: #087f5b; --fail: #c92a2a; }
+      body { margin: 0; font: 15px/1.45 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: var(--ink); background: var(--bg); }
+      main { width: min(1120px, calc(100% - 32px)); margin: 0 auto; padding: 32px 0 48px; }
+      header { display: grid; gap: 16px; margin-bottom: 24px; }
+      h1 { margin: 0; font-size: clamp(32px, 6vw, 62px); line-height: 0.95; }
+      h2 { margin: 0 0 10px; font-size: 18px; }
+      p { color: var(--muted); margin: 0; }
+      .summary { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin: 24px 0; }
+      .metric, .card, section { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 18px; }
+      .metric span, .card span { display: block; color: var(--muted); font-size: 12px; text-transform: uppercase; font-weight: 700; }
+      .metric strong { display: block; margin-top: 8px; font-size: 28px; }
+      .verdict-pass { color: var(--pass); }
+      .verdict-fail { color: var(--fail); }
+      .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 12px; }
+      .card { border-left: 5px solid var(--line); }
+      .card.pass { border-left-color: var(--pass); }
+      .card.fail { border-left-color: var(--fail); }
+      .card strong { display: block; margin: 8px 0; font-size: 20px; }
+      section { margin-top: 16px; overflow-x: auto; }
+      table { width: 100%; border-collapse: collapse; min-width: 720px; }
+      th, td { padding: 10px 8px; border-bottom: 1px solid var(--line); text-align: left; vertical-align: top; }
+      th { font-size: 12px; text-transform: uppercase; color: var(--muted); }
+      a { color: #0b63ce; text-decoration: none; font-weight: 650; }
+      ul { margin: 0; padding-left: 20px; }
+      li { margin: 8px 0; }
+      li span { display: block; color: var(--muted); }
+      .severity { display: inline-block; border-radius: 999px; padding: 2px 8px; font-size: 12px; font-weight: 800; color: #fff; background: #687385; }
+      .severity.critical, .severity.high { background: var(--fail); }
+      .severity.medium { background: #b35c00; }
+      .severity.low, .severity.info { background: #24745a; }
+      @media (max-width: 760px) { .summary { grid-template-columns: 1fr 1fr; } main { width: min(100% - 24px, 1120px); padding-top: 20px; } }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <p>Witnora Evidence Report</p>
+        <h1>${escapeHtml(bundle.subject.name)}</h1>
+        <p>Generated ${escapeHtml(bundle.generatedAt)}. Portable evidence bundle ${escapeHtml(bundle.runId)}.</p>
+      </header>
+      <div class="summary">
+        <div class="metric"><span>Verdict</span><strong class="${bundle.verdict.passed ? "verdict-pass" : "verdict-fail"}">${bundle.verdict.passed ? "PASS" : "FAIL"}</strong></div>
+        <div class="metric"><span>Score</span><strong>${bundle.verdict.score}/100</strong></div>
+        <div class="metric"><span>Evidence strength</span><strong>${escapeHtml(bundle.evidenceStrength?.level ?? "reported")}</strong></div>
+        <div class="metric"><span>Evidence</span><strong>${bundle.summary.totalEvidence}</strong></div>
+      </div>
+      <div class="cards">${resultCards}</div>
+      <section>
+        <h2>Evidence strength: ${escapeHtml(strength.level)}</h2>
+        <h3>Supported claims</h3>
+        <ul>${strength.claims.map((claim) => `<li>${escapeHtml(claim)}</li>`).join("")}</ul>
+        <h3>Limitations</h3>
+        <ul>${strength.limitations.map((limitation) => `<li>${escapeHtml(limitation)}</li>`).join("")}</ul>
+      </section>
+      <section>
+        <h2>Evidence</h2>
+        <table>
+          <thead><tr><th>Severity</th><th>Kind</th><th>Message</th><th>Artifact</th></tr></thead>
+          <tbody>${evidenceRows}</tbody>
+        </table>
+      </section>
+      <section>
+        <h2>Artifacts</h2>
+        <table>
+          <thead><tr><th>Name</th><th>Path</th></tr></thead>
+          <tbody>${artifactRows || `<tr><td colspan="2">No artifacts recorded.</td></tr>`}</tbody>
+        </table>
+      </section>
+      <section>
+        <h2>Standards Mapping</h2>
+        <ul>${standardItems}</ul>
+      </section>
+    </main>
+  </body>
+</html>
+`;
+}
+function artifactLink(path) {
+    const escaped = escapeHtml(path);
+    return `<a href="${escapeHtml(path)}">${escaped}</a>`;
+}
+function escapeHtml(value) {
+    return String(value)
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}