witnora 0.9.3 → 0.10.2

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/trust-v02.js

@@ -0,0 +1,111 @@
+import { createHash, createPrivateKey, createPublicKey, sign, verify } from "node:crypto";
+import { canonicalBytesV02, sha256CanonicalV02 } from "./canonical-v02.js";
+export function createTrustRoot(input) {
+    const core = { ...input, protocolVersion: "witnora.trust_root.v0.2" };
+    return { ...core, rootFingerprint: createHash("sha256").update(createPublicKey(input.publicKeyPem).export({ format: "der", type: "spki" })).digest("hex") };
+}
+export function issueKeyCertificate(input, issuerPrivateKeyPem) {
+    const core = { ...input, protocolVersion: "witnora.key_certificate.v0.2" };
+    const certificateDigest = sha256CanonicalV02(core);
+    return { ...core, certificateDigest, signature: sign(null, canonicalBytesV02({ ...core, certificateDigest }), createPrivateKey(issuerPrivateKeyPem)).toString("base64") };
+}
+export function verifyKeyCertificate(certificate, root, at, expected) {
+    if (certificate.protocolVersion !== "witnora.key_certificate.v0.2")
+        throw new Error("Unsupported key certificate version.");
+    verifyPinnedRootShape(root);
+    const eventAt = parseInstant(at, "certificate verification time");
+    const rootNotBefore = parseInstant(root.notBefore, "trust root notBefore");
+    const rootNotAfter = parseInstant(root.notAfter, "trust root notAfter");
+    if (rootNotAfter <= rootNotBefore)
+        throw new Error("Pinned trust-root validity interval is invalid.");
+    if (eventAt < rootNotBefore || eventAt > rootNotAfter)
+        throw new Error("Pinned trust root is outside its validity interval.");
+    if (certificate.issuerRootId !== root.rootId)
+        throw new Error("Certificate issuer is not the pinned root.");
+    if (certificate.role !== expected.role || !root.allowedRoles.includes(certificate.role))
+        throw new Error("Certificate role is not authorized by the pinned root.");
+    if (certificate.tenantRef !== expected.tenantRef || certificate.projectRef !== expected.projectRef || certificate.environment !== expected.environment)
+        throw new Error("Certificate trust scope mismatch.");
+    const certificateNotBefore = parseInstant(certificate.notBefore, "certificate notBefore");
+    const certificateNotAfter = parseInstant(certificate.notAfter, "certificate notAfter");
+    if (certificateNotAfter <= certificateNotBefore)
+        throw new Error("Certificate validity interval is invalid.");
+    if (eventAt < certificateNotBefore || eventAt > certificateNotAfter)
+        throw new Error("Certificate is outside its validity interval.");
+    const { signature, certificateDigest, ...core } = certificate;
+    if (sha256CanonicalV02(core) !== certificateDigest)
+        throw new Error("Certificate digest mismatch.");
+    if (!verify(null, canonicalBytesV02({ ...core, certificateDigest }), createPublicKey(root.publicKeyPem), Buffer.from(signature, "base64")))
+        throw new Error("Certificate signature is invalid.");
+}
+export function appendRevocation(journal, input, rootPrivateKeyPem) {
+    const statements = journal?.statements ?? [];
+    const core = {
+        sequence: statements.length + 1,
+        previousJournalDigest: journal?.checkpointDigest ?? null,
+        ...input,
+        protocolVersion: "witnora.key_revocation_statement.v0.2",
+    };
+    const statementDigest = sha256CanonicalV02(core);
+    const statement = { ...core, statementDigest, signature: sign(null, canonicalBytesV02({ ...core, statementDigest }), createPrivateKey(rootPrivateKeyPem)).toString("base64") };
+    const next = [...statements, statement];
+    return { protocolVersion: "witnora.revocation_journal.v0.2", rootId: input.issuerRootId, statements: next, checkpointDigest: sha256CanonicalV02(next) };
+}
+export function verifyRevocationJournal(journal, root) {
+    if (journal.protocolVersion !== "witnora.revocation_journal.v0.2")
+        throw new Error("Unsupported revocation journal version.");
+    verifyPinnedRootShape(root);
+    let previous = null;
+    for (const [index, statement] of journal.statements.entries()) {
+        if (statement.protocolVersion !== "witnora.key_revocation_statement.v0.2")
+            throw new Error("Unsupported revocation statement version.");
+        if (statement.sequence !== index + 1 || statement.previousJournalDigest !== previous || statement.issuerRootId !== root.rootId)
+            throw new Error("Revocation journal continuity is invalid.");
+        parseInstant(statement.effectiveAt, "revocation effectiveAt");
+        const { signature, statementDigest, ...core } = statement;
+        if (sha256CanonicalV02(core) !== statementDigest)
+            throw new Error("Revocation statement digest mismatch.");
+        if (!verify(null, canonicalBytesV02({ ...core, statementDigest }), createPublicKey(root.publicKeyPem), Buffer.from(signature, "base64")))
+            throw new Error("Revocation statement signature is invalid.");
+        previous = sha256CanonicalV02(journal.statements.slice(0, index + 1));
+    }
+    if (journal.rootId !== root.rootId || journal.checkpointDigest !== (previous ?? sha256CanonicalV02([])))
+        throw new Error("Revocation journal checkpoint mismatch.");
+}
+export function assertNotRevoked(certificate, journal, eventAt) {
+    const eventTime = parseInstant(eventAt, "revocation event time");
+    for (const revocation of journal.statements) {
+        if (revocation.revokedId !== certificate.certificateId && revocation.revokedId !== certificate.subjectKeyId)
+            continue;
+        const effectiveAt = parseInstant(revocation.effectiveAt, "revocation effectiveAt");
+        if (revocation.retroactive || eventTime >= effectiveAt)
+            throw new Error("Certificate was revoked for the event time.");
+    }
+}
+export function assertRevocationJournalExtends(packetJournal, latestJournal) {
+    if (packetJournal.rootId !== latestJournal.rootId || packetJournal.statements.length > latestJournal.statements.length)
+        throw new Error("Revocation rollback detected: packet journal is not a prefix of the latest trusted journal.");
+    for (const [index, statement] of packetJournal.statements.entries()) {
+        if (statement.statementDigest !== latestJournal.statements[index]?.statementDigest)
+            throw new Error("Revocation rollback detected: packet journal diverges from the latest trusted journal.");
+    }
+}
+function parseInstant(value, field) {
+    if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value))
+        throw new Error(`${field} must be an RFC 3339 UTC timestamp.`);
+    const parsed = value instanceof Date ? value.getTime() : Date.parse(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${field} must be a valid timestamp.`);
+    return parsed;
+}
+function verifyPinnedRootShape(root) {
+    if (root.protocolVersion !== "witnora.trust_root.v0.2" || root.algorithm !== "Ed25519")
+        throw new Error("Unsupported pinned trust root.");
+    const actualFingerprint = createHash("sha256").update(createPublicKey(root.publicKeyPem).export({ format: "der", type: "spki" })).digest("hex");
+    if (root.rootFingerprint !== actualFingerprint)
+        throw new Error("Pinned trust-root fingerprint mismatch.");
+    const notBefore = parseInstant(root.notBefore, "trust root notBefore");
+    const notAfter = parseInstant(root.notAfter, "trust root notAfter");
+    if (notAfter <= notBefore)
+        throw new Error("Pinned trust-root validity interval is invalid.");
+}

package/dist/try.js

@@ -92,7 +92,7 @@ export async function writeTryEvidence(options) {
                 kind: "synthetic_onboarding",
                 severity: "info",
                 message: `Deterministic ${options.template} sample passed. Replace it with evidence from the real agent boundary before making a release decision.`,
-                source: "agentcert try",
+                source: "witnora try",
                 artifactPath,
                 metadata: { synthetic: true, template: options.template, purpose: "onboarding_only" },
             }],