agentcert 0.5.2 → 0.5.3

package/README.md

@@ -6,8 +6,8 @@ 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.
 
-[Public assurance demo](https://agentcert-control-plane.onrender.com/demo) |
-[Private workspace](https://agentcert-control-plane.onrender.com/app) |
+[Public evidence](https://agentcert.app/evidence) |
+[Private workspace](https://agentcert.app/app) |
 [GitHub source](https://github.com/Kakarottoooo/agentcert)
 
 ## 5-minute local path
@@ -53,7 +53,7 @@ Default outputs:
 Push the validated evidence bundle into a hosted AgentCert project:
 
 ```bash
-npx agentcert connect --server https://agentcert-control-plane.onrender.com --project your-project-id
+npx agentcert connect --server https://agentcert.app --project your-project-id
 npx agentcert push --evidence .agentcert/latest/agentcert-evidence.json
 ```
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { validateEvidenceArtifacts } from "./artifact-validation.js";
@@ -8,6 +8,7 @@ import { buildEvidenceBundle } from "./bundle.js";
 import { collectCompanionArtifacts, MAX_REPORTED_COMPANION_ARTIFACT_SKIPS } from "./companion-artifacts.js";
 import { recordsFromAgentCertResult, evaluateFailureClassifier, renderCorpusSummary, summarizeCorpus, writeReviewedFailureDataset, } from "./corpus.js";
 import { openCorpusStore, parseCorpusStoreKind } from "./corpus-store.js";
+import { deleteCorpusRecords, exportGovernedCorpus, governCorpusRecords, parseCorpusConsent } from "./corpus-governance.js";
 import { pushEvidenceToControlPlane, verifyControlPlaneConnection } from "./control-plane.js";
 import { runEvidenceConformance } from "./conformance.js";
 import { DEFAULT_AGENTCERT_SERVER, resolveConnection, saveConnection } from "./credentials.js";
@@ -62,7 +63,7 @@ else if (command === "init") {
 else if (command === "connect") {
     if (readBoolFlag("--help")) {
         process.stdout.write(`Usage:
-  agentcert connect --server https://agentcert-control-plane.onrender.com --project <project-id>
+  agentcert connect --server https://agentcert.app --project <project-id>
   agentcert connect --name staging --server https://staging.example.com --project <project-id>
 
 The API key is read from AGENTCERT_API_KEY or requested with hidden input.
@@ -124,7 +125,7 @@ else if (command === "corpus") {
             throw new Error("No input artifacts were provided. Use --mcpbench, --tripwire, --onegent, or --config.");
         }
         const reviews = await readFailureReviews(readReviewsPath());
-        const records = applyFailureReviews(loaded.flatMap(({ result, path, raw }) => recordsFromAgentCertResult(result, path, subject, raw)), reviews);
+        const records = governCorpusRecords(applyFailureReviews(loaded.flatMap(({ result, path, raw }) => recordsFromAgentCertResult(result, path, subject, raw)), reviews), { consent: parseCorpusConsent(readFlag("--consent")), consentSource: readFlag("--consent-source") ?? "local-default" });
         const store = await openCorpusStore(storeOptions);
         try {
             await store.append(records, { replace });
@@ -169,6 +170,38 @@ else if (command === "corpus") {
             await store.close();
         }
     }
+    else if (action === "export") {
+        const outPath = readFlag("--out") ?? ".agentcert/latest/governed-corpus.jsonl";
+        const allowed = (readFlag("--consent") ?? "public,anonymous").split(",").map((item) => parseCorpusConsent(item.trim()));
+        const store = await openCorpusStore(readCorpusStoreOptions(".agentcert/corpus/corpus.jsonl"));
+        try {
+            const records = exportGovernedCorpus(await store.readAll(), allowed);
+            await mkdir(dirname(resolve(outPath)), { recursive: true });
+            await writeFile(outPath, records.map((record) => JSON.stringify(record)).join("\n") + (records.length ? "\n" : ""));
+            process.stdout.write(`Exported ${records.length} consented corpus records to ${resolve(outPath)}\n`);
+        }
+        finally {
+            await store.close();
+        }
+    }
+    else if (action === "delete") {
+        const ids = requiredFlag("--record-id").split(",").map((item) => item.trim()).filter(Boolean);
+        const reason = requiredFlag("--reason");
+        const journalPath = readFlag("--journal") ?? ".agentcert/corpus/deletion-journal.jsonl";
+        const store = await openCorpusStore(readCorpusStoreOptions(".agentcert/corpus/corpus.jsonl"));
+        try {
+            const result = deleteCorpusRecords(await store.readAll(), ids, reason);
+            if (!result.tombstones.length)
+                throw new Error("No corpus records matched --record-id; nothing was deleted.");
+            await store.append(result.retained, { replace: true });
+            await mkdir(dirname(resolve(journalPath)), { recursive: true });
+            await appendFile(journalPath, result.tombstones.map((item) => JSON.stringify(item)).join("\n") + "\n");
+            process.stdout.write(`Deleted ${result.tombstones.length} corpus records and wrote non-identifying tombstones to ${resolve(journalPath)}\n`);
+        }
+        finally {
+            await store.close();
+        }
+    }
     else if (action === "classifier-eval") {
         const outPath = readFlag("--out");
         const store = await openCorpusStore(readCorpusStoreOptions(".agentcert/corpus/corpus.jsonl"));
@@ -231,9 +264,12 @@ else if (command === "corpus") {
         process.stdout.write(`Usage:
   agentcert corpus ingest --tripwire .tripwire/latest/tripwire-result.json --out .agentcert/corpus/corpus.jsonl --subject my-agent
   agentcert corpus ingest --store sqlite --sqlite .agentcert/corpus/agentcert.sqlite --tripwire .tripwire/latest/tripwire-result.json --subject my-agent
+  agentcert corpus ingest --tripwire result.json --consent anonymous --consent-source "pilot agreement 2026-07"
   agentcert corpus review --corpus .agentcert/corpus/corpus.jsonl --reviews .agentcert/corpus/failure-reviews.jsonl --pattern-key tripwire:ui_drift:modal-overlay:url_contains --type ui_drift --status confirmed --reviewer you@example.com --confidence 0.8 --why "Visible evidence supports the ui_drift label."
   agentcert corpus metrics --corpus .agentcert/corpus/corpus.jsonl
   agentcert corpus export-reviewed --corpus .agentcert/corpus/corpus.jsonl --out .agentcert/latest/reviewed-failure-dataset.jsonl
+  agentcert corpus export --corpus .agentcert/corpus/corpus.jsonl --consent public,anonymous --out .agentcert/latest/governed-corpus.jsonl
+  agentcert corpus delete --corpus .agentcert/corpus/corpus.jsonl --record-id <id> --reason "participant withdrawal"
   agentcert corpus classifier-eval --corpus .agentcert/corpus/corpus.jsonl --out .agentcert/latest/failure-classifier-evaluation.json
   agentcert corpus summary --corpus .agentcert/corpus/corpus.jsonl
   agentcert corpus summary --store postgres --database-url "$DATABASE_URL"
@@ -452,6 +488,7 @@ else if (command === "schema") {
   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 assurance-report --file assurance-report.json
   agentcert schema validate --schema evidence-signature --file .agentcert/latest/agentcert-evidence.json.sig.json
 `);
     }
@@ -515,7 +552,7 @@ else if (command === "conformance") {
 else {
     process.stdout.write(`Usage:
   agentcert init --subject my-browser-agent
-  agentcert connect --server https://agentcert-control-plane.onrender.com --project <project-id>
+  agentcert connect --server https://agentcert.app --project <project-id>
   agentcert sandbox init
   agentcert sandbox certify --adapter ./agentcert.sandbox.mjs
   agentcert sandbox push --adapter ./agentcert.sandbox.mjs

package/dist/corpus-governance.js

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+const SECRET_PATTERNS = [
+    /\bsk-(?:proj-|live_|test_)?[A-Za-z0-9_-]{16,}\b/g,
+    /\brk_(?:live|test)_[A-Za-z0-9]{12,}\b/g,
+    /\bnpm_[A-Za-z0-9]{16,}\b/g,
+    /\bac_(?:live|test)_[A-Za-z0-9_-]{12,}\b/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi,
+];
+const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+export function governCorpusRecords(records, input) {
+    if (input.consent === "denied")
+        throw new Error("Corpus consent is denied; no record was retained.");
+    if (!input.consentSource.trim())
+        throw new Error("Corpus consent source is required.");
+    const recordedAt = input.recordedAt ?? new Date().toISOString();
+    return records.map((record) => {
+        const [redacted, replacements] = redactValue(structuredClone(record), input.consent === "anonymous");
+        const governed = redacted;
+        if (input.consent === "anonymous") {
+            const identity = pseudonym(record.subject);
+            governed.subject = `anonymous-${identity}`;
+            governed.agentName = `anonymous-agent-${identity}`;
+            governed.sourcePath = basename(record.sourcePath.replaceAll("\\", "/"));
+            governed.artifacts = Object.fromEntries(Object.entries(governed.artifacts).map(([key, value]) => [key, basename(value.replaceAll("\\", "/"))]));
+        }
+        governed.governance = {
+            schemaVersion: "agentcert.corpus_governance.v0.1",
+            consent: input.consent,
+            consentSource: redactText(input.consentSource, input.consent === "anonymous")[0],
+            consentRecordedAt: recordedAt,
+            provenance: {
+                sourcePath: input.consent === "anonymous" ? basename(record.sourcePath.replaceAll("\\", "/")) : record.sourcePath,
+                sourceRecordSha256: createHash("sha256").update(JSON.stringify(record)).digest("hex"),
+                collectedAt: record.ingestedAt,
+            },
+            redaction: { policyVersion: "agentcert.redaction.v0.1", replacements, secretScanPassed: !containsSecret(JSON.stringify(governed)) },
+        };
+        if (!governed.governance.redaction.secretScanPassed)
+            throw new Error(`Corpus record ${record.id} still contains a recognized secret after redaction.`);
+        return governed;
+    });
+}
+export function exportGovernedCorpus(records, allowed = ["public", "anonymous"]) {
+    const allow = new Set(allowed);
+    return records
+        .filter((record) => record.governance && allow.has(record.governance.consent))
+        .map((record) => {
+        const [redacted, replacements] = redactValue(structuredClone(record), record.governance.consent === "anonymous");
+        const exported = redacted;
+        if (record.governance.consent === "anonymous") {
+            const identity = record.subject.startsWith("anonymous-") ? record.subject.slice("anonymous-".length) : pseudonym(record.subject);
+            exported.subject = `anonymous-${identity}`;
+            exported.agentName = `anonymous-agent-${identity}`;
+            exported.sourcePath = basename(record.sourcePath.replaceAll("\\", "/"));
+            exported.artifacts = Object.fromEntries(Object.entries(exported.artifacts).map(([key, value]) => [key, basename(value.replaceAll("\\", "/"))]));
+        }
+        exported.governance = {
+            ...record.governance,
+            redaction: {
+                ...record.governance.redaction,
+                replacements: record.governance.redaction.replacements + replacements,
+                secretScanPassed: !containsSecret(JSON.stringify(exported)),
+            },
+        };
+        if (!exported.governance.redaction.secretScanPassed)
+            throw new Error(`Corpus record ${record.id} failed the export secret scan.`);
+        return exported;
+    });
+}
+export function deleteCorpusRecords(records, ids, reason, deletedAt = new Date().toISOString()) {
+    if (!reason.trim())
+        throw new Error("Corpus deletion requires a reason.");
+    const requested = new Set(ids);
+    const deleted = records.filter((record) => requested.has(record.id));
+    return {
+        retained: records.filter((record) => !requested.has(record.id)),
+        tombstones: deleted.map((record) => ({
+            schemaVersion: "agentcert.corpus_deletion.v0.1",
+            recordIdSha256: createHash("sha256").update(record.id).digest("hex"),
+            reason: redactText(reason, true)[0],
+            deletedAt,
+        })),
+    };
+}
+export function parseCorpusConsent(value) {
+    const consent = value ?? "private";
+    if (consent === "private" || consent === "anonymous" || consent === "public" || consent === "denied")
+        return consent;
+    throw new Error(`Unsupported corpus consent "${consent}". Use private, anonymous, public, or denied.`);
+}
+function redactValue(value, anonymous) {
+    if (typeof value === "string")
+        return redactText(value, anonymous);
+    if (Array.isArray(value)) {
+        let replacements = 0;
+        const output = value.map((item) => { const [next, count] = redactValue(item, anonymous); replacements += count; return next; });
+        return [output, replacements];
+    }
+    if (value && typeof value === "object") {
+        let replacements = 0;
+        const output = {};
+        for (const [key, item] of Object.entries(value)) {
+            const [next, count] = redactValue(item, anonymous);
+            output[key] = next;
+            replacements += count;
+        }
+        return [output, replacements];
+    }
+    return [value, 0];
+}
+function redactText(value, anonymous) {
+    let output = value;
+    let replacements = 0;
+    for (const pattern of SECRET_PATTERNS)
+        output = output.replace(pattern, () => { replacements += 1; return "[REDACTED_SECRET]"; });
+    if (anonymous)
+        output = output.replace(EMAIL_PATTERN, () => { replacements += 1; return "[REDACTED_EMAIL]"; });
+    return [output, replacements];
+}
+function containsSecret(value) {
+    return SECRET_PATTERNS.some((pattern) => { pattern.lastIndex = 0; return pattern.test(value); });
+}
+function pseudonym(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}

package/dist/corpus-store.js

@@ -62,11 +62,10 @@ async function createSqliteCorpusStore(path, tableNameInput) {
         kind: "sqlite",
         description: `SQLite corpus at ${outPath}`,
         append: async (records, options) => {
-            if (options?.replace) {
-                db.exec(`DELETE FROM ${table}`);
-            }
             db.exec("BEGIN");
             try {
+                if (options?.replace)
+                    db.exec(`DELETE FROM ${table}`);
                 for (const record of records) {
                     insert.run(...recordSqlValues(record, "sqlite"), JSON.stringify(record));
                 }
@@ -97,11 +96,10 @@ async function createPostgresCorpusStore(databaseUrl, tableNameInput) {
         kind: "postgres",
         description: `Postgres corpus table ${tableName}`,
         append: async (records, options) => {
-            if (options?.replace) {
-                await client.query(`DELETE FROM ${table}`);
-            }
             await client.query("BEGIN");
             try {
+                if (options?.replace)
+                    await client.query(`DELETE FROM ${table}`);
                 for (const record of records) {
                     await client.query(insertSql(table, "$"), [...recordSqlValues(record, "postgres"), JSON.stringify(record)]);
                 }

package/dist/credentials.js

@@ -2,7 +2,7 @@ import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
-export const DEFAULT_AGENTCERT_SERVER = "https://agentcert-control-plane.onrender.com";
+export const DEFAULT_AGENTCERT_SERVER = "https://agentcert.app";
 export async function saveConnection(name, input, options = {}) {
     const connectionName = validateConnectionName(name);
     const connection = validateConnection(input);

package/dist/runner.js

@@ -7,6 +7,7 @@ import { buildEvidenceBundle } from "./bundle.js";
 import { recordsFromAgentCertResult, renderCorpusSummary, summarizeCorpus, writeReviewedFailureDataset, } from "./corpus.js";
 import { openCorpusStore, parseCorpusStoreKind } from "./corpus-store.js";
 import { applyFailureReviews, readFailureReviews } from "./failure-review.js";
+import { governCorpusRecords } from "./corpus-governance.js";
 import { buildMonitorSnapshot, writeMonitorSnapshot } from "./monitor.js";
 import { normalizeMcpBenchResult, normalizeOnegentAuditPacket, normalizeTripwireResult } from "./normalizers.js";
 import { renderHtmlReport, renderMarkdownReport } from "./report.js";
@@ -168,7 +169,7 @@ export async function runAgentCertProfile(profileInput, options = {}) {
     const bundle = buildEvidenceBundle(loaded.map((artifact) => artifact.result), profile.subject.name, profile.subject.type);
     const reviewsPath = profile.run?.corpus?.reviewsPath;
     const reviews = await readFailureReviews(reviewsPath ? resolve(cwd, reviewsPath) : undefined);
-    const records = applyFailureReviews(loaded.flatMap(({ result, path, raw }) => recordsFromAgentCertResult(result, path, profile.subject.name, raw)), reviews);
+    const records = governCorpusRecords(applyFailureReviews(loaded.flatMap(({ result, path, raw }) => recordsFromAgentCertResult(result, path, profile.subject.name, raw)), reviews), { consent: "private", consentSource: "agentcert-runner-default" });
     const outputs = { monitor: [], reviewedDataset: [] };
     const reportEnabled = profile.run?.report?.enabled ?? true;
     const reportDir = profile.run?.report?.outDir ?? profile.outputDir;

package/dist/schema-validator.js

@@ -11,10 +11,11 @@ export function parseSchemaId(input) {
         value === "monitor-snapshot" ||
         value === "robustness-lab" ||
         value === "release-gate" ||
+        value === "assurance-report" ||
         value === "evidence-signature") {
         return value;
     }
-    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.`);
+    throw new Error(`Unsupported schema "${value}". Use evidence-bundle, result, corpus-record, failure-review, classifier-eval, monitor-snapshot, robustness-lab, release-gate, assurance-report, or evidence-signature.`);
 }
 export function validateAgentCertSchema(schema, input) {
     const errors = [];
@@ -42,6 +43,8 @@ export function validateAgentCertSchema(schema, input) {
             validateMonitorSnapshot(value, errors);
         if (schema === "robustness-lab")
             validateRobustnessLab(value, errors);
+        if (schema === "assurance-report")
+            validateAssuranceReport(value, errors);
     }
     return { schema, valid: errors.length === 0, errors };
 }
@@ -160,6 +163,32 @@ function validateCorpusRecord(value, errors) {
     requiredString(value, "runId", errors);
     requiredBoolean(value, "passed", errors);
     requiredArray(value, "failurePatterns", errors);
+    if (value.governance !== undefined) {
+        const governance = recordValue(value.governance);
+        if (!governance)
+            errors.push("governance must be an object.");
+        else {
+            requiredConst(governance, "schemaVersion", "agentcert.corpus_governance.v0.1", errors);
+            requiredEnum(governance, "consent", ["private", "anonymous", "public", "denied"], errors);
+            requiredString(governance, "consentSource", errors);
+            requiredString(governance, "consentRecordedAt", errors);
+            requiredObject(governance, "provenance", errors);
+            requiredObject(governance, "redaction", errors);
+        }
+    }
+}
+function validateAssuranceReport(value, errors) {
+    requiredConst(value, "schemaVersion", "agentcert.assurance_report.v0.1", errors);
+    for (const key of ["assuranceCaseId", "projectId", "policyPackVersion", "evaluationPlanSha256", "reviewerId", "issuedAt", "expiresAt", "statement"])
+        requiredString(value, key, errors);
+    requiredObject(value, "subject", errors);
+    requiredArray(value, "evidence", errors);
+    requiredConst(value, "decision", "issued", errors);
+    requiredArray(value, "limitations", errors);
+    if (!/^[0-9a-f]{64}$/.test(String(value.evaluationPlanSha256 ?? "")))
+        errors.push("evaluationPlanSha256 must be a lowercase SHA-256 digest.");
+    validateTimestamp(value.issuedAt, "issuedAt", errors);
+    validateTimestamp(value.expiresAt, "expiresAt", errors);
 }
 function validateFailureReview(value, errors) {
     requiredConst(value, "schemaVersion", "1", errors);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "agentcert",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Assurance release gates, runtime evidence, and regression CI for AI agents.",
   "type": "module",
   "license": "Apache-2.0",
-  "homepage": "https://agentcert-control-plane.onrender.com/demo",
+  "homepage": "https://agentcert.app/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Kakarottoooo/agentcert.git",