agentcert 0.2.6 → 0.3.0

package/README.md

@@ -57,6 +57,31 @@ or mismatched artifacts remain observable as `partial` or `rejected`.
 Project API keys can create runs, record events, and upload evidence, but
 cannot approve their own runtime actions.
 
+## Sandbox onboarding
+
+Create and certify a synthetic SandboxSystem adapter with the same public CLI:
+
+```bash
+npx agentcert sandbox init
+npx agentcert sandbox certify --adapter ./agentcert.sandbox.mjs
+```
+
+The first command writes one dependency-free JavaScript file. The second runs
+the bundled deterministic adapter contract and writes
+`.agentcert/sandbox/sandbox-adapter-conformance.json`. No `@agentcert` scoped
+package is required.
+
+After `agentcert connect`, certify and upload in one command:
+
+```bash
+npx agentcert sandbox push --adapter ./agentcert.sandbox.mjs
+```
+
+Passing and failing reports are both retained for review, while failed
+certifications return a non-zero exit status. The generated template is
+synthetic and network-denied; it must not contain production credentials or
+connect to live systems.
+
 Review/export helpers:
 
 ```bash

package/dist/cli.js

@@ -9,6 +9,7 @@ import { collectCompanionArtifacts, MAX_REPORTED_COMPANION_ARTIFACT_SKIPS } from
 import { recordsFromAgentCertResult, evaluateFailureClassifier, renderCorpusSummary, summarizeCorpus, writeReviewedFailureDataset, } from "./corpus.js";
 import { openCorpusStore, parseCorpusStoreKind } from "./corpus-store.js";
 import { pushEvidenceToControlPlane, verifyControlPlaneConnection } from "./control-plane.js";
+import { runEvidenceConformance } from "./conformance.js";
 import { DEFAULT_AGENTCERT_SERVER, resolveConnection, saveConnection } from "./credentials.js";
 import { applyFailureReviews, appendFailureReview, createFailureReview, findFailurePattern, parseFailureReviewStatus, parseFailureType, parseReviewConfidence, readFailureReviews, } from "./failure-review.js";
 import { buildMonitorSnapshot, writeMonitorSnapshot } from "./monitor.js";
@@ -21,6 +22,7 @@ import { parseSchemaId, validateAgentCertSchema } from "./schema-validator.js";
 import { applyRunOverrides, loadRunProfile, profileFromArtifactFlags, renderRunSummary, runAgentCertProfile, } from "./runner.js";
 import { buildRobustnessLabSnapshot, readRobustnessLabConfig, renderRobustnessLabSummary, writeRobustnessLabSnapshot } from "./lab.js";
 import { renderCommandHelp } from "./command-help.js";
+import { runSandboxCommand } from "./sandbox.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
 const command = process.argv[2] ?? "help";
@@ -119,6 +121,10 @@ Saved connections are reused by agentcert push and agentcert run --push.
         process.stdout.write(`Credentials: ${path}\n`);
     }
 }
+else if (command === "sandbox") {
+    const result = await runSandboxCommand(process.argv.slice(3));
+    process.exitCode = result.exitCode;
+}
 else if (command === "report") {
     const config = await loadConfig(readFlag("--config"));
     const subject = readFlag("--subject") ?? config?.subject.name ?? "agentcert-subject";
@@ -515,10 +521,39 @@ else if (command === "validate") {
         }
     }
 }
+else if (command === "conformance") {
+    const file = readFlag("--file") ?? readFirstPositionalAfterCommand();
+    if (!file)
+        throw new Error("Missing evidence file. Usage: agentcert conformance <file> --artifact-root <directory>.");
+    const artifactRoot = resolve(readFlag("--artifact-root") ?? dirname(resolve(file)));
+    const report = await runEvidenceConformance(await readJson(file), {
+        evidenceFile: file,
+        artifactRoot,
+        implementation: readFlag("--implementation"),
+    });
+    const output = `${JSON.stringify(report, null, 2)}\n`;
+    const outPath = readFlag("--out");
+    if (outPath) {
+        await mkdir(dirname(resolve(outPath)), { recursive: true });
+        await writeFile(outPath, output);
+        process.stdout.write(`Wrote conformance report: ${resolve(outPath)}\n`);
+    }
+    process.stdout.write(`${report.valid ? "Conformant" : "Non-conformant"} evidence implementation: ${report.implementation}\n`);
+    for (const item of report.checks) {
+        process.stdout.write(`- ${item.status === "passed" ? "PASS" : "FAIL"} ${item.id}: ${item.message}\n`);
+        for (const error of item.errors)
+            process.stdout.write(`  - ${error}\n`);
+    }
+    if (!report.valid)
+        process.exitCode = 1;
+}
 else {
     process.stdout.write(`Usage:
   agentcert init --subject my-browser-agent
   agentcert connect --server https://agentcert-control-plane.onrender.com --project <project-id>
+  agentcert sandbox init
+  agentcert sandbox certify --adapter ./agentcert.sandbox.mjs
+  agentcert sandbox push --adapter ./agentcert.sandbox.mjs
   agentcert init --out agentcert.config.json --tripwire-config tripwire.yml --force
   agentcert init --subject my-browser-agent --github-action
   agentcert report --mcpbench .mcpbench/latest/results.json --tripwire .tripwire/latest/tripwire-result.json --onegent .onegent/procurement/audit-packet.json --out .agentcert/latest --subject my-agent
@@ -543,6 +578,7 @@ else {
   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
   agentcert validate .agentcert/latest/agentcert-evidence.json --check-artifacts
+  agentcert conformance .agentcert/latest/agentcert-evidence.json --artifact-root . --implementation my-agent
   agentcert schema validate --schema evidence-bundle --file .agentcert/latest/agentcert-evidence.json
 `);
 }
@@ -911,12 +947,13 @@ jobs:
     # permissions:
     #   contents: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v6
         with:
           node-version: "20"
 
-      - uses: Kakarottoooo/agentcert/actions/tripwire@v0
+      - id: agentcert
+        uses: Kakarottoooo/agentcert/actions/tripwire@v0
         with:
           config: tripwire.yml
           out: .tripwire/latest

package/dist/command-help.js

@@ -1,4 +1,12 @@
 export function renderCommandHelp(command) {
+    if (command === "sandbox")
+        return undefined;
+    if (command === "conformance")
+        return `Usage:
+  agentcert conformance <evidence.json> --artifact-root <directory> [--implementation <name>] [--out <report.json>]
+
+Checks schema identity, v0.1 compatibility, artifact manifest structure, and exact artifact hashes and sizes.
+`;
     if (command !== "push")
         return undefined;
     return `Usage:

package/dist/conformance.js

@@ -0,0 +1,115 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { normalizeManifestPath } from "./artifact-manifest.js";
+import { validateAgentCertSchema } from "./schema-validator.js";
+const SUPPORTED_TOP_LEVEL_FIELDS = new Set([
+    "schemaName", "schemaVersion", "schemaSemver", "kind", "runId", "generatedAt", "subject", "verdict", "summary",
+    "results", "evidence", "artifacts", "artifactManifest", "standards",
+]);
+export async function runEvidenceConformance(input, options) {
+    const checks = [];
+    const schema = validateAgentCertSchema("evidence-bundle", input);
+    checks.push(check("schema", "Evidence bundle satisfies the AgentCert v0.1 semantic contract.", schema.errors));
+    const bundle = object(input);
+    const compatibilityErrors = bundle
+        ? Object.keys(bundle).filter((key) => !SUPPORTED_TOP_LEVEL_FIELDS.has(key)).map((key) => `Unsupported top-level field: ${key}.`)
+        : ["Evidence bundle must be an object."];
+    checks.push(check("compatibility", "Evidence bundle uses only v0.1-compatible top-level fields.", compatibilityErrors));
+    const manifestErrors = [];
+    const entries = parseManifest(bundle?.artifactManifest, manifestErrors);
+    checks.push(check("manifest", "Artifact manifest declares unique normalized paths, SHA-256, byte size, and kind.", manifestErrors));
+    const byteErrors = [];
+    if (manifestErrors.length === 0) {
+        const root = resolve(options.artifactRoot);
+        for (const entry of entries) {
+            const path = resolve(root, entry.path);
+            if (path !== root && !path.startsWith(`${root}\\`) && !path.startsWith(`${root}/`)) {
+                byteErrors.push(`${entry.path}: resolved path escapes artifact root.`);
+                continue;
+            }
+            try {
+                const bytes = await readFile(path);
+                const digest = createHash("sha256").update(bytes).digest("hex");
+                if (bytes.byteLength !== entry.sizeBytes)
+                    byteErrors.push(`${entry.path}: expected ${entry.sizeBytes} bytes, observed ${bytes.byteLength}.`);
+                if (digest !== entry.sha256)
+                    byteErrors.push(`${entry.path}: SHA-256 does not match the declared digest.`);
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error ? String(error.code) : "read_failed";
+                byteErrors.push(`${entry.path}: artifact could not be read (${code}).`);
+            }
+        }
+    }
+    else {
+        byteErrors.push("Artifact bytes were not checked because the manifest is invalid.");
+    }
+    checks.push(check("artifact-bytes", "Every declared artifact matches its exact runtime bytes.", byteErrors));
+    const passed = checks.filter((item) => item.status === "passed").length;
+    const failed = checks.length - passed;
+    return {
+        schemaVersion: "agentcert.conformance.v0.1",
+        kind: "agentcert.evidence_conformance_report",
+        implementation: options.implementation?.trim() || "third-party",
+        evidenceFile: resolve(options.evidenceFile),
+        artifactRoot: resolve(options.artifactRoot),
+        generatedAt: (options.now ?? new Date()).toISOString(),
+        valid: failed === 0,
+        summary: { passed, failed },
+        checks,
+    };
+}
+function parseManifest(input, errors) {
+    const manifest = object(input);
+    if (!manifest) {
+        errors.push("artifactManifest is required for conformance.");
+        return [];
+    }
+    if (manifest.schemaVersion !== "agentcert.artifact_manifest.v0.1")
+        errors.push("artifactManifest.schemaVersion must be agentcert.artifact_manifest.v0.1.");
+    if (!Array.isArray(manifest.entries)) {
+        errors.push("artifactManifest.entries must be an array.");
+        return [];
+    }
+    if (manifest.entries.length > 500)
+        errors.push("artifactManifest.entries cannot exceed 500 entries.");
+    const paths = new Set();
+    const entries = [];
+    manifest.entries.forEach((inputEntry, index) => {
+        const entry = object(inputEntry);
+        if (!entry) {
+            errors.push(`artifactManifest.entries[${index}] must be an object.`);
+            return;
+        }
+        let path;
+        try {
+            path = typeof entry.path === "string" ? normalizeManifestPath(entry.path) : undefined;
+        }
+        catch (error) {
+            errors.push(`artifactManifest.entries[${index}].path: ${error.message}`);
+        }
+        if (!path)
+            errors.push(`artifactManifest.entries[${index}].path must be a normalized relative path.`);
+        else if (paths.has(path))
+            errors.push(`artifactManifest contains duplicate path ${path}.`);
+        else
+            paths.add(path);
+        if (typeof entry.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256))
+            errors.push(`artifactManifest.entries[${index}].sha256 must be 64 lowercase hex characters.`);
+        if (!Number.isInteger(entry.sizeBytes) || entry.sizeBytes < 0)
+            errors.push(`artifactManifest.entries[${index}].sizeBytes must be a non-negative integer.`);
+        if (typeof entry.kind !== "string" || !/^[a-z][a-z0-9_-]{0,63}$/.test(entry.kind))
+            errors.push(`artifactManifest.entries[${index}].kind must be a stable lowercase identifier.`);
+        if (path && typeof entry.sha256 === "string" && Number.isInteger(entry.sizeBytes) && typeof entry.kind === "string") {
+            entries.push({ path, sha256: entry.sha256, sizeBytes: entry.sizeBytes, kind: entry.kind });
+        }
+    });
+    return entries;
+}
+function check(id, message, errors) {
+    return { id, status: errors.length === 0 ? "passed" : "failed", message, errors };
+}
+function object(input) {
+    return input && typeof input === "object" && !Array.isArray(input) ? input : undefined;
+}

package/dist/index.js

@@ -2,6 +2,8 @@ export * from "./bundle.js";
 export * from "./corpus.js";
 export * from "./corpus-store.js";
 export * from "./control-plane.js";
+export * from "./sandbox.js";
+export * from "./conformance.js";
 export * from "./credentials.js";
 export * from "./failure-review.js";
 export * from "./evidence-signing.js";

package/dist/sandbox.js

@@ -0,0 +1,258 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolveConnection } from "./credentials.js";
+const DEFAULT_ADAPTER_PATH = "agentcert.sandbox.mjs";
+const DEFAULT_REPORT_PATH = ".agentcert/sandbox/sandbox-adapter-conformance.json";
+export async function runSandboxCommand(args) {
+    const action = args[0] ?? "help";
+    if (action === "help" || args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(renderSandboxHelp(action === "help" ? undefined : action));
+        return { exitCode: 0 };
+    }
+    if (action === "init")
+        return initializeSandboxAdapter(args.slice(1));
+    if (action === "certify")
+        return certifySandboxAdapter(args.slice(1));
+    if (action === "push")
+        return pushSandboxCertification(args.slice(1));
+    throw new Error(`Unknown sandbox command ${JSON.stringify(action)}. Run \`npx agentcert sandbox --help\`.`);
+}
+export async function initializeSandboxAdapter(args) {
+    const requestedPath = flag(args, "--adapter") ?? flag(args, "--out") ?? DEFAULT_ADAPTER_PATH;
+    const outPath = resolve(requestedPath);
+    await writeStarterFile(outPath, sandboxAdapterTemplate(), args.includes("--force"));
+    process.stdout.write(`Wrote ${outPath}\n\nNext:\n`);
+    process.stdout.write(`  npx agentcert sandbox certify --adapter ${JSON.stringify(requestedPath)}\n`);
+    process.stdout.write("\nReplace the in-memory handlers with your sandbox implementation. Keep production credentials and live systems out of this adapter.\n");
+    return { exitCode: 0 };
+}
+export async function certifySandboxAdapter(args, runtimeOverride) {
+    const runtime = runtimeOverride ?? await loadSandboxRuntime();
+    const adapterPath = resolve(flag(args, "--adapter") ?? DEFAULT_ADAPTER_PATH);
+    const reportPath = resolve(flag(args, "--out") ?? DEFAULT_REPORT_PATH);
+    const system = await loadSandboxAdapter(adapterPath);
+    const report = await runtime.runSandboxAdapterConformanceSuite({
+        system,
+        implementation: flag(args, "--implementation"),
+        targetSystem: flag(args, "--target-system"),
+    });
+    await runtime.writeSandboxAdapterConformanceReport(report, reportPath);
+    renderCertificationResult(report, reportPath);
+    return { exitCode: report.verdict.passed ? 0 : 1, reportPath, report };
+}
+export async function pushSandboxCertification(args, runtimeOverride) {
+    const runtime = runtimeOverride ?? await loadSandboxRuntime();
+    const certified = await certifySandboxAdapter(args, runtime);
+    if (!certified.report || !certified.reportPath)
+        throw new Error("Sandbox certification did not produce a report.");
+    const connection = await resolveConnection({
+        name: flag(args, "--connection"),
+        server: flag(args, "--server"),
+        projectId: flag(args, "--project"),
+        apiKey: flag(args, "--api-key"),
+    });
+    const uploaded = await runtime.uploadSandboxCertificationReport(certified.report, {
+        baseUrl: connection.server,
+        projectId: connection.projectId,
+        apiKey: connection.apiKey,
+        externalId: flag(args, "--external-id"),
+    });
+    process.stdout.write(`Hosted sandbox run: ${String(uploaded.run.id ?? "created")}\n`);
+    process.stdout.write(`Hosted evidence: ${String(uploaded.evidence.id ?? "created")}\n`);
+    return certified;
+}
+export async function loadSandboxAdapter(adapterPath) {
+    let module;
+    try {
+        module = await import(pathToFileURL(adapterPath).href);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not load sandbox adapter ${adapterPath}: ${message}`);
+    }
+    const candidate = module.sandboxSystem ?? module.default ?? module.system;
+    if (!isSandboxSystem(candidate)) {
+        throw new Error(`Sandbox adapter ${adapterPath} must export \`sandboxSystem\`, \`system\`, or a default SandboxSystem object.`);
+    }
+    return candidate;
+}
+export function renderSandboxHelp(action) {
+    if (action === "init")
+        return `Usage:
+  agentcert sandbox init [--adapter agentcert.sandbox.mjs] [--force]
+
+Writes one dependency-free synthetic SandboxSystem adapter template.
+`;
+    if (action === "certify")
+        return `Usage:
+  agentcert sandbox certify --adapter ./my-sandbox-adapter.js [--out .agentcert/sandbox/report.json]
+
+Runs the deterministic sandbox adapter conformance suite locally.
+`;
+    if (action === "push")
+        return `Usage:
+  agentcert sandbox push --adapter ./my-sandbox-adapter.js
+
+Runs certification, writes the local report, and uploads it through the saved AgentCert connection.
+Use \`agentcert connect\` first, or pass --server, --project, and --api-key.
+`;
+    return `Usage:
+  agentcert sandbox init [--adapter agentcert.sandbox.mjs]
+  agentcert sandbox certify --adapter ./my-sandbox-adapter.js
+  agentcert sandbox push --adapter ./my-sandbox-adapter.js
+
+Commands:
+  init      Write one dependency-free adapter template
+  certify   Run deterministic local conformance checks
+  push      Certify and upload the report to AgentCert Hosted
+
+Common options:
+  --adapter <path>        Adapter module (default: agentcert.sandbox.mjs)
+  --out <path>            Local report path
+  --implementation <id>  Stable adapter implementation name
+  --target-system <name> Target system exercised by the suite
+`;
+}
+async function loadSandboxRuntime() {
+    const adapterKitUrl = new URL("./vendor/onegent-runtime/sandbox-adapter-kit.js", import.meta.url);
+    const hostedUrl = new URL("./vendor/onegent-runtime/sandbox-hosted.js", import.meta.url);
+    try {
+        const [adapterKit, hosted] = await Promise.all([import(adapterKitUrl.href), import(hostedUrl.href)]);
+        return { ...adapterKit, ...hosted };
+    }
+    catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : undefined;
+        if (code === "ERR_MODULE_NOT_FOUND") {
+            throw new Error("AgentCert sandbox runtime is missing. Reinstall the agentcert package and retry.");
+        }
+        throw error;
+    }
+}
+function isSandboxSystem(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const system = value;
+    const safety = system.safety;
+    return typeof system.name === "string"
+        && safety?.mode === "sandbox"
+        && safety.networkAccess === false
+        && safety.syntheticDataOnly === true
+        && Array.isArray(safety.allowedTargetSystems)
+        && ["createTenant", "deleteTenant", "resetTenant", "seedTenant", "hasTenant", "snapshotTenant", "adapterForTenant"]
+            .every((method) => typeof system[method] === "function");
+}
+function flag(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+async function writeStarterFile(path, content, force) {
+    await mkdir(dirname(path), { recursive: true });
+    try {
+        await writeFile(path, content, { flag: force ? "w" : "wx" });
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
+            throw new Error(`${path} already exists. Re-run with --force to overwrite it.`);
+        }
+        throw error;
+    }
+}
+function renderCertificationResult(report, reportPath) {
+    process.stdout.write(`${report.verdict.passed ? "PASS" : "FAIL"} ${report.verdict.score}/100 sandbox adapter conformance\n`);
+    for (const check of report.checks) {
+        process.stdout.write(`- ${check.status === "passed" ? "PASS" : "FAIL"} ${check.id}: ${check.message}\n`);
+    }
+    process.stdout.write(`Report: ${reportPath}\n`);
+}
+function sandboxAdapterTemplate() {
+    return `// Synthetic local state only. Do not import production credentials or call live systems here.
+const tenants = new Map();
+
+export const sandboxSystem = {
+  name: "my-sandbox-adapter",
+  safety: {
+    mode: "sandbox",
+    networkAccess: false,
+    syntheticDataOnly: true,
+    allowedTargetSystems: ["MySandboxSystem"],
+  },
+  createTenant(input) {
+    if (input.synthetic !== true) throw new Error("Synthetic tenants only.");
+    if (tenants.has(input.id)) throw new Error(\`Tenant \${input.id} already exists.\`);
+    const seed = syntheticSeed(input.seed ?? {});
+    tenants.set(input.id, { seed, state: structuredClone(seed) });
+  },
+  deleteTenant(tenantId) {
+    tenants.delete(tenantId);
+  },
+  resetTenant(tenantId) {
+    const tenant = requiredTenant(tenantId);
+    tenant.state = structuredClone(tenant.seed);
+  },
+  seedTenant(tenantId, seed) {
+    const tenant = requiredTenant(tenantId);
+    tenant.seed = syntheticSeed(seed);
+    tenant.state = structuredClone(seed);
+  },
+  hasTenant(tenantId) {
+    return tenants.has(tenantId);
+  },
+  snapshotTenant(tenantId) {
+    return structuredClone(requiredTenant(tenantId).state);
+  },
+  adapterForTenant(tenantId) {
+    requiredTenant(tenantId);
+    return {
+      name: \`my-sandbox-adapter:\${tenantId}\`,
+      safety: { mode: "sandbox", networkAccess: false, allowedTargetSystems: ["MySandboxSystem"] },
+      execute(action) {
+        const tenant = requiredTenant(tenantId);
+        const previousState = structuredClone(tenant.state[action.businessObjectId] ?? action.beforeState);
+        const observedState = structuredClone(action.proposedAfterState);
+        tenant.state[action.businessObjectId] = observedState;
+        return { method: "SYNTHETIC_SANDBOX", targetSystem: action.targetSystem, previousState, observedState };
+      },
+      rollback(action, execution) {
+        const restored = structuredClone(execution.previousState ?? action.beforeState);
+        requiredTenant(tenantId).state[action.businessObjectId] = restored;
+        return { success: true, observedState: restored };
+      },
+    };
+  },
+};
+
+export default sandboxSystem;
+
+function requiredTenant(tenantId) {
+  const tenant = tenants.get(tenantId);
+  if (!tenant) throw new Error(\`Tenant \${tenantId} does not exist.\`);
+  return tenant;
+}
+
+function syntheticSeed(value) {
+  assertSynthetic(value, "seed", new Set());
+  return structuredClone(value);
+}
+
+function assertSynthetic(value, path, seen) {
+  if (value === null || ["boolean", "number"].includes(typeof value)) return;
+  if (typeof value === "string") {
+    if (/^(?:sk-(?:proj-)?|npm_|gh[pousr]_)[A-Za-z0-9_-]{16,}$/.test(value)) {
+      throw new Error(\`Credential-like value is not allowed at \${path}.\`);
+    }
+    return;
+  }
+  if (typeof value !== "object") throw new Error(\`Synthetic data must be JSON-compatible at \${path}.\`);
+  if (seen.has(value)) throw new Error(\`Synthetic data cannot contain cycles at \${path}.\`);
+  seen.add(value);
+  for (const [key, item] of Object.entries(value)) {
+    if (/(?:password|passwd|secret|token|api[_-]?key|credential|authorization|cookie)/i.test(key)) {
+      throw new Error(\`Credential-like field \${path}.\${key} is not allowed.\`);
+    }
+    assertSynthetic(item, \`\${path}.\${key}\`, seen);
+  }
+  seen.delete(value);
+}
+`;
+}

package/dist/schema-validator.js

@@ -59,10 +59,33 @@ function validateEvidenceBundle(value, errors) {
     requiredArray(value, "evidence", errors);
     requiredObject(value, "artifacts", errors);
     requiredArray(value, "standards", errors);
+    const subject = recordValue(value.subject);
+    if (subject) {
+        requiredStringAt(subject, "name", "subject.name", errors);
+        requiredEnumAt(subject, "type", ["agent", "mcp-server", "tool", "application", "unknown"], "subject.type", errors);
+    }
+    const verdict = recordValue(value.verdict);
+    if (verdict) {
+        requiredBooleanAt(verdict, "passed", "verdict.passed", errors);
+        requiredNumberRange(verdict, "score", "verdict.score", 0, 100, errors);
+        requiredStringAt(verdict, "level", "verdict.level", errors);
+    }
+    const summary = recordValue(value.summary);
+    if (summary) {
+        stringArray(summary.products, "summary.products", errors);
+        requiredNonNegativeInteger(summary, "criticalEvidence", "summary.criticalEvidence", errors);
+        requiredNonNegativeInteger(summary, "highEvidence", "summary.highEvidence", errors);
+        requiredNonNegativeInteger(summary, "totalEvidence", "summary.totalEvidence", errors);
+    }
+    validateTimestamp(value.generatedAt, "generatedAt", errors);
+    validateArtifactMap(value.artifacts, "artifacts", errors);
+    validateResultArray(value.results, "results", errors);
+    validateEvidenceArray(value.evidence, "evidence", errors);
+    validateStandards(value.standards, errors);
 }
 function validateResult(value, errors) {
     requiredConst(value, "schemaVersion", "1", errors);
-    requiredEnum(value, "product", ["mcpbench", "tripwire-ci", "onegent-runtime", "agentcert-cli"], errors);
+    requiredString(value, "product", errors);
     requiredString(value, "runId", errors);
     requiredString(value, "timestamp", errors);
     requiredEnum(value, "phase", ["pre-release", "runtime"], errors);
@@ -70,6 +93,62 @@ function validateResult(value, errors) {
     requiredBoolean(value, "passed", errors);
     requiredObject(value, "artifacts", errors);
     requiredArray(value, "evidence", errors);
+    requiredNumberRange(value, "score", "score", 0, 100, errors);
+    validateTimestamp(value.timestamp, "timestamp", errors);
+    validateArtifactMap(value.artifacts, "artifacts", errors);
+    validateEvidenceArray(value.evidence, "evidence", errors);
+}
+function validateResultArray(input, path, errors) {
+    if (!Array.isArray(input))
+        return;
+    input.forEach((item, index) => {
+        const value = object(item, `${path}[${index}]`, errors);
+        if (!value)
+            return;
+        const nested = [];
+        validateResult(value, nested);
+        errors.push(...nested.map((error) => `${path}[${index}].${error}`));
+    });
+}
+function validateEvidenceArray(input, path, errors) {
+    if (!Array.isArray(input))
+        return;
+    input.forEach((item, index) => {
+        const value = object(item, `${path}[${index}]`, errors);
+        if (!value)
+            return;
+        requiredStringAt(value, "id", `${path}[${index}].id`, errors);
+        requiredStringAt(value, "kind", `${path}[${index}].kind`, errors);
+        requiredEnumAt(value, "severity", ["critical", "high", "medium", "low", "info"], `${path}[${index}].severity`, errors);
+        requiredStringAt(value, "message", `${path}[${index}].message`, errors);
+        for (const field of ["source", "artifactPath", "suggestedFix"]) {
+            if (value[field] !== undefined && typeof value[field] !== "string")
+                errors.push(`${path}[${index}].${field} must be a string.`);
+        }
+        if (value.metadata !== undefined && !recordValue(value.metadata))
+            errors.push(`${path}[${index}].metadata must be an object.`);
+    });
+}
+function validateArtifactMap(input, path, errors) {
+    const value = recordValue(input);
+    if (!value)
+        return;
+    for (const [key, item] of Object.entries(value))
+        if (typeof item !== "string")
+            errors.push(`${path}.${key} must be a string.`);
+}
+function validateStandards(input, errors) {
+    if (!Array.isArray(input))
+        return;
+    input.forEach((item, index) => {
+        const value = object(item, `standards[${index}]`, errors);
+        if (!value)
+            return;
+        requiredStringAt(value, "id", `standards[${index}].id`, errors);
+        requiredStringAt(value, "name", `standards[${index}].name`, errors);
+        requiredEnumAt(value, "status", ["mapped", "planned"], `standards[${index}].status`, errors);
+        requiredStringAt(value, "note", `standards[${index}].note`, errors);
+    });
 }
 function validateCorpusRecord(value, errors) {
     requiredConst(value, "schemaVersion", "1", errors);
@@ -161,3 +240,37 @@ function requiredEnum(input, key, values, errors) {
         errors.push(`${key} must be one of: ${values.join(", ")}.`);
     }
 }
+function recordValue(input) {
+    return input && typeof input === "object" && !Array.isArray(input) ? input : undefined;
+}
+function requiredStringAt(input, key, path, errors) {
+    if (typeof input[key] !== "string" || input[key] === "")
+        errors.push(`${path} must be a non-empty string.`);
+}
+function requiredBooleanAt(input, key, path, errors) {
+    if (typeof input[key] !== "boolean")
+        errors.push(`${path} must be a boolean.`);
+}
+function requiredEnumAt(input, key, values, path, errors) {
+    if (typeof input[key] !== "string" || !values.includes(input[key]))
+        errors.push(`${path} must be one of: ${values.join(", ")}.`);
+}
+function requiredNumberRange(input, key, path, minimum, maximum, errors) {
+    const value = input[key];
+    if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
+        errors.push(`${path} must be a finite number from ${minimum} to ${maximum}.`);
+    }
+}
+function requiredNonNegativeInteger(input, key, path, errors) {
+    const value = input[key];
+    if (!Number.isInteger(value) || value < 0)
+        errors.push(`${path} must be a non-negative integer.`);
+}
+function stringArray(input, path, errors) {
+    if (!Array.isArray(input) || input.some((item) => typeof item !== "string"))
+        errors.push(`${path} must be an array of strings.`);
+}
+function validateTimestamp(input, path, errors) {
+    if (typeof input === "string" && !Number.isFinite(Date.parse(input)))
+        errors.push(`${path} must be a valid date-time string.`);
+}

package/dist/vendor/onegent-runtime/mock-procurement.d.ts

@@ -0,0 +1,6 @@
+import type { ActionIntent, MockPurchaseOrder } from "./types.js";
+export declare const PROCUREMENT_DEMO_PO_ID = "PO-DEMO-4850";
+export declare function createProcurementDemoPurchaseOrder(): MockPurchaseOrder;
+export declare function getPurchaseOrder(id: string): MockPurchaseOrder | undefined;
+export declare function submitMockPurchaseOrder(action: ActionIntent): MockPurchaseOrder;
+//# sourceMappingURL=mock-procurement.d.ts.map

package/dist/vendor/onegent-runtime/mock-procurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-procurement.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/mock-procurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGlE,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAErD,wBAAgB,kCAAkC,IAAI,iBAAiB,CActE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAE1E;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,YAAY,GAAG,iBAAiB,CAc/E"}