agentcert 0.1.2 → 0.2.1

package/README.md

@@ -1,10 +1,10 @@
 # AgentCert CLI
 
-Unified evidence, corpus, monitor, and lab CLI for AgentCert.
+Unified release assurance, evidence, corpus, monitor, and lab CLI for AgentCert.
 
-AgentCert is regression CI for browser agents. It runs Tripwire robustness
-checks, converts the result into evidence bundles, writes HTML reports and
-badges, and accumulates a local failure corpus.
+AgentCert checks what an agent may do, whether it passed pre-release evidence,
+whether a high-risk runtime action may proceed, and who can verify the observed
+outcome. It writes portable reports and accumulates a local failure corpus.
 
 ## 5-minute local path
 
@@ -34,6 +34,19 @@ Default outputs:
 - `.agentcert/latest/reviewed-failure-dataset.jsonl`
 - `.agentcert/latest/monitor.json`
 
+Push the validated evidence bundle into a hosted AgentCert project:
+
+```bash
+export AGENTCERT_BASE_URL="https://agentcert.example.com"
+export AGENTCERT_PROJECT_ID="your-project-id"
+export AGENTCERT_API_KEY="ac_live_..."
+npx agentcert push --evidence .agentcert/latest/agentcert-evidence.json
+```
+
+Add `--push` to `agentcert run` to run locally and upload the resulting bundle
+in one command. Project API keys can create runs, record events, and upload
+evidence, but cannot approve their own runtime actions.
+
 Review/export helpers:
 
 ```bash
@@ -42,16 +55,23 @@ npx agentcert corpus export-reviewed --corpus .agentcert/corpus/corpus.jsonl --o
 npx agentcert corpus classifier-eval --corpus .agentcert/corpus/corpus.jsonl --out .agentcert/latest/failure-classifier-evaluation.json
 npx agentcert validate .agentcert/latest/agentcert-evidence.json
 npx agentcert validate .agentcert/latest/agentcert-evidence.json --check-artifacts
+npx agentcert release-gate --config agentcert.config.json --strict
+npx agentcert release-gate --evidence .agentcert/latest/agentcert-evidence.json --baseline .agentcert/baselines/main.json
 npx agentcert schema validate --schema evidence-bundle --file .agentcert/latest/agentcert-evidence.json
 npx agentcert schema validate --schema classifier-eval --file examples/agentcert/classifier-eval.example.json
 ```
 
-Release gate checklist:
+The release gate writes fixed JSON, HTML, Markdown, JUnit, and badge outputs,
+records SHA-256 artifact provenance, and supports optional Ed25519 signatures:
 
-```text
-docs/release-gate-checklist.md
+```bash
+npx agentcert evidence keygen --private-key .agentcert/keys/evidence-private.pem --public-key .agentcert/keys/evidence-public.pem
+npx agentcert evidence sign .agentcert/latest/agentcert-evidence.json --private-key .agentcert/keys/evidence-private.pem
 ```
 
+Control semantics and attestation format:
+[release gate checklist](https://github.com/Kakarottoooo/agentcert/blob/main/docs/release-gate-checklist.md).
+
 CI users can run Tripwire and AgentCert together with
 `Kakarottoooo/agentcert/actions/tripwire@v0`.
 

package/dist/cli.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { validateEvidenceArtifacts } from "./artifact-validation.js";
 import { renderAgentCertBadge } from "./badge.js";
 import { buildEvidenceBundle } from "./bundle.js";
 import { recordsFromAgentCertResult, evaluateFailureClassifier, renderCorpusSummary, summarizeCorpus, writeReviewedFailureDataset, } from "./corpus.js";
 import { openCorpusStore, parseCorpusStoreKind } from "./corpus-store.js";
+import { pushEvidenceToControlPlane } from "./control-plane.js";
 import { applyFailureReviews, appendFailureReview, createFailureReview, findFailurePattern, parseFailureReviewStatus, parseFailureType, parseReviewConfidence, readFailureReviews, } from "./failure-review.js";
 import { buildMonitorSnapshot, writeMonitorSnapshot } from "./monitor.js";
 import { normalizeMcpBenchResult, normalizeOnegentAuditPacket, normalizeTripwireResult } from "./normalizers.js";
 import { renderHtmlReport, renderMarkdownReport } from "./report.js";
+import { generateEvidenceSigningKeyPair, signEvidenceFile, verifyEvidenceFile, } from "./evidence-signing.js";
+import { buildReleaseGateReport, renderReleaseGateSummary, writeReleaseGateArtifacts, } from "./release-gate.js";
 import { serveAgentCertMonitor } from "./local-server.js";
 import { parseSchemaId, validateAgentCertSchema } from "./schema-validator.js";
-import { loadRunProfile, profileFromArtifactFlags, renderRunSummary, runAgentCertProfile, } from "./runner.js";
+import { applyRunOverrides, loadRunProfile, profileFromArtifactFlags, renderRunSummary, runAgentCertProfile, } from "./runner.js";
 import { buildRobustnessLabSnapshot, readRobustnessLabConfig, renderRobustnessLabSummary, writeRobustnessLabSnapshot } from "./lab.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
@@ -52,6 +55,9 @@ if (command === "init") {
             },
             gate: {
                 failOnVerdict: true,
+                strict: false,
+                outDir: ".agentcert/latest",
+                maxScoreDrop: 0,
             },
             manifest: {
                 out: ".agentcert/latest/agentcert-run-manifest.json",
@@ -264,8 +270,127 @@ else if (command === "run") {
         overrides,
     });
     process.stdout.write(renderRunSummary(outcome));
+    if (readBoolFlag("--push")) {
+        await pushHostedEvidence(outcome.bundle, Buffer.from(`${JSON.stringify(outcome.bundle, null, 2)}\n`), "agentcert-evidence.json");
+    }
     process.exitCode = outcome.exitCode;
 }
+else if (command === "push") {
+    const evidencePath = resolve(readFlag("--evidence") ?? ".agentcert/latest/agentcert-evidence.json");
+    const evidenceBytes = await readFile(evidencePath);
+    let bundle;
+    try {
+        bundle = JSON.parse(evidenceBytes.toString("utf8"));
+    }
+    catch {
+        throw new Error(`Evidence file is not valid JSON: ${evidencePath}`);
+    }
+    const validation = validateAgentCertSchema("evidence-bundle", bundle);
+    if (!validation.valid) {
+        throw new Error(`Evidence bundle is invalid:\n${validation.errors.map((error) => `- ${error}`).join("\n")}`);
+    }
+    await pushHostedEvidence(bundle, evidenceBytes, basename(evidencePath));
+}
+else if (command === "release-gate") {
+    const overrides = readRunOverrides();
+    const profileName = readFlag("--profile");
+    const configPath = readFlag("--config");
+    const evidenceInput = readFlag("--evidence");
+    let profile;
+    let bundle;
+    let evidenceBundlePath;
+    let sourceArtifacts;
+    if (evidenceInput) {
+        profile = configPath ? applyRunOverrides(await loadRunProfile(profileName, configPath), overrides) : undefined;
+        bundle = (await readJson(evidenceInput));
+        evidenceBundlePath = resolve(evidenceInput);
+        sourceArtifacts = bundle.artifacts;
+    }
+    else {
+        const hasArtifactFlags = Boolean(overrides.mcpbench || overrides.tripwire || overrides.onegent);
+        const loadedProfile = hasArtifactFlags && !profileName && !configPath
+            ? profileFromArtifactFlags(overrides)
+            : await loadRunProfile(profileName, configPath);
+        profile = applyRunOverrides(loadedProfile, overrides);
+        const outcome = await runAgentCertProfile(profile, {
+            runCommands: !readBoolFlag("--skip-commands"),
+        });
+        bundle = outcome.bundle;
+        evidenceBundlePath = resolve(outcome.manifest.outputs.evidenceBundle ?? join(profile.outputDir, "agentcert-evidence.json"));
+        sourceArtifacts = profile.artifacts;
+        if (!outcome.manifest.outputs.evidenceBundle) {
+            await mkdir(dirname(evidenceBundlePath), { recursive: true });
+            await writeFile(evidenceBundlePath, `${JSON.stringify(outcome.bundle, null, 2)}\n`);
+        }
+    }
+    const outDir = resolve(readFlag("--out") ?? profile?.run?.gate?.outDir ?? profile?.outputDir ?? dirname(evidenceBundlePath));
+    await mkdir(outDir, { recursive: true });
+    const baselinePath = readFlag("--baseline") ?? profile?.run?.gate?.baseline;
+    const baseline = baselinePath ? (await readJson(baselinePath)) : undefined;
+    const report = await buildReleaseGateReport(bundle, {
+        strict: readBoolFlag("--strict") || profile?.run?.gate?.strict,
+        requireBaseline: readBoolFlag("--require-baseline") || profile?.run?.gate?.requireBaseline,
+        maxScoreDrop: parseOptionalNonNegativeNumber(readFlag("--max-score-drop"), "--max-score-drop") ?? profile?.run?.gate?.maxScoreDrop,
+        baseline,
+        attestations: profile?.run?.gate?.controls,
+        sourceArtifacts,
+        evidenceBundlePath,
+    });
+    const paths = await writeReleaseGateArtifacts(outDir, report);
+    const saveBaselinePath = readFlag("--save-baseline");
+    if (saveBaselinePath) {
+        if (report.verdict.passed) {
+            await mkdir(dirname(resolve(saveBaselinePath)), { recursive: true });
+            await writeFile(resolve(saveBaselinePath), `${JSON.stringify(bundle, null, 2)}\n`);
+            process.stdout.write(`Saved passing baseline ${resolve(saveBaselinePath)}\n`);
+        }
+        else {
+            process.stdout.write(`Baseline not saved because the release gate failed: ${resolve(saveBaselinePath)}\n`);
+        }
+    }
+    const privateKey = readFlag("--sign-private-key") ?? profile?.run?.gate?.signing?.privateKey;
+    if (privateKey) {
+        await signEvidenceFile(evidenceBundlePath, privateKey);
+        await signEvidenceFile(paths.json, privateKey);
+        process.stdout.write(`Signed ${evidenceBundlePath}\nSigned ${paths.json}\n`);
+    }
+    process.stdout.write(renderReleaseGateSummary(report));
+    process.stdout.write(`Release gate JSON: ${paths.json}\nRelease gate HTML: ${paths.html}\nRelease gate JUnit: ${paths.junit}\n`);
+    process.exitCode = report.verdict.passed ? 0 : 1;
+}
+else if (command === "evidence") {
+    const action = process.argv[3] ?? "help";
+    if (action === "keygen") {
+        const privateKeyPath = readFlag("--private-key") ?? ".agentcert/keys/evidence-private.pem";
+        const publicKeyPath = readFlag("--public-key") ?? ".agentcert/keys/evidence-public.pem";
+        await generateEvidenceSigningKeyPair(privateKeyPath, publicKeyPath);
+        process.stdout.write(`Wrote private key ${resolve(privateKeyPath)}\nWrote public key ${resolve(publicKeyPath)}\n`);
+    }
+    else if (action === "sign") {
+        const file = readFlag("--file") ?? readPositional(4);
+        if (!file)
+            throw new Error("Missing evidence file. Usage: agentcert evidence sign <file> --private-key <path>.");
+        const privateKeyPath = requiredFlag("--private-key");
+        const signaturePath = readFlag("--out") ?? `${file}.sig.json`;
+        const signature = await signEvidenceFile(file, privateKeyPath, signaturePath);
+        process.stdout.write(`Signed ${resolve(file)}\nSignature: ${resolve(signaturePath)}\nKey id: ${signature.keyId}\n`);
+    }
+    else if (action === "verify") {
+        const file = readFlag("--file") ?? readPositional(4);
+        if (!file)
+            throw new Error("Missing evidence file. Usage: agentcert evidence verify <file> --signature <path> --public-key <path>.");
+        const result = await verifyEvidenceFile(file, requiredFlag("--signature"), requiredFlag("--public-key"));
+        process.stdout.write(`${result.valid ? "Valid" : "Invalid"} evidence signature: ${resolve(file)}\nKey id: ${result.keyId}\nSHA-256: ${result.artifactSha256}\n`);
+        process.exitCode = result.valid ? 0 : 1;
+    }
+    else {
+        process.stdout.write(`Usage:
+  agentcert evidence keygen --private-key .agentcert/keys/evidence-private.pem --public-key .agentcert/keys/evidence-public.pem
+  agentcert evidence sign .agentcert/latest/agentcert-evidence.json --private-key .agentcert/keys/evidence-private.pem
+  agentcert evidence verify .agentcert/latest/agentcert-evidence.json --signature .agentcert/latest/agentcert-evidence.json.sig.json --public-key .agentcert/keys/evidence-public.pem
+`);
+    }
+}
 else if (command === "lab") {
     const action = process.argv[3] ?? "help";
     if (action === "build") {
@@ -318,6 +443,8 @@ else if (command === "schema") {
   agentcert schema validate --schema monitor-snapshot --file .agentcert/latest/monitor.json
   agentcert schema validate --schema corpus-record --file examples/agentcert/corpus-record.example.json
   agentcert schema validate --schema classifier-eval --file examples/agentcert/classifier-eval.example.json
+  agentcert schema validate --schema release-gate --file .agentcert/latest/agentcert-release-gate.json
+  agentcert schema validate --schema evidence-signature --file .agentcert/latest/agentcert-evidence.json.sig.json
 `);
     }
 }
@@ -364,7 +491,16 @@ else {
   agentcert monitor build --corpus .agentcert/corpus/corpus.jsonl --out .agentcert/latest/monitor.json --subject my-agent
   agentcert monitor build --store sqlite --sqlite .agentcert/corpus/agentcert.sqlite --out .agentcert/latest/monitor.json --subject my-agent
   agentcert run --profile public-demo
+  agentcert push --evidence .agentcert/latest/agentcert-evidence.json --server https://agentcert.example.com --project <project-id>
+  agentcert run --tripwire .tripwire/latest/tripwire-result.json --push
   agentcert run --mcpbench .mcpbench/latest/results.json --tripwire .tripwire/latest/tripwire-result.json --onegent .onegent/procurement/audit-packet.json --out .agentcert/latest --corpus .agentcert/corpus/corpus.jsonl --monitor-out .agentcert/latest/monitor.json --reviewed-dataset-out .agentcert/latest/reviewed-failure-dataset.jsonl
+  agentcert release-gate --config agentcert.config.json --strict
+  agentcert release-gate --evidence .agentcert/latest/agentcert-evidence.json --baseline .agentcert/baselines/main.json
+  agentcert release-gate --evidence .agentcert/latest/agentcert-evidence.json --save-baseline .agentcert/baselines/main.json
+  agentcert release-gate --tripwire .tripwire/latest/tripwire-result.json --baseline .agentcert/baselines/main.json
+  agentcert evidence keygen --private-key .agentcert/keys/evidence-private.pem --public-key .agentcert/keys/evidence-public.pem
+  agentcert evidence sign .agentcert/latest/agentcert-evidence.json --private-key .agentcert/keys/evidence-private.pem
+  agentcert evidence verify .agentcert/latest/agentcert-evidence.json --signature .agentcert/latest/agentcert-evidence.json.sig.json --public-key .agentcert/keys/evidence-public.pem
   agentcert lab build --config examples/real-agents/robustness-lab/lab.config.json --out public-demo/real-agent-robustness/evidence/lab-snapshot.json
   agentcert serve --corpus .agentcert/corpus/corpus.jsonl --static public-demo/agentcert-monitor --artifact-root public-demo/browser-agent-robustness/evidence/tripwire-public-demo
   agentcert validate .agentcert/latest/agentcert-evidence.json
@@ -378,6 +514,24 @@ async function loadConfig(path) {
     }
     return (await readJson(path));
 }
+async function pushHostedEvidence(bundle, bytes, fileName) {
+    const baseUrl = readFlag("--server") ?? process.env.AGENTCERT_BASE_URL;
+    const projectId = readFlag("--project") ?? process.env.AGENTCERT_PROJECT_ID;
+    const apiKey = readFlag("--api-key") ?? process.env.AGENTCERT_API_KEY;
+    if (!baseUrl || !projectId || !apiKey) {
+        throw new Error("Hosted push requires AGENTCERT_BASE_URL, AGENTCERT_PROJECT_ID, and AGENTCERT_API_KEY (or --server, --project, and --api-key).");
+    }
+    const result = await pushEvidenceToControlPlane({
+        baseUrl,
+        projectId,
+        apiKey,
+        bundle,
+        evidenceBytes: bytes,
+        fileName,
+        externalId: readFlag("--external-id"),
+    });
+    process.stdout.write(`Hosted run: ${result.runId}\nHosted evidence: ${result.evidenceId}\n`);
+}
 async function readJson(path) {
     const raw = await readFile(resolve(path), "utf8");
     return JSON.parse(raw);
@@ -418,6 +572,19 @@ function readFirstPositionalAfterCommand() {
     }
     return undefined;
 }
+function readPositional(startIndex) {
+    for (let index = startIndex; index < process.argv.length; index += 1) {
+        const value = process.argv[index];
+        if (!value)
+            continue;
+        if (value.startsWith("--")) {
+            index += 1;
+            continue;
+        }
+        return value;
+    }
+    return undefined;
+}
 function readBoolFlag(name) {
     return process.argv.includes(name);
 }
@@ -493,6 +660,15 @@ function parseOptionalNonNegativeInteger(input, flagName) {
     }
     return value;
 }
+function parseOptionalNonNegativeNumber(input, flagName) {
+    if (input === undefined)
+        return undefined;
+    const value = Number(input);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${flagName} must be a non-negative number.`);
+    }
+    return value;
+}
 function readReviewsPath() {
     return readFlag("--reviews") ?? process.env.AGENTCERT_FAILURE_REVIEWS;
 }
@@ -547,6 +723,12 @@ function errorHint(message, code) {
     if (message.includes("already exists")) {
         return "Hint: re-run with `--force` to overwrite starter files, or choose a different `--out` path.";
     }
+    if (message.includes("Hosted push requires")) {
+        return "Hint: create a project API key in AgentCert Integrations, then set AGENTCERT_BASE_URL, AGENTCERT_PROJECT_ID, and AGENTCERT_API_KEY.";
+    }
+    if (message.includes("Authentication required") || message.includes("API key")) {
+        return "Hint: check AGENTCERT_API_KEY and confirm the key belongs to AGENTCERT_PROJECT_ID.";
+    }
     return undefined;
 }
 function starterTripwireConfig(subject) {
@@ -636,6 +818,8 @@ jobs:
           subject: ${JSON.stringify(subject)}
           agentcert-out: .agentcert/latest
           fail-on-verdict: "true"
+          release-gate: "true"
+          strict-release-gate: "false"
           # publish-pages: "true"
 `;
 }

package/dist/control-plane.js

@@ -0,0 +1,109 @@
+export async function pushEvidenceToControlPlane(options) {
+    const baseUrl = options.baseUrl.replace(/\/$/, "");
+    if (!baseUrl || !options.projectId || !options.apiKey) {
+        throw new Error("baseUrl, projectId, and apiKey are required to push evidence.");
+    }
+    const request = options.fetch ?? fetch;
+    const projectUrl = `${baseUrl}/v1/projects/${encodeURIComponent(options.projectId)}`;
+    const externalId = options.externalId ?? options.bundle.runId;
+    const kind = hostedRunKind(options.bundle);
+    const headers = { authorization: `Bearer ${options.apiKey}` };
+    const run = await requestJson(request, `${projectUrl}/runs`, {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: JSON.stringify({
+            externalId,
+            kind,
+            schemaVersion: options.bundle.schemaVersion,
+            startedAt: options.bundle.generatedAt,
+            metadata: {
+                subject: options.bundle.subject,
+                products: options.bundle.summary.products,
+            },
+        }),
+    });
+    await requestJson(request, `${projectUrl}/runs/${encodeURIComponent(run.id)}/events`, {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: JSON.stringify({
+            events: [{
+                    sequence: 0,
+                    type: "agentcert.evidence.created",
+                    actor: "agentcert-cli",
+                    occurredAt: options.bundle.generatedAt,
+                    payload: {
+                        verdict: options.bundle.verdict,
+                        totalEvidence: options.bundle.summary.totalEvidence,
+                        criticalEvidence: options.bundle.summary.criticalEvidence,
+                        highEvidence: options.bundle.summary.highEvidence,
+                    },
+                }],
+        }),
+    });
+    const query = new URLSearchParams({
+        fileName: options.fileName ?? "agentcert-evidence.json",
+        kind: "evidence_bundle",
+        schemaVersion: options.bundle.schemaVersion,
+        runId: run.id,
+    });
+    const evidence = await requestJson(request, `${projectUrl}/evidence?${query}`, {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: new Uint8Array(options.evidenceBytes).buffer,
+    });
+    const firstDivergence = options.bundle.evidence.find((item) => item.severity === "critical" || item.severity === "high")?.message;
+    await requestJson(request, `${projectUrl}/runs/${encodeURIComponent(run.id)}/complete`, {
+        method: "POST",
+        headers: { ...headers, "content-type": "application/json" },
+        body: JSON.stringify({
+            status: options.bundle.verdict.passed ? "passed" : "failed",
+            score: options.bundle.verdict.score,
+            summary: `${options.bundle.subject.name}: ${options.bundle.verdict.level}`,
+            firstDivergence,
+            completedAt: options.bundle.generatedAt,
+            metadata: {
+                evidenceId: evidence.id,
+                evidenceSchemaVersion: options.bundle.schemaVersion,
+            },
+        }),
+    });
+    return { runId: run.id, evidenceId: evidence.id, externalId };
+}
+function hostedRunKind(bundle) {
+    const products = new Set(bundle.summary.products);
+    if (products.size > 1)
+        return "release_gate";
+    if (products.has("mcpbench"))
+        return "mcpbench";
+    if (products.has("tripwire-ci"))
+        return "tripwire";
+    if (products.has("onegent-runtime"))
+        return "runtime";
+    return "custom";
+}
+async function requestJson(request, url, init) {
+    let response;
+    try {
+        response = await request(url, { ...init, signal: init.signal ?? AbortSignal.timeout(30_000) });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`AgentCert control plane request failed: ${message}`);
+    }
+    const text = await response.text();
+    let value = {};
+    if (text) {
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            if (!response.ok)
+                throw new Error(`AgentCert control plane returned HTTP ${response.status}.`);
+            throw new Error("AgentCert control plane returned invalid JSON.");
+        }
+    }
+    if (!response.ok) {
+        throw new Error(typeof value.error === "string" ? value.error : `AgentCert control plane returned HTTP ${response.status}.`);
+    }
+    return value;
+}

package/dist/evidence-signing.js

@@ -0,0 +1,85 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign, verify } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export const AGENTCERT_SIGNATURE_SCHEMA_VERSION = "agentcert.evidence_signature.v0.1";
+export async function generateEvidenceSigningKeyPair(privateKeyPath, publicKeyPath) {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519", {
+        privateKeyEncoding: { type: "pkcs8", format: "pem" },
+        publicKeyEncoding: { type: "spki", format: "pem" },
+    });
+    await Promise.all([
+        writePrivateFile(privateKeyPath, privateKey),
+        writePublicFile(publicKeyPath, publicKey),
+    ]);
+}
+export async function signEvidenceFile(artifactPath, privateKeyPath, signaturePath = `${artifactPath}.sig.json`) {
+    const [artifact, privatePem] = await Promise.all([readFile(resolve(artifactPath)), readFile(resolve(privateKeyPath), "utf8")]);
+    const privateKey = createPrivateKey(privatePem);
+    const publicKey = createPublicKey(privateKey);
+    const envelope = {
+        schemaVersion: AGENTCERT_SIGNATURE_SCHEMA_VERSION,
+        kind: "agentcert.evidence_signature",
+        algorithm: "Ed25519",
+        keyId: keyId(publicKey),
+        signedAt: new Date().toISOString(),
+        artifactPath: artifactPath.replace(/\\/g, "/"),
+        artifactSha256: sha256(artifact),
+        signature: sign(null, artifact, privateKey).toString("base64"),
+    };
+    const resolvedSignaturePath = resolve(signaturePath);
+    await mkdir(dirname(resolvedSignaturePath), { recursive: true });
+    await writeFile(resolvedSignaturePath, `${JSON.stringify(envelope, null, 2)}\n`);
+    return envelope;
+}
+export async function verifyEvidenceFile(artifactPath, signaturePath, publicKeyPath) {
+    const [artifact, signatureRaw, publicPem] = await Promise.all([
+        readFile(resolve(artifactPath)),
+        readFile(resolve(signaturePath), "utf8"),
+        readFile(resolve(publicKeyPath), "utf8"),
+    ]);
+    const envelope = JSON.parse(signatureRaw);
+    const errors = validateEvidenceSignature(envelope);
+    if (errors.length > 0)
+        throw new Error(`Invalid evidence signature: ${errors.join(" ")}`);
+    const publicKey = createPublicKey(publicPem);
+    const artifactSha256 = sha256(artifact);
+    const actualKeyId = keyId(publicKey);
+    const digestMatches = envelope.artifactSha256 === artifactSha256;
+    const keyIdMatches = envelope.keyId === actualKeyId;
+    const signatureMatches = verify(null, artifact, publicKey, Buffer.from(envelope.signature, "base64"));
+    return { valid: digestMatches && signatureMatches && keyIdMatches, digestMatches, signatureMatches, keyIdMatches, artifactSha256, keyId: actualKeyId };
+}
+export function validateEvidenceSignature(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return ["$ must be an object."];
+    const value = input;
+    const errors = [];
+    if (value.schemaVersion !== AGENTCERT_SIGNATURE_SCHEMA_VERSION)
+        errors.push(`schemaVersion must be ${JSON.stringify(AGENTCERT_SIGNATURE_SCHEMA_VERSION)}.`);
+    if (value.kind !== "agentcert.evidence_signature")
+        errors.push('kind must be "agentcert.evidence_signature".');
+    if (value.algorithm !== "Ed25519")
+        errors.push('algorithm must be "Ed25519".');
+    for (const field of ["keyId", "signedAt", "artifactPath", "artifactSha256", "signature"]) {
+        if (typeof value[field] !== "string" || value[field].length === 0)
+            errors.push(`${field} must be a non-empty string.`);
+    }
+    return errors;
+}
+function keyId(publicKey) {
+    const der = publicKey.export({ type: "spki", format: "der" });
+    return `sha256:${sha256(der).slice(0, 32)}`;
+}
+function sha256(input) {
+    return createHash("sha256").update(input).digest("hex");
+}
+async function writePrivateFile(path, content) {
+    const resolved = resolve(path);
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, content, { mode: 0o600, flag: "wx" });
+}
+async function writePublicFile(path, content) {
+    const resolved = resolve(path);
+    await mkdir(dirname(resolved), { recursive: true });
+    await writeFile(resolved, content, { flag: "wx" });
+}

package/dist/index.js

@@ -1,10 +1,13 @@
 export * from "./bundle.js";
 export * from "./corpus.js";
 export * from "./corpus-store.js";
+export * from "./control-plane.js";
 export * from "./failure-review.js";
+export * from "./evidence-signing.js";
 export * from "./local-server.js";
 export * from "./monitor.js";
 export * from "./normalizers.js";
 export * from "./report.js";
+export * from "./release-gate.js";
 export * from "./schema-validator.js";
 export * from "./types.js";

package/dist/normalizers.js

@@ -94,6 +94,8 @@ export function normalizeOnegentAuditPacket(input, artifactPath) {
     const action = asRecord(value.actionIntent);
     const risk = asRecord(value.riskAssessment);
     const approval = asRecord(value.approvalRequest);
+    const principal = asRecord(action.principal);
+    const authorization = asRecord(value.authorizationDecision);
     const verification = asRecord(value.verificationResult);
     const auditEvents = Array.isArray(value.auditEvents) ? value.auditEvents : [];
     const verificationSuccess = verification.success === true;
@@ -101,6 +103,18 @@ export function normalizeOnegentAuditPacket(input, artifactPath) {
     const passed = verificationSuccess && approved;
     const riskLevel = stringValue(risk.riskLevel) ?? "UNKNOWN";
     const evidence = [
+        {
+            id: "onegent_principal",
+            kind: "runtime_identity",
+            severity: "info",
+            message: `Runtime action principal: ${stringValue(principal.id) ?? stringValue(action.sourceAgentName) ?? "UNKNOWN"}.`,
+            source: "onegent-runtime",
+            artifactPath,
+            metadata: {
+                principal,
+                requestedPermissions: action.requestedPermissions,
+            },
+        },
         {
             id: "onegent_risk_assessment",
             kind: "runtime_risk_assessment",
@@ -111,6 +125,17 @@ export function normalizeOnegentAuditPacket(input, artifactPath) {
             metadata: risk,
         },
     ];
+    if (authorization.decision) {
+        evidence.push({
+            id: "onegent_authorization",
+            kind: "authorization_decision",
+            severity: authorization.decision === "ALLOW" ? "info" : "critical",
+            message: `Runtime authorization decision: ${String(authorization.decision)}.`,
+            source: "onegent-runtime",
+            artifactPath,
+            metadata: authorization,
+        });
+    }
     if (approval.status) {
         evidence.push({
             id: "onegent_approval",

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 = [
+        "# AgentCert 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 AgentCert 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 = [
+        "# AgentCert 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>AgentCert 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>AgentCert 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="AgentCert 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/schema-validator.js

@@ -1,4 +1,6 @@
 import { AGENTCERT_EVIDENCE_SCHEMA_SEMVER, AGENTCERT_EVIDENCE_SCHEMA_VERSION } from "./types.js";
+import { validateEvidenceSignature } from "./evidence-signing.js";
+import { validateReleaseGateReport } from "./release-gate.js";
 export function parseSchemaId(input) {
     const value = input ?? "evidence-bundle";
     if (value === "evidence-bundle" ||
@@ -7,13 +9,23 @@ export function parseSchemaId(input) {
         value === "failure-review" ||
         value === "classifier-eval" ||
         value === "monitor-snapshot" ||
-        value === "robustness-lab") {
+        value === "robustness-lab" ||
+        value === "release-gate" ||
+        value === "evidence-signature") {
         return value;
     }
-    throw new Error(`Unsupported schema "${value}". Use evidence-bundle, result, corpus-record, failure-review, classifier-eval, monitor-snapshot, or robustness-lab.`);
+    throw new Error(`Unsupported schema "${value}". Use evidence-bundle, result, corpus-record, failure-review, classifier-eval, monitor-snapshot, robustness-lab, release-gate, or evidence-signature.`);
 }
 export function validateAgentCertSchema(schema, input) {
     const errors = [];
+    if (schema === "release-gate") {
+        errors.push(...validateReleaseGateReport(input));
+        return { schema, valid: errors.length === 0, errors };
+    }
+    if (schema === "evidence-signature") {
+        errors.push(...validateEvidenceSignature(input));
+        return { schema, valid: errors.length === 0, errors };
+    }
     const value = object(input, "$", errors);
     if (value) {
         if (schema === "evidence-bundle")

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentcert",
-  "version": "0.1.2",
-  "description": "Regression CI, evidence reports, and failure corpus tooling for browser agents.",
+  "version": "0.2.1",
+  "description": "Assurance release gates, runtime evidence, and regression CI for AI agents.",
   "type": "module",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Kakarottoooo/agentcert#readme",
@@ -22,7 +22,10 @@
     "llm",
     "mcp",
     "tripwire",
-    "evidence"
+    "evidence",
+    "assurance",
+    "authorization",
+    "audit"
   ],
   "bin": {
     "agentcert": "dist/cli.js"