witnora 0.9.2 → 0.10.0

package/README.md

@@ -52,6 +52,21 @@ runner:
 npx witnora@latest setup apply --plan witnora-setup-plan.json --repo .
 ```
 
+Customer-owned deployment boundaries can import the bounded credential broker
+and admission adapters from the canonical package:
+
+```ts
+import {
+  exchangeGitHubOidcPromotionGrant,
+  deployWithPromotionEnforcement,
+  createKubernetesAdmissionHandler,
+} from "witnora/deployment-enforcement";
+```
+
+The SDK rejects deployment before customer code runs unless the exact artifact,
+target, and adapter match a valid single-use credential. It does not retain raw
+OIDC or deployment bearer tokens.
+
 Add `--github-pr` only after reviewing the generated files. The runner accepts
 only the five Witnora templates and ignores commands embedded in a plan.
 Coding, workflow, and data integrations begin at observed-event strength; they
@@ -84,6 +99,28 @@ npx witnora connect --server https://witnora.com --project your-project-id
 npx witnora push --evidence .witnora/latest/agentcert-evidence.json
 ```
 
+### Automatic agent and environment context
+
+`run --push`, `push`, and the generated workflow/coding/data adapter register
+the observed agent automatically. Witnora derives the stable identity and
+version from the command subject, the nearest `package.json`, and the current
+CI commit. It records one canonical environment for every run:
+
+- local, development, and test execution becomes `sandbox`;
+- pull-request and preview execution becomes `staging`;
+- tagged releases and recognized production hosts become `production`.
+
+This context is run evidence, not a project form the customer must keep in
+sync. A later run with the same Agent ID updates the observed version without
+overwriting reviewed permissions. Explicit `WITNORA_AGENT_ID`,
+`WITNORA_AGENT_VERSION`, and `WITNORA_ENVIRONMENT` values take precedence when
+a repository needs a stable identity that differs from its package metadata.
+Unsupported environment values fail closed instead of being guessed.
+
+Useful one-run overrides are `--agent-id`, `--agent-name`, `--agent-version`,
+`--agent-framework`, and `--environment`. Raw prompts, credentials, and tool
+arguments are not needed for this registration.
+
 Bind a release, pull-request, or nightly run to an issued continuous assurance
 case by declaring the exact reviewed scope:
 

package/dist/bundle.js

@@ -75,8 +75,30 @@ function evidenceStrengthFor(results) {
         level: weakest.level,
         claims: [...new Set(values.flatMap((value) => value.claims))],
         limitations: [...new Set(values.flatMap((value) => value.limitations))],
+        ...(() => {
+            const vectors = values.flatMap((value) => value.trustVector ? [value.trustVector] : []);
+            return vectors.length === values.length && vectors.length ? { trustVector: weakestTrustVector(vectors) } : {};
+        })(),
     };
 }
+function weakestTrustVector(vectors) {
+    const capture = weakest(vectors.map((item) => item.capture), ["self_reported", "collector_recorded", "boundary_observed"]);
+    const mediation = weakest(vectors.map((item) => item.mediation), ["none", "advisory", "enforced"]);
+    const completeness = weakest(vectors.map((item) => item.completeness), ["unknown", "partial", "target_reconciled"]);
+    const attestation = weakest(vectors.map((item) => item.attestation), ["unsigned", "source_signed", "platform_signed", "externally_witnessed"]);
+    const review = weakest(vectors.map((item) => item.review), ["none", "internal", "independent_external"]);
+    const outcome = vectors.some((item) => item.outcome === "contradicted")
+        ? "contradicted"
+        : vectors.some((item) => item.outcome === "unverified") ? "unverified" : "verified";
+    return {
+        schemaVersion: "witnora.evidence_trust_vector.v0.1",
+        capture, mediation, outcome, completeness, attestation, review,
+        limitations: [...new Set(vectors.flatMap((item) => item.limitations))],
+    };
+}
+function weakest(values, order) {
+    return values.reduce((left, right) => order.indexOf(left) <= order.indexOf(right) ? left : right);
+}
 function levelForScore(score, passed) {
     if (!passed) {
         return "No assurance decision";

package/dist/cli.js

@@ -28,6 +28,7 @@ import { runBrowserAdapterCommand } from "./browser-adapter.js";
 import { parseAgentTemplate, starterAdapter, starterGitHubActionWorkflow, starterInstructions, starterProfile, starterTripwireConfig, } from "./onboarding-templates.js";
 import { renderTrySummary, writeTryEvidence } from "./try.js";
 import { applyGuidedSetup } from "./guided-setup.js";
+import { resolveRuntimeContext } from "./runtime-context.js";
 process.on("uncaughtException", reportFatalError);
 process.on("unhandledRejection", reportFatalError);
 const command = process.argv[2] ?? "help";
@@ -535,6 +536,8 @@ else if (command === "schema") {
   witnora schema validate --schema assurance-report --file assurance-report.json
   witnora schema validate --schema assurance-delivery --file assurance-delivery.json
   witnora schema validate --schema evidence-signature --file .witnora/latest/agentcert-evidence.json.sig.json
+  witnora schema validate --schema assurance-wallet --file assurance-wallet.json
+  witnora schema validate --schema payment-token-reference --file payment-token-reference.json
 `);
     }
 }
@@ -665,6 +668,17 @@ async function pushHostedEvidence(bundle, bytes, fileName) {
         skippedCompanionArtifacts: companions?.skipped,
         assurance,
         verifyContinuousAssurance: Boolean(assurance && (healthOut || requireCurrent)),
+        runtimeContext: await resolveRuntimeContext({
+            subject: bundle.subject.name,
+            framework: readFlag("--agent-framework"),
+            env: {
+                ...process.env,
+                ...(readFlag("--agent-id") ? { WITNORA_AGENT_ID: readFlag("--agent-id") } : {}),
+                ...(readFlag("--agent-name") ? { WITNORA_AGENT_NAME: readFlag("--agent-name") } : {}),
+                ...(readFlag("--agent-version") ? { WITNORA_AGENT_VERSION: readFlag("--agent-version") } : {}),
+                ...(readFlag("--environment") ? { WITNORA_ENVIRONMENT: readFlag("--environment") } : {}),
+            },
+        }),
     });
     process.stdout.write(`Hosted run: ${result.runId}\nHosted evidence: ${result.evidenceId}\n`);
     if (companions) {

package/dist/command-help.js

@@ -59,6 +59,11 @@ Options:
   --project <id>         Hosted project ID
   --api-key <key>        Project API key (prefer WITNORA_API_KEY in CI)
   --external-id <id>     Idempotent hosted run ID
+  --agent-id <id>        Stable observed Agent identity (default: evidence subject)
+  --agent-name <name>    Human-readable observed Agent name
+  --agent-version <v>    Version override (default: package or CI commit)
+  --agent-framework <f>  Framework metadata override
+  --environment <env>    sandbox, staging, or production
   --assurance-case <id>  Issued assurance case to reconcile
   --assurance-scope <p>  Declared agent/model/prompt/tools/policy/suite scope JSON
   --assurance-trigger <t> auto, pull_request, release, or nightly (default: auto)

package/dist/control-plane.js

@@ -75,6 +75,15 @@ export async function pushEvidenceToControlPlane(options) {
                 subject: bundle.subject,
                 products: bundle.summary.products,
             },
+            ...(options.runtimeContext ? {
+                agent: {
+                    externalId: options.runtimeContext.agentId,
+                    name: options.runtimeContext.agentName,
+                    version: options.runtimeContext.agentVersion,
+                    framework: options.runtimeContext.framework,
+                },
+                environment: options.runtimeContext.environment,
+            } : {}),
             assurance: options.assurance,
         }),
     });

package/dist/onboarding-templates.js

@@ -32,10 +32,15 @@ export function starterAdapter(template, subject) {
     const eventType = template === "coding" ? "coding.change.proposed" : template === "workflow" ? "workflow.step.completed" : "data.query.completed";
     return `#!/usr/bin/env node
 import { randomBytes, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
 
 const baseUrl = brandedRequired("BASE_URL").replace(/\\\/$/, "");
 const projectId = brandedRequired("PROJECT_ID");
 const apiKey = brandedRequired("API_KEY");
+const agentId = branded("AGENT_ID") ?? ${JSON.stringify(subject)};
+const agentName = branded("AGENT_NAME") ?? humanize(agentId);
+const agentVersion = await discoverAgentVersion();
+const environment = detectEnvironment();
 const now = new Date().toISOString();
 const traceId = randomBytes(16).toString("hex");
 const spanId = randomBytes(8).toString("hex");
@@ -44,10 +49,10 @@ const envelope = {
   envelopeId: randomUUID(),
   kind: "event",
   occurredAt: now,
-  source: { agentId: ${JSON.stringify(subject)}, agentVersion: process.env.AGENT_VERSION ?? "unversioned", framework: ${JSON.stringify(framework)}, adapter: "witnora-init-v0.2" },
-  run: { externalId: process.env.AGENT_RUN_ID ?? randomUUID(), kind: "custom" },
+  source: { agentId, agentName, agentVersion, framework: branded("AGENT_FRAMEWORK") ?? ${JSON.stringify(framework)}, adapter: "witnora-init-v0.3" },
+  run: { externalId: process.env.WITNORA_RUN_ID ?? process.env.AGENT_RUN_ID ?? randomUUID(), kind: "custom", environment: environment },
   trace: { traceId, spanId },
-  event: { type: ${JSON.stringify(eventType)}, actor: "agent", sequence: 0, attributes: { environment: process.env.AGENT_ENVIRONMENT ?? "development" } },
+  event: { type: ${JSON.stringify(eventType)}, actor: "agent", sequence: 0, attributes: { environment } },
 };
 const response = await fetch(\`\${baseUrl}/v1/projects/\${encodeURIComponent(projectId)}/envelopes\`, {
   method: "POST",
@@ -66,6 +71,44 @@ function brandedRequired(suffix) {
   if (!value) throw new Error(\`\${name} is required. Connect the Witnora CLI or set the hosted project variables. Legacy AGENTCERT_* names remain supported.\`);
   return value;
 }
+
+function branded(suffix) {
+  return process.env[\`WITNORA_\${suffix}\`] ?? process.env[\`AGENTCERT_\${suffix}\`];
+}
+
+function humanize(value) {
+  const unscoped = value.includes("/") ? value.slice(value.lastIndexOf("/") + 1) : value;
+  return unscoped.replace(/[-_.]+/g, " ").replace(/\\b\\w/g, (character) => character.toUpperCase()).trim();
+}
+
+async function discoverAgentVersion() {
+  const explicit = branded("AGENT_VERSION");
+  if (explicit) return explicit;
+  try {
+    const pkg = JSON.parse(await readFile(new URL("./package.json", import.meta.url), "utf8"));
+    if (typeof pkg.version === "string" && pkg.version.trim()) return pkg.version.trim();
+  } catch {}
+  const commit = process.env.GITHUB_SHA ?? process.env.RENDER_GIT_COMMIT ?? process.env.VERCEL_GIT_COMMIT_SHA;
+  return commit ? \`git-\${commit.slice(0, 12)}\` : "local";
+}
+
+function detectEnvironment() {
+  const explicit = branded("ENVIRONMENT") ?? process.env.VERCEL_ENV;
+  if (explicit) return normalizeEnvironment(explicit);
+  if (["pull_request", "pull_request_target"].includes(process.env.GITHUB_EVENT_NAME ?? "")) return "staging";
+  if (process.env.GITHUB_REF_TYPE === "tag") return "production";
+  if (process.env.RENDER_SERVICE_ID) return process.env.IS_PULL_REQUEST === "true" ? "staging" : "production";
+  if (process.env.NODE_ENV === "production") return "production";
+  return "sandbox";
+}
+
+function normalizeEnvironment(value) {
+  const normalized = value.trim().toLowerCase();
+  if (["sandbox", "development", "dev", "test", "local"].includes(normalized)) return "sandbox";
+  if (["staging", "stage", "preview", "pull_request", "pr"].includes(normalized)) return "staging";
+  if (["production", "prod", "live"].includes(normalized)) return "production";
+  throw new Error(\`Unsupported Witnora environment \${JSON.stringify(value)}. Use sandbox, staging, or production.\`);
+}
 `;
 }
 export function starterInstructions(template, subject) {

package/dist/runtime-context.js

@@ -0,0 +1,75 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+export async function resolveRuntimeContext(options) {
+    const env = options.env ?? process.env;
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const packageMetadata = await nearestPackageMetadata(cwd);
+    const agentId = first(env.WITNORA_AGENT_ID, env.AGENTCERT_AGENT_ID, options.subject, packageMetadata?.name) ?? "witnora-agent";
+    const agentName = first(env.WITNORA_AGENT_NAME, env.AGENTCERT_AGENT_NAME) ?? humanizeIdentifier(agentId);
+    return {
+        agentId,
+        agentName,
+        agentVersion: first(env.WITNORA_AGENT_VERSION, env.AGENTCERT_AGENT_VERSION, packageMetadata?.version, commitVersion(env), "local"),
+        ...(first(env.WITNORA_AGENT_FRAMEWORK, env.AGENTCERT_AGENT_FRAMEWORK, options.framework)
+            ? { framework: first(env.WITNORA_AGENT_FRAMEWORK, env.AGENTCERT_AGENT_FRAMEWORK, options.framework) }
+            : {}),
+        environment: detectRuntimeEnvironment(env),
+    };
+}
+export function humanizeIdentifier(value) {
+    const unscoped = value.includes("/") ? value.slice(value.lastIndexOf("/") + 1) : value;
+    return unscoped.replace(/[-_.]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase()).trim();
+}
+export function detectRuntimeEnvironment(env) {
+    const explicit = first(env.WITNORA_ENVIRONMENT, env.AGENTCERT_ENVIRONMENT);
+    if (explicit)
+        return normalizeRuntimeEnvironment(explicit);
+    if (env.VERCEL_ENV)
+        return normalizeRuntimeEnvironment(env.VERCEL_ENV);
+    if (env.GITHUB_EVENT_NAME === "pull_request" || env.GITHUB_EVENT_NAME === "pull_request_target")
+        return "staging";
+    if (env.GITHUB_REF_TYPE === "tag")
+        return "production";
+    if (env.RENDER_SERVICE_ID)
+        return env.IS_PULL_REQUEST === "true" ? "staging" : "production";
+    if (env.NODE_ENV === "production")
+        return "production";
+    return "sandbox";
+}
+export function normalizeRuntimeEnvironment(value) {
+    const normalized = value.trim().toLowerCase();
+    if (["sandbox", "development", "dev", "test", "local"].includes(normalized))
+        return "sandbox";
+    if (["staging", "stage", "preview", "pull_request", "pr"].includes(normalized))
+        return "staging";
+    if (["production", "prod", "live"].includes(normalized))
+        return "production";
+    throw new Error(`Unsupported Witnora environment ${JSON.stringify(value)}. Use sandbox, staging, or production.`);
+}
+async function nearestPackageMetadata(start) {
+    let current = start;
+    while (true) {
+        try {
+            const value = JSON.parse(await readFile(join(current, "package.json"), "utf8"));
+            return { name: text(value.name), version: text(value.version) };
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" && !(error instanceof SyntaxError))
+                throw error;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function commitVersion(env) {
+    const sha = first(env.GITHUB_SHA, env.RENDER_GIT_COMMIT, env.VERCEL_GIT_COMMIT_SHA);
+    return sha ? `git-${sha.slice(0, 12)}` : undefined;
+}
+function first(...values) {
+    return values.find((value) => typeof value === "string" && value.trim().length > 0)?.trim();
+}
+function text(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/dist/schema-validator.js

@@ -23,10 +23,12 @@ export function parseSchemaId(input) {
         value === "evolution-manifest" ||
         value === "permission-diff" ||
         value === "promotion-grant" ||
-        value === "promotion-receipt") {
+        value === "promotion-receipt" ||
+        value === "assurance-wallet" ||
+        value === "payment-token-reference") {
         return value;
     }
-    throw new Error(`Unsupported schema "${value}". Use evidence-bundle, result, corpus-record, failure-review, classifier-eval, monitor-snapshot, robustness-lab, release-gate, assurance-report, assurance-delivery, assurance-scope, evidence-signature, evidence-strength, action-mandate, trusted-action-record, trusted-run-receipt, agent-mutation, evolution-manifest, permission-diff, promotion-grant, or promotion-receipt.`);
+    throw new Error(`Unsupported schema "${value}". Use evidence-bundle, result, corpus-record, failure-review, classifier-eval, monitor-snapshot, robustness-lab, release-gate, assurance-report, assurance-delivery, assurance-scope, evidence-signature, evidence-strength, action-mandate, trusted-action-record, trusted-run-receipt, agent-mutation, evolution-manifest, permission-diff, promotion-grant, promotion-receipt, assurance-wallet, or payment-token-reference.`);
 }
 export function validateAgentCertSchema(schema, input) {
     const errors = [];
@@ -78,9 +80,100 @@ export function validateAgentCertSchema(schema, input) {
             validatePromotionGrant(value, errors);
         if (schema === "promotion-receipt")
             validatePromotionReceipt(value, errors);
+        if (schema === "assurance-wallet")
+            validateAssuranceWallet(value, errors);
+        if (schema === "payment-token-reference")
+            validatePaymentTokenReference(value, errors);
     }
     return { schema, valid: errors.length === 0, errors };
 }
+function validateAssuranceWallet(value, errors) {
+    requiredConst(value, "schemaVersion", "witnora.assurance_wallet.v0.1", errors);
+    for (const field of ["id", "projectId", "name", "ownerPrincipalId", "baseCurrency", "policyDigestSha256", "status", "createdBy", "createdAt", "updatedAt"])
+        requiredString(value, field, errors);
+    sha256Field(value, "policyDigestSha256", errors);
+    requiredEnum(value, "status", ["ACTIVE", "SUSPENDED", "REVOKED"], errors);
+    for (const field of ["createdAt", "updatedAt"])
+        validateTimestamp(value[field], field, errors);
+    const policy = recordValue(value.policy);
+    if (!policy) {
+        errors.push("policy must be an object.");
+        return;
+    }
+    requiredArray(policy, "allowedProviders", errors);
+    requiredArray(policy, "allowedEnvironments", errors);
+    requiredArray(policy, "allowedCurrencies", errors);
+    stringArray(policy.allowedProviders, "policy.allowedProviders", errors);
+    stringArray(policy.allowedEnvironments, "policy.allowedEnvironments", errors);
+    stringArray(policy.allowedCurrencies, "policy.allowedCurrencies", errors);
+    enumArray(policy.allowedProviders, "policy.allowedProviders", ["STRIPE", "CLOUDFLARE"], errors);
+    enumArray(policy.allowedEnvironments, "policy.allowedEnvironments", ["SANDBOX", "TEST"], errors);
+    currencyArray(policy.allowedCurrencies, "policy.allowedCurrencies", errors);
+    currencyField(value, "baseCurrency", errors);
+    if (Array.isArray(policy.allowedCurrencies) &&
+        (policy.allowedCurrencies.length !== 1 || policy.allowedCurrencies[0] !== value.baseCurrency)) {
+        errors.push("policy.allowedCurrencies must contain only baseCurrency in v0.1.");
+    }
+    requiredNumber(policy, "maxAmountPerAction", errors);
+    requiredNumber(policy, "maxAmountPerPeriod", errors);
+    requiredNumber(policy, "periodSeconds", errors);
+    positiveNumber(policy, "maxAmountPerAction", errors);
+    positiveNumber(policy, "maxAmountPerPeriod", errors);
+    positiveInteger(policy, "periodSeconds", errors);
+    requiredBoolean(policy, "mandateRequired", errors);
+    requiredBoolean(policy, "independentOutcomeRequired", errors);
+    if (policy.mandateRequired !== true)
+        errors.push("policy.mandateRequired must be true.");
+    if (policy.independentOutcomeRequired !== true)
+        errors.push("policy.independentOutcomeRequired must be true.");
+    requiredEnum(policy, "recurringPayments", ["DENY", "REQUIRE_APPROVAL"], errors);
+}
+function validatePaymentTokenReference(value, errors) {
+    requiredConst(value, "schemaVersion", "witnora.payment_token_reference.v0.1", errors);
+    for (const field of ["id", "projectId", "walletId", "providerAccountId", "tokenType", "tokenSha256", "audience", "currency", "expiresAt", "status", "createdBy", "createdAt", "updatedAt"])
+        requiredString(value, field, errors);
+    sha256Field(value, "tokenSha256", errors);
+    requiredNumber(value, "maxAmount", errors);
+    positiveNumber(value, "maxAmount", errors);
+    currencyField(value, "currency", errors);
+    requiredEnum(value, "provider", ["STRIPE", "CLOUDFLARE"], errors);
+    requiredEnum(value, "environment", ["SANDBOX", "TEST"], errors);
+    requiredEnum(value, "status", ["AVAILABLE", "BOUND", "CONSUMED", "EXPIRED", "REVOKED"], errors);
+    for (const field of ["expiresAt", "createdAt", "updatedAt"])
+        validateTimestamp(value[field], field, errors);
+}
+function enumArray(value, path, allowed, errors) {
+    if (!Array.isArray(value))
+        return;
+    for (const [index, item] of value.entries()) {
+        if (typeof item === "string" && !allowed.includes(item)) {
+            errors.push(`${path}[${index}] must be one of: ${allowed.join(", ")}.`);
+        }
+    }
+}
+function currencyArray(value, path, errors) {
+    if (!Array.isArray(value))
+        return;
+    for (const [index, item] of value.entries()) {
+        if (typeof item === "string" && !/^[A-Z]{3}$/.test(item)) {
+            errors.push(`${path}[${index}] must be a three-letter uppercase currency code.`);
+        }
+    }
+}
+function currencyField(input, key, errors) {
+    if (typeof input[key] === "string" && !/^[A-Z]{3}$/.test(input[key])) {
+        errors.push(`${key} must be a three-letter uppercase currency code.`);
+    }
+}
+function positiveNumber(input, key, errors) {
+    if (typeof input[key] === "number" && input[key] <= 0)
+        errors.push(`${key} must be greater than zero.`);
+}
+function positiveInteger(input, key, errors) {
+    if (typeof input[key] === "number" && (!Number.isInteger(input[key]) || input[key] <= 0)) {
+        errors.push(`${key} must be a positive integer.`);
+    }
+}
 function validateEvidenceBundle(value, errors) {
     requiredConst(value, "schemaName", "agentcert.evidence_bundle", errors);
     requiredConst(value, "schemaVersion", AGENTCERT_EVIDENCE_SCHEMA_VERSION, errors);
@@ -135,6 +228,21 @@ function validateEvidenceStrength(value, errors, prefix = "") {
     requiredArray(value, "limitations", errors);
     stringArray(value.claims, `${prefix}claims`, errors);
     stringArray(value.limitations, `${prefix}limitations`, errors);
+    const trust = recordValue(value.trustVector);
+    if (value.trustVector !== undefined && !trust)
+        errors.push(`${prefix}trustVector must be an object.`);
+    if (trust)
+        validateEvidenceTrustVector(trust, errors, `${prefix}trustVector.`);
+}
+function validateEvidenceTrustVector(value, errors, prefix) {
+    requiredConst(value, "schemaVersion", "witnora.evidence_trust_vector.v0.1", errors);
+    requiredEnumAt(value, "capture", ["self_reported", "collector_recorded", "boundary_observed"], `${prefix}capture`, errors);
+    requiredEnumAt(value, "mediation", ["none", "advisory", "enforced"], `${prefix}mediation`, errors);
+    requiredEnumAt(value, "outcome", ["unverified", "verified", "contradicted"], `${prefix}outcome`, errors);
+    requiredEnumAt(value, "completeness", ["unknown", "partial", "target_reconciled"], `${prefix}completeness`, errors);
+    requiredEnumAt(value, "attestation", ["unsigned", "source_signed", "platform_signed", "externally_witnessed"], `${prefix}attestation`, errors);
+    requiredEnumAt(value, "review", ["none", "internal", "independent_external"], `${prefix}review`, errors);
+    stringArray(value.limitations, `${prefix}limitations`, errors);
 }
 function validateActionMandate(value, errors) {
     requiredConst(value, "schemaVersion", "agentcert.action_mandate.v0.1", errors);
@@ -363,7 +471,9 @@ function validateAssuranceContinuity(input, errors) {
     }
 }
 function validateAssuranceScope(value, errors) {
-    requiredConst(value, "schemaVersion", "agentcert.assurance_scope.v0.1", errors);
+    if (value.schemaVersion !== "agentcert.assurance_scope.v0.1" && value.schemaVersion !== "agentcert.assurance_scope.v0.2") {
+        errors.push("schemaVersion must be agentcert.assurance_scope.v0.1 or agentcert.assurance_scope.v0.2.");
+    }
     for (const key of ["agent", "model", "prompt", "tools", "policy", "scenarioSuite"])
         requiredObject(value, key, errors);
     const agent = recordValue(value.agent);
@@ -394,6 +504,34 @@ function validateAssuranceScope(value, errors) {
         requiredStringAt(suite, "version", "scenarioSuite.version", errors);
         requiredSha256At(suite, "sha256", "scenarioSuite.sha256", errors);
     }
+    if (value.schemaVersion === "agentcert.assurance_scope.v0.2") {
+        for (const key of ["runtimeBoundary", "outcomeProbe", "evidenceTrust"])
+            requiredObject(value, key, errors);
+        const runtime = recordValue(value.runtimeBoundary);
+        const probe = recordValue(value.outcomeProbe);
+        const trust = recordValue(value.evidenceTrust);
+        if (runtime) {
+            requiredSha256At(runtime, "gatewayDigestSha256", "runtimeBoundary.gatewayDigestSha256", errors);
+            requiredSha256At(runtime, "adapterDigestSha256", "runtimeBoundary.adapterDigestSha256", errors);
+            requiredStringAt(runtime, "credentialBoundary", "runtimeBoundary.credentialBoundary", errors);
+            requiredSha256At(runtime, "networkBoundarySha256", "runtimeBoundary.networkBoundarySha256", errors);
+            requiredStringAt(runtime, "grantIssuer", "runtimeBoundary.grantIssuer", errors);
+        }
+        if (probe) {
+            requiredStringAt(probe, "profileId", "outcomeProbe.profileId", errors);
+            requiredStringAt(probe, "version", "outcomeProbe.version", errors);
+            requiredSha256At(probe, "digestSha256", "outcomeProbe.digestSha256", errors);
+            requiredStringAt(probe, "authoritativeSource", "outcomeProbe.authoritativeSource", errors);
+            requiredStringAt(probe, "readCredentialBoundary", "outcomeProbe.readCredentialBoundary", errors);
+        }
+        if (trust) {
+            requiredSha256At(trust, "collectorDigestSha256", "evidenceTrust.collectorDigestSha256", errors);
+            requiredStringAt(trust, "evidenceSchemaVersion", "evidenceTrust.evidenceSchemaVersion", errors);
+            requiredStringAt(trust, "signingKeyId", "evidenceTrust.signingKeyId", errors);
+            requiredSha256At(trust, "verifierDigestSha256", "evidenceTrust.verifierDigestSha256", errors);
+            requiredSha256At(trust, "retentionPolicySha256", "evidenceTrust.retentionPolicySha256", errors);
+        }
+    }
 }
 function requiredSha256At(value, key, path, errors) {
     if (typeof value[key] !== "string" || !/^[0-9a-f]{64}$/.test(value[key]))

package/dist/vendor/agentcert-sdk/deployment-enforcement.d.ts

@@ -0,0 +1,77 @@
+export type DeploymentAdapterKind = "github_environment" | "kubernetes_admission" | "customer_gateway";
+export interface DeploymentCredentialExchangeResult {
+    credential: {
+        id: string;
+        payload: {
+            schemaVersion: "witnora.deployment_credential.v0.1";
+            artifactDigestSha256: string;
+            target: {
+                environment: string;
+                deploymentUri: string;
+            };
+            adapters: DeploymentAdapterKind[];
+            mode: "PROMOTION" | "ROLLBACK" | "BREAK_GLASS";
+            expiresAt: string;
+        };
+        status: "ISSUED";
+    };
+    token: string;
+}
+export declare function exchangeGitHubOidcPromotionGrant(input: {
+    baseUrl: string;
+    projectId: string;
+    promotionGrantId: string;
+    identityProviderId: string;
+    brokerApiKey: string;
+    audience?: string;
+    adapters: DeploymentAdapterKind[];
+    rationale: string;
+    ttlSeconds?: number;
+    idempotencyKey?: string;
+    fetch?: typeof fetch;
+    environment?: NodeJS.ProcessEnv;
+}): Promise<DeploymentCredentialExchangeResult>;
+export declare function claimDeploymentAdmission(input: {
+    baseUrl: string;
+    projectId: string;
+    credentialId: string;
+    deploymentToken: string;
+    adapter: DeploymentAdapterKind;
+    artifactDigestSha256: string;
+    deploymentUri: string;
+    idempotencyKey?: string;
+    fetch?: typeof fetch;
+}): Promise<{
+    admitted: true;
+}>;
+export declare function deployWithPromotionEnforcement<T>(input: {
+    admission: Parameters<typeof claimDeploymentAdmission>[0];
+    deploy: () => Promise<T>;
+    observe: (result: T) => Promise<{
+        artifactDigestSha256: string;
+    }>;
+    rollback?: (result: T) => Promise<void>;
+}): Promise<{
+    result: T;
+    observedArtifactDigestSha256: string;
+}>;
+export interface KubernetesAdmissionReview {
+    apiVersion: "admission.k8s.io/v1";
+    kind: "AdmissionReview";
+    request?: {
+        uid: string;
+        object?: {
+            metadata?: {
+                annotations?: Record<string, string>;
+            };
+            spec?: Record<string, unknown>;
+        };
+    };
+}
+export declare function createKubernetesAdmissionHandler(options: {
+    baseUrl: string;
+    projectId: string;
+    deploymentToken: () => string | Promise<string>;
+    fetch?: typeof fetch;
+}): (review: KubernetesAdmissionReview) => Promise<Record<string, unknown>>;
+//# sourceMappingURL=deployment-enforcement.d.ts.map

package/dist/vendor/agentcert-sdk/deployment-enforcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-enforcement.d.ts","sourceRoot":"","sources":["../../../../agentcert-sdk/src/deployment-enforcement.ts"],"names":[],"mappings":"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"}

package/dist/vendor/agentcert-sdk/deployment-enforcement.js

@@ -0,0 +1,109 @@
+import { randomUUID } from "node:crypto";
+export async function exchangeGitHubOidcPromotionGrant(input) {
+    const requestFetch = input.fetch ?? fetch;
+    const environment = input.environment ?? process.env;
+    const requestUrl = environment.ACTIONS_ID_TOKEN_REQUEST_URL;
+    const requestToken = environment.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+    if (!requestUrl || !requestToken)
+        throw new Error("GitHub Actions OIDC is unavailable. Set permissions: id-token: write.");
+    const oidcUrl = new URL(requestUrl);
+    oidcUrl.searchParams.set("audience", input.audience ?? "witnora-deployment-broker");
+    const oidcResponse = await requestFetch(oidcUrl, { headers: { authorization: `Bearer ${requestToken}`, accept: "application/json" } });
+    const oidcBody = await responseObject(oidcResponse);
+    if (!oidcResponse.ok || typeof oidcBody.value !== "string")
+        throw new Error(message(oidcBody, `GitHub OIDC request failed (${oidcResponse.status}).`));
+    const response = await requestFetch(`${stripSlash(input.baseUrl)}/v1/projects/${encodeURIComponent(input.projectId)}/promotion-grants/${encodeURIComponent(input.promotionGrantId)}/exchange-deployment-credential`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${input.brokerApiKey}`, "content-type": "application/json" },
+        body: JSON.stringify({
+            providerId: input.identityProviderId,
+            oidcToken: oidcBody.value,
+            adapters: input.adapters,
+            rationale: input.rationale,
+            ttlSeconds: input.ttlSeconds ?? 300,
+            idempotencyKey: input.idempotencyKey ?? `${environment.GITHUB_RUN_ID ?? "local"}:${environment.GITHUB_RUN_ATTEMPT ?? "1"}`,
+        }),
+    });
+    const body = await responseObject(response);
+    if (!response.ok)
+        throw new Error(message(body, `Deployment credential exchange failed (${response.status}).`));
+    return body;
+}
+export async function claimDeploymentAdmission(input) {
+    const response = await (input.fetch ?? fetch)(`${stripSlash(input.baseUrl)}/v1/runtime/projects/${encodeURIComponent(input.projectId)}/deployment-credentials/${encodeURIComponent(input.credentialId)}/admit`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${input.deploymentToken}`, "content-type": "application/json" },
+        body: JSON.stringify({
+            adapter: input.adapter,
+            artifactDigestSha256: input.artifactDigestSha256,
+            deploymentUri: input.deploymentUri,
+            idempotencyKey: input.idempotencyKey ?? randomUUID(),
+        }),
+    });
+    const body = await responseObject(response);
+    if (!response.ok)
+        throw new Error(message(body, `Deployment was denied (${response.status}).`));
+    return body;
+}
+export async function deployWithPromotionEnforcement(input) {
+    await claimDeploymentAdmission(input.admission);
+    const result = await input.deploy();
+    try {
+        const observation = await input.observe(result);
+        if (observation.artifactDigestSha256 !== input.admission.artifactDigestSha256)
+            throw new Error("Observed deployment digest does not match the admitted artifact digest.");
+        return { result, observedArtifactDigestSha256: observation.artifactDigestSha256 };
+    }
+    catch (error) {
+        if (input.rollback)
+            await input.rollback(result);
+        throw error;
+    }
+}
+export function createKubernetesAdmissionHandler(options) {
+    return async (review) => {
+        const uid = review.request?.uid ?? "missing-uid";
+        const annotations = review.request?.object?.metadata?.annotations ?? {};
+        const credentialId = annotations["witnora.com/deployment-credential-id"];
+        const artifactDigestSha256 = annotations["witnora.com/artifact-digest-sha256"];
+        const deploymentUri = annotations["witnora.com/deployment-uri"];
+        if (!credentialId || !artifactDigestSha256 || !deploymentUri)
+            return admissionReview(uid, false, "Missing Witnora deployment credential annotations.");
+        const images = workloadImages(review.request?.object?.spec);
+        if (!images.length || !images.every((image) => image.endsWith(`@sha256:${artifactDigestSha256}`))) {
+            return admissionReview(uid, false, "Workload image digest does not match the Witnora admitted artifact digest.");
+        }
+        try {
+            await claimDeploymentAdmission({
+                baseUrl: options.baseUrl, projectId: options.projectId, credentialId,
+                deploymentToken: await options.deploymentToken(), adapter: "kubernetes_admission",
+                artifactDigestSha256, deploymentUri, idempotencyKey: `k8s:${uid}`, fetch: options.fetch,
+            });
+            return admissionReview(uid, true, "Witnora deployment credential admitted the exact artifact and target.");
+        }
+        catch (error) {
+            return admissionReview(uid, false, error instanceof Error ? error.message : "Witnora deployment admission failed.");
+        }
+    };
+}
+function admissionReview(uid, allowed, messageValue) {
+    return { apiVersion: "admission.k8s.io/v1", kind: "AdmissionReview", response: { uid, allowed, status: { message: messageValue } } };
+}
+function workloadImages(spec) {
+    const template = object(spec?.template);
+    const podSpec = object(template?.spec) ?? spec;
+    if (!podSpec)
+        return [];
+    const containers = [...array(podSpec.containers), ...array(podSpec.initContainers)];
+    return containers.flatMap((value) => {
+        const container = object(value);
+        return typeof container?.image === "string" ? [container.image] : [];
+    });
+}
+function object(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : undefined; }
+function array(value) { return Array.isArray(value) ? value : []; }
+async function responseObject(response) {
+    return await response.json().catch(() => ({}));
+}
+function message(body, fallback) { return typeof body.error === "string" ? body.error : fallback; }
+function stripSlash(value) { return value.replace(/\/$/, ""); }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "witnora",
-  "version": "0.9.2",
-  "description": "Witnora evidence, assurance release gates, runtime records, and regression CI for autonomous AI systems.",
+  "version": "0.10.0",
+  "description": "Independent assurance for covered agent action paths across models and frameworks.",
   "type": "module",
   "license": "Apache-2.0",
   "homepage": "https://witnora.com/",
@@ -39,6 +39,10 @@
     "./browser-adapter-kit": {
       "types": "./dist/vendor/onegent-runtime/browser-adapter-kit.d.ts",
       "import": "./dist/vendor/onegent-runtime/browser-adapter-kit.js"
+    },
+    "./deployment-enforcement": {
+      "types": "./dist/vendor/agentcert-sdk/deployment-enforcement.d.ts",
+      "import": "./dist/vendor/agentcert-sdk/deployment-enforcement.js"
     }
   },
   "files": [
@@ -47,7 +51,7 @@
     "package.json"
   ],
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.onegent-vendor.json",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.onegent-vendor.json && tsc -p tsconfig.sdk-vendor.json",
     "prepack": "npm run build",
     "test": "vitest run tests",
     "demo:report": "node dist/cli.js report --mcpbench ../../examples/reports/passing/results.json --out .witnora/demo --subject demo-agent"