@oxdeai/conformance 1.3.1 → 2.0.0

package/dist/src/validate.js

@@ -1,8 +1,15 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+import { evidenceScope } from "./evidenceScope.mjs";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { encodeCanonicalState, encodeEnvelope, PolicyEngine, sha256HexFromJson, signAuthorizationEd25519, signEnvelopeEd25519, verifyAuthorization, verifyAuditEvents, verifyEnvelope, verifySnapshot } from "@oxdeai/core";
+import { fileURLToPath } from "node:url";
+import { createHash, sign as nodeSign } from "node:crypto";
+import { encodeCanonicalState, encodeEnvelope, PolicyEngine, RECOMMENDED_TRUSTED_TIME_PROFILE, sha256HexFromJson, signAuthorizationEd25519, signEnvelopeEd25519, verifyAuthorization, verifyAuditEvents, verifyEnvelope, verifySnapshot, createDelegation, verifyDelegation, verifyDelegationChain, signEd25519, SIGNING_DOMAINS, signedKrlSigningPayload, verifySignedKrl, } from "@oxdeai/core";
 import { TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, } from "./fixtures/ed25519.test-only.fixture.js";
+import { KRL_TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, KRL_TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION, } from "./fixtures/krl-ed25519.test-only.fixture.js";
+import { CONFORMANCE_ENGINE_SECRET } from "./fixtures/conformance-engine-secret.fixture.js";
+import { runTrustedTimeConformance } from "./trustedTimeConformance.js";
 const TEST_KEYSET = {
     issuer: "oxdeai.policy-engine",
     version: "1",
@@ -14,7 +21,7 @@ const TEST_KEYSET = {
         }
     ]
 };
-const CORE_ENGINE_SECRET = "test-secret";
+const CORE_ENGINE_SECRET = CONFORMANCE_ENGINE_SECRET;
 const CORE_POLICY_ID = "a".repeat(64);
 const INTENT_BINDING_FIELDS = [
     "intent_id",
@@ -32,12 +39,13 @@ const INTENT_BINDING_FIELDS = [
     "tool",
     "tool_call"
 ];
-function makeEngine() {
+function makeEngine(authorizationTtlSeconds = 60) {
     return new PolicyEngine({
         policy_version: "v1.0.0",
-        engine_secret: CORE_ENGINE_SECRET,
-        authorization_ttl_seconds: 60,
-        policyId: CORE_POLICY_ID
+        engine_secret: CORE_ENGINE_SECRET, // now typed as string
+        authorization_ttl_seconds: authorizationTtlSeconds,
+        policyId: CORE_POLICY_ID,
+        ...RECOMMENDED_TRUSTED_TIME_PROFILE
     });
 }
 function makeBaseState() {
@@ -151,6 +159,23 @@ function b64ToBytes(value) {
 function hexSha256Utf8(value) {
     return createHash("sha256").update(value, "utf8").digest("hex");
 }
+// Returns the raw signature bytes string regardless of which shape is present.
+// Used wherever the conformance layer needs to inspect or compare signature material.
+function getSignatureBytes(signature) {
+    return typeof signature === "string" ? signature : signature.sig;
+}
+// Corrupts the signature bytes by replacing the last two characters with "aa".
+// Works for both the legacy bare-string shape and the normative nested-object shape.
+// All mutation-test sites must go through this helper; no direct .slice() on signature.
+function mutateSignature(auth) {
+    if (typeof auth.signature === "string") {
+        return { ...auth, signature: auth.signature.slice(0, -2) + "aa" };
+    }
+    return {
+        ...auth,
+        signature: { ...auth.signature, sig: auth.signature.sig.slice(0, -2) + "aa" },
+    };
+}
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -185,12 +210,15 @@ const coreAdapter = {
         }
         return sha256HexFromJson(binding);
     },
-    evaluateAuthorization(intent) {
+    evaluateAuthorization(intent, evaluationTime) {
         const engine = makeEngine();
-        const out = engine.evaluatePure(intent, makeBaseState());
+        const out = engine.evaluatePure(intent, makeBaseState(), evaluationTime);
         if (out.decision !== "ALLOW") {
             throw new Error(`expected ALLOW, got DENY: ${out.reasons.join(",")}`);
         }
+        // Cast to AuthorizationLike: runtime object retains internal engine fields
+        // (state_snapshot_hash, expires_at, engine_signature) even though the
+        // TypeScript type was narrowed to AuthorizationV1 at the evaluatePure boundary.
         return { authorization: out.authorization, policyId: engine.computePolicyId() };
     },
     encodeSnapshot(state) {
@@ -207,16 +235,29 @@ const coreAdapter = {
     verifyEnvelope,
     verifyAuthorization
 };
+const here = fileURLToPath(new URL(".", import.meta.url));
+const exercised = new Map();
+const caseResults = new Map();
+const jsonOutput = process.argv.includes("--json");
+function recordCase(label, passed) {
+    const id = label.split(/[ :]/)[0];
+    caseResults.set(id, (caseResults.get(id) ?? true) && passed);
+}
 function loadJson(name) {
-    const p = resolve(process.cwd(), "vectors", name);
-    return JSON.parse(readFileSync(p, "utf8"));
+    const p = resolve(here, "../../vectors", name);
+    const data = JSON.parse(readFileSync(p, "utf8"));
+    exercised.set(`packages/conformance/vectors/${name}`, data);
+    return data;
 }
 function pass(ctx, msg) {
     ctx.passed += 1;
-    console.log(`PASS ${msg}`);
+    recordCase(msg, true);
+    if (!jsonOutput)
+        console.log(`PASS ${msg}`);
 }
 function fail(ctx, msg) {
     ctx.failures.push(msg);
+    recordCase(msg, false);
     console.error(`FAIL ${msg}`);
 }
 function eq(ctx, label, actual, expected) {
@@ -246,14 +287,20 @@ function validateAuthorizationVectors(ctx, adapter) {
     const file = loadJson("authorization-payload.json");
     for (const v of file.vectors) {
         const id = String(v.id);
-        const intent = parseIntent(v.input);
-        const { authorization, policyId } = adapter.evaluateAuthorization(intent);
+        const input = asRecord(v.input);
+        const intent = parseIntent(input.intent);
+        const evaluationTime = Number(input.evaluation_time);
+        const effectiveTtl = Number(input.effective_ttl);
+        eq(ctx, `${id} intent_timestamp`, intent.timestamp, Number(input.intent_timestamp));
+        const { authorization, policyId } = adapter.evaluateAuthorization(intent, evaluationTime);
         const expected = asRecord(v.expected);
         eq(ctx, `${id} intent_hash`, authorization.intent_hash, String(expected.intent_hash));
         if (expected.state_hash !== undefined) {
             eq(ctx, `${id} state_hash`, authorization.state_snapshot_hash, String(expected.state_hash));
         }
-        eq(ctx, `${id} expires_at`, authorization.expires_at, Number(expected.expires_at));
+        eq(ctx, `${id} issued_at`, authorization.issued_at, Number(expected.expected_issued_at));
+        eq(ctx, `${id} expiry`, authorization.expires_at, Number(expected.expected_expiry));
+        eq(ctx, `${id} effective_ttl`, authorization.expires_at - authorization.issued_at, effectiveTtl);
         const payload = adapter.canonicalJson({
             expires_at: authorization.expires_at,
             intent_hash: authorization.intent_hash,
@@ -282,6 +329,263 @@ function validateAuthorizationVerificationVectors(ctx, adapter) {
         eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
     }
 }
+function validateClockSemanticsVectors(ctx, adapter) {
+    const file = loadJson("clock-semantics-verification.json");
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const input = asRecord(v.input);
+        const auth = {
+            alg: "HMAC-SHA256",
+            kid: "legacy",
+            signature: "legacy-placeholder",
+            ...asRecord(input.auth)
+        };
+        const opts = (input.opts ? asRecord(input.opts) : {});
+        const expected = asRecord(v.expected);
+        const got = adapter.verifyAuthorization(auth, opts);
+        eq(ctx, `${id} status`, got.status, String(expected.status));
+        eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
+    }
+}
+// ── Delegation conformance helpers ────────────────────────────────────────────
+const DELEGATION_T_ISSUED = 1_000_000;
+const DELEGATION_T_NOW = 1_001_000;
+const DELEGATION_T_DEL_EXP = 1_002_000;
+const DELEGATION_T_PAR_EXP = 1_003_000;
+// Delegation signatures are verified against the delegating principal's KeySet.
+// issuer = parent.audience = "parent-agent" (not the PDP issuer).
+const DELEGATION_TEST_KEYSET = {
+    issuer: "parent-agent",
+    version: "1",
+    keys: [{
+            kid: "2026-01",
+            alg: "Ed25519",
+            public_key: TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION,
+        }],
+};
+function makeParentAuth() {
+    return signAuthorizationEd25519({
+        auth_id: "f".repeat(64),
+        issuer: "oxdeai.policy-engine",
+        audience: "parent-agent",
+        intent_hash: "a".repeat(64),
+        state_hash: "b".repeat(64),
+        policy_id: "c".repeat(64),
+        decision: "ALLOW",
+        issued_at: DELEGATION_T_ISSUED,
+        expiry: DELEGATION_T_PAR_EXP,
+        kid: "2026-01",
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+}
+function makeSignedDelegationBase(parent) {
+    return createDelegation(parent, {
+        delegatee: "child-agent",
+        scope: { tools: ["provision_gpu"] },
+        expiry: DELEGATION_T_DEL_EXP,
+        kid: "2026-01",
+        delegationId: "d1d1d1d1-0000-0000-0000-c0nf0rm4nce",
+        issuedAt: DELEGATION_T_ISSUED,
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+}
+function parseDelegationScope(input) {
+    if (input === undefined || input === null)
+        return {};
+    const r = asRecord(input);
+    const scope = {};
+    if (r.tools !== undefined)
+        scope.tools = r.tools;
+    if (r.max_amount !== undefined)
+        scope.max_amount = BigInt(String(r.max_amount));
+    if (r.max_actions !== undefined)
+        scope.max_actions = Number(r.max_actions);
+    if (r.max_depth !== undefined)
+        scope.max_depth = Number(r.max_depth);
+    return scope;
+}
+function parseDelegationInput(input) {
+    const r = asRecord(input);
+    return {
+        delegation_id: String(r.delegation_id),
+        issuer: String(r.issuer),
+        audience: String(r.audience),
+        parent_auth_hash: String(r.parent_auth_hash),
+        delegator: String(r.delegator),
+        delegatee: String(r.delegatee),
+        scope: parseDelegationScope(r.scope),
+        policy_id: String(r.policy_id),
+        issued_at: Number(r.issued_at),
+        expiry: Number(r.expiry),
+        alg: "Ed25519",
+        kid: String(r.kid),
+        signature: String(r.signature),
+    };
+}
+function validateDelegationParentHashVectors(ctx) {
+    const file = loadJson("delegation-parent-hash.json");
+    const seen = {};
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const input = asRecord(v.input);
+        const parent = asRecord(input.parent);
+        const hash = hexSha256Utf8(canonicalJson(parent));
+        const expected = String(asRecord(v.expected).parent_auth_hash);
+        eq(ctx, `${id} parent_auth_hash`, hash, expected);
+        seen[id] = hash;
+        if (v.invariant) {
+            const inv = String(v.invariant);
+            if (inv.startsWith("equals ")) {
+                const refId = inv.slice("equals ".length);
+                if (refId in seen) {
+                    eq(ctx, `${id} invariant`, hash, seen[refId]);
+                }
+            }
+        }
+    }
+}
+function validateDelegationVerificationVectors(ctx) {
+    const file = loadJson("delegation-verification.json");
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const input = asRecord(v.input);
+        const delegation = parseDelegationInput(input.delegation);
+        const optsRaw = input.opts ? asRecord(input.opts) : {};
+        const opts = {};
+        if (optsRaw.now !== undefined)
+            opts.now = Number(optsRaw.now);
+        if (optsRaw.expectedDelegatee !== undefined)
+            opts.expectedDelegatee = String(optsRaw.expectedDelegatee);
+        if (optsRaw.expectedPolicyId !== undefined)
+            opts.expectedPolicyId = String(optsRaw.expectedPolicyId);
+        if (optsRaw.requireSignatureVerification !== undefined)
+            opts.requireSignatureVerification = Boolean(optsRaw.requireSignatureVerification);
+        if (optsRaw.consumedDelegationIds !== undefined)
+            opts.consumedDelegationIds = optsRaw.consumedDelegationIds;
+        if (optsRaw.parentScope !== undefined)
+            opts.parentScope = parseDelegationScope(optsRaw.parentScope);
+        const got = verifyDelegation(delegation, opts);
+        const expected = asRecord(v.expected);
+        eq(ctx, `${id} status`, got.status, String(expected.status));
+        eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
+    }
+}
+function buildDelegationChainCases() {
+    const parent = makeParentAuth();
+    const delegation = makeSignedDelegationBase(parent);
+    const opts = { now: DELEGATION_T_NOW };
+    // valid
+    const valid = verifyDelegationChain(delegation, parent, opts);
+    // parent-hash-mismatch: different parent with same audience/policy so only hash differs
+    const otherParent = signAuthorizationEd25519({
+        auth_id: "e".repeat(64), // different → different hash
+        issuer: "oxdeai.policy-engine",
+        audience: "parent-agent", // same → delegator check passes
+        intent_hash: "a".repeat(64),
+        state_hash: "b".repeat(64),
+        policy_id: "c".repeat(64), // same → policy check passes
+        decision: "ALLOW",
+        issued_at: DELEGATION_T_ISSUED,
+        expiry: DELEGATION_T_PAR_EXP,
+        kid: "2026-01",
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+    const hashMismatch = verifyDelegationChain(delegation, otherParent, opts);
+    // delegator-mismatch: tamper delegator field after signing (chain check catches before sig)
+    const delegatorMismatch = verifyDelegationChain({ ...delegation, delegator: "wrong-agent" }, parent, opts);
+    // parent-expired: now === parent.expiry → DELEGATION_PARENT_EXPIRED
+    const parentExpired = verifyDelegationChain(delegation, parent, { now: DELEGATION_T_PAR_EXP });
+    // expiry-exceeds-parent: delegation.expiry > parent.expiry
+    const exceedsDelegation = createDelegation(parent, {
+        delegatee: "child-agent",
+        scope: {},
+        expiry: DELEGATION_T_PAR_EXP + 1,
+        kid: "2026-01",
+        issuedAt: DELEGATION_T_ISSUED,
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+    const expiryExceeds = verifyDelegationChain(exceedsDelegation, parent, opts);
+    // multi-hop: delegation passed as its own parent (has delegation_id field)
+    const multiHop = verifyDelegationChain(delegation, delegation, opts);
+    // policy-id-mismatch: tamper policy_id after signing (chain check catches before sig)
+    const policyMismatch = verifyDelegationChain({ ...delegation, policy_id: "d".repeat(64) }, parent, opts);
+    return [valid, hashMismatch, delegatorMismatch, parentExpired, expiryExceeds, multiHop, policyMismatch];
+}
+function validateDelegationChainVectors(ctx) {
+    const file = loadJson("delegation-chain-verification.json");
+    const actual = buildDelegationChainCases();
+    for (let i = 0; i < file.vectors.length; i++) {
+        const id = String(file.vectors[i].id);
+        const expected = asRecord(file.vectors[i].expected);
+        const got = actual[i];
+        eq(ctx, `${id} status`, got.status, String(expected.status));
+        eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
+    }
+}
+function buildDelegationSignatureCases() {
+    const parent = makeParentAuth();
+    const delegation = makeSignedDelegationBase(parent);
+    const chainOpts = {
+        now: DELEGATION_T_NOW,
+        trustedKeySets: DELEGATION_TEST_KEYSET,
+        requireSignatureVerification: true,
+    };
+    // valid
+    const valid = verifyDelegationChain(delegation, parent, chainOpts);
+    // tampered-signature: corrupt last bytes
+    const tamperedSig = verifyDelegationChain({ ...delegation, signature: delegation.signature.slice(0, -4) + "AAAA" }, parent, chainOpts);
+    // wrong-kid: key not found in trustedKeySets
+    const wrongKid = verifyDelegationChain({ ...delegation, kid: "unknown-kid" }, parent, chainOpts);
+    // tampered-field: mutate delegatee after signing → sig covers original payload
+    const tamperedField = verifyDelegationChain({ ...delegation, delegatee: "evil-agent" }, parent, chainOpts);
+    // expired: correctly signed but expiry already past
+    const expiredDelegation = createDelegation(parent, {
+        delegatee: "child-agent",
+        scope: {},
+        expiry: DELEGATION_T_NOW - 1,
+        kid: "2026-01",
+        issuedAt: DELEGATION_T_ISSUED,
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+    const expired = verifyDelegationChain(expiredDelegation, parent, chainOpts);
+    return [valid, tamperedSig, wrongKid, tamperedField, expired];
+}
+function validateDelegationSignatureVectors(ctx) {
+    const file = loadJson("delegation-signature-verification.json");
+    const actual = buildDelegationSignatureCases();
+    for (let i = 0; i < file.vectors.length; i++) {
+        const id = String(file.vectors[i].id);
+        const expected = asRecord(file.vectors[i].expected);
+        const got = actual[i];
+        eq(ctx, `${id} status`, got.status, String(expected.status));
+        eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
+    }
+}
+/**
+ * Builds a signed AuthorizationV1 in Sift-compatible wire format:
+ *   - alg = "ed25519" (lowercase, nested signature object)
+ *   - expires_at (not expiry)
+ *   - base64url-encoded signature bytes
+ *   - signing preimage: canonicalJson(unsigned) with no domain prefix
+ *
+ * The verifier accepts this via the ed25519 branch + verifyEd25519Raw fallback
+ * + base64url decoding in decodeSignatureBytes.
+ */
+function makeSiftWireFormatAuth(now = 1730000000) {
+    const unsigned = {
+        auth_id: "f".repeat(64),
+        issuer: "oxdeai.policy-engine",
+        audience: "merchant-gateway",
+        intent_hash: "a".repeat(64),
+        state_hash: "b".repeat(64),
+        policy_id: "c".repeat(64),
+        decision: "ALLOW",
+        issued_at: now,
+        expires_at: now + 60,
+        signature: { alg: "ed25519", kid: "2026-01" },
+    };
+    const preimage = Buffer.from(canonicalJson(unsigned), "utf8");
+    const sigBytes = nodeSign(null, preimage, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+    return {
+        ...unsigned,
+        signature: { alg: "ed25519", kid: "2026-01", sig: sigBytes.toString("base64url") },
+    };
+}
 function makeSignedAuthorizationBase(now = 1730000000) {
     return signAuthorizationEd25519({
         auth_id: "f".repeat(64),
@@ -313,7 +617,7 @@ function validateAuthorizationSignatureVectors(ctx, adapter) {
             consumedAuthIds: []
         };
         if (mode === "invalid-signature") {
-            auth = { ...auth, signature: `${auth.signature.slice(0, -2)}aa` };
+            auth = mutateSignature(auth);
         }
         else if (mode === "wrong-kid") {
             auth = { ...auth, kid: "unknown-kid" };
@@ -347,6 +651,15 @@ function validateAuthorizationSignatureVectors(ctx, adapter) {
         else if (mode === "unknown-alg") {
             auth = { ...auth, alg: "Unknown" };
         }
+        else if (mode === "sift-wire-format") {
+            auth = makeSiftWireFormatAuth();
+        }
+        else if (mode === "unsupported-alg-EdDSA") {
+            auth = { ...auth, alg: "EdDSA" };
+        }
+        else if (mode === "unsupported-alg-ED25519") {
+            auth = { ...auth, alg: "ED25519" };
+        }
         const got = adapter.verifyAuthorization(auth, opts);
         eq(ctx, `${id} status`, got.status, String(expected.status));
         eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
@@ -426,7 +739,7 @@ function buildEnvelopeCases(adapter) {
         tool_call: true,
         type: "EXECUTE"
     });
-    const out = engine.evaluatePure(intent, state);
+    const out = engine.evaluatePure(intent, state, intent.timestamp);
     if (out.decision !== "ALLOW")
         throw new Error("expected ALLOW for envelope cases");
     const events = engine.audit.snapshot();
@@ -460,11 +773,11 @@ function buildEnvelopeCases(adapter) {
     });
     const corrupt = new Uint8Array([1, 2, 3, 4, 5]);
     return [
-        adapter.verifyEnvelope(withCheckpoint, { expectedPolicyId: engine.computePolicyId(), mode: "strict" }),
+        adapter.verifyEnvelope(withCheckpoint, { expectedPolicyId: engine.computePolicyId(), mode: "strict", trustedKeySets: TEST_KEYSET }),
         adapter.verifyEnvelope(valid, { expectedPolicyId: engine.computePolicyId(), mode: "best-effort" }),
         adapter.verifyEnvelope(mismatched, { expectedPolicyId: engine.computePolicyId(), mode: "best-effort" }),
         adapter.verifyEnvelope(corrupt, { expectedPolicyId: engine.computePolicyId(), mode: "best-effort" }),
-        adapter.verifyEnvelope(valid, { expectedPolicyId: engine.computePolicyId(), mode: "strict" })
+        adapter.verifyEnvelope(valid, { expectedPolicyId: engine.computePolicyId(), mode: "strict", trustedKeySets: TEST_KEYSET })
     ];
 }
 function validateEnvelopeVectors(ctx, adapter) {
@@ -639,24 +952,403 @@ function validateAuditVerificationVectors(ctx, adapter) {
         eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
     }
 }
+// ── Profile C: Semantic State Verification ────────────────────────────────────
+//
+// Tests the guard's step 10 behavior: computeStateHash(liveState) must equal
+// authorization.state_hash. Two hash strategies are modelled:
+//   "core"     — sha256HexFromJson (standard OxDeAI; matches stateSnapshotHash for flat objects)
+//   "provider" — SHA-256 of "PROVIDER:" + canonicalJson (simulates an external provider
+//                algorithm such as siftCanonicalJsonHash; distinct from "core")
+//   "throws"   — always throws (models a broken or unavailable hash implementation)
+//
+// Encoding B vectors additionally exercise selected Profile-C semantics: Sift-compatible wire format
+// (alg="ed25519", expires_at, base64url sig) + live-state semantic verification.
+function profileCCoreHash(state) {
+    return sha256HexFromJson(state);
+}
+function profileCProviderHash(state) {
+    // Deterministic but distinct from coreHash — simulates an external provider algorithm.
+    return createHash("sha256")
+        .update("PROVIDER:" + canonicalJson(state), "utf8")
+        .digest("hex");
+}
+function profileCGetHashFn(strategy) {
+    if (strategy === "core")
+        return profileCCoreHash;
+    if (strategy === "provider")
+        return profileCProviderHash;
+    if (strategy === "throws")
+        return (_s) => { throw new Error("hash backend unavailable"); };
+    throw new Error(`unknown hash_strategy: ${strategy}`);
+}
+// ── Key lifecycle constants ───────────────────────────────────────────────────
+const KL_SIGNING_NOW = 1730000000;
+const KL_VERIFY_NOW = 1730000010;
+const KL_PAST = KL_SIGNING_NOW - 7200; // 2 h before signing
+const KL_FUTURE = KL_SIGNING_NOW + 7200; // 2 h after signing
+function makeKLAuth() {
+    return signAuthorizationEd25519({
+        auth_id: "e".repeat(64),
+        issuer: "kl.issuer",
+        audience: "kl.audience",
+        intent_hash: "a".repeat(64),
+        state_hash: "b".repeat(64),
+        policy_id: "c".repeat(64),
+        decision: "ALLOW",
+        issued_at: KL_SIGNING_NOW,
+        expiry: KL_SIGNING_NOW + 300,
+        kid: "kl-key-001",
+    }, TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+}
+function makeKLKeyEntry(overrides = {}) {
+    return {
+        kid: "kl-key-001",
+        alg: "Ed25519",
+        public_key: TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION,
+        ...overrides,
+    };
+}
+function makeKLKeyset(entry) {
+    return { issuer: "kl.issuer", version: "1", keys: [entry] };
+}
+function klVerifyOpts(keyset) {
+    return {
+        now: KL_VERIFY_NOW,
+        expectedIssuer: "kl.issuer",
+        expectedAudience: "kl.audience",
+        expectedPolicyId: "c".repeat(64),
+        trustedKeySets: keyset,
+        requireSignatureVerification: true,
+        consumedAuthIds: [],
+    };
+}
+function validateKeyLifecycleVectors(ctx, adapter) {
+    const file = loadJson("key-lifecycle-verification.json");
+    const auth = makeKLAuth();
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const mode = String(v.mode);
+        const expected = asRecord(v.expected);
+        let keyset;
+        if (mode === "key-active") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "active" }));
+        }
+        else if (mode === "key-revoked") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "revoked" }));
+        }
+        else if (mode === "key-not-before-future") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "active", not_before: KL_FUTURE }));
+        }
+        else if (mode === "key-not-after-past") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "active", not_after: KL_PAST }));
+        }
+        else if (mode === "key-valid-window") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "active", not_before: KL_PAST, not_after: KL_FUTURE }));
+        }
+        else if (mode === "key-expired-window") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "active", not_before: KL_PAST - 3600, not_after: KL_PAST }));
+        }
+        else if (mode === "key-retired-within-window") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "retired", not_before: KL_PAST, not_after: KL_FUTURE }));
+        }
+        else if (mode === "key-retired-past-window") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "retired", not_after: KL_PAST }));
+        }
+        else if (mode === "key-revoked-valid-window") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ status: "revoked", not_before: KL_PAST, not_after: KL_FUTURE }));
+        }
+        else if (mode === "wrong-kid-known-issuer") {
+            keyset = makeKLKeyset(makeKLKeyEntry({ kid: "different-key-id", status: "active" }));
+        }
+        else {
+            fail(ctx, `${id}: unknown mode "${mode}"`);
+            continue;
+        }
+        const got = adapter.verifyAuthorization(auth, klVerifyOpts(keyset));
+        eq(ctx, `${id} status`, got.status, String(expected.status));
+        eq(ctx, `${id} violations`, got.violations, expected.violations ?? []);
+    }
+}
+function validateProfileCStateVerificationVectors(ctx, adapter) {
+    const file = loadJson("profile-c-state-verification.json");
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const mode = String(v.mode);
+        const expected = asRecord(v.expected);
+        const expectedStatus = String(expected.status);
+        // ── Pure state-hash comparison modes ─────────────────────────────────────
+        // These modes test the semantic comparison (step 10) in isolation.
+        // They do not involve a real AuthorizationV1 artifact — they model the
+        // guard's computeStateHash(liveState) == authorization.state_hash logic.
+        if (mode === "live-state-match" ||
+            mode === "live-state-mismatch" ||
+            mode === "hash-strategy-mismatch" ||
+            mode === "toctou-stale-state") {
+            const stateInput = v.state_input;
+            const liveStateInput = (v.live_state_input ?? v.state_input);
+            const signingStrategy = String((v.signing_strategy ?? v.hash_strategy) ?? "core");
+            const verifyStrategy = String((v.verify_strategy ?? v.hash_strategy) ?? "core");
+            const signingHashFn = profileCGetHashFn(signingStrategy);
+            const committedHash = signingHashFn(stateInput);
+            let liveHash;
+            let threw = false;
+            try {
+                liveHash = profileCGetHashFn(verifyStrategy)(liveStateInput);
+            }
+            catch {
+                threw = true;
+            }
+            if (threw) {
+                eq(ctx, `${id} outcome`, "compute-error", expectedStatus);
+            }
+            else if (liveHash === committedHash) {
+                eq(ctx, `${id} outcome`, "ok", expectedStatus);
+            }
+            else {
+                eq(ctx, `${id} outcome`, "state-hash-mismatch", expectedStatus);
+            }
+            continue;
+        }
+        // ── compute-throws mode ───────────────────────────────────────────────────
+        if (mode === "compute-throws") {
+            let threw = false;
+            try {
+                profileCGetHashFn("throws")(null);
+            }
+            catch {
+                threw = true;
+            }
+            eq(ctx, `${id} throws`, threw, true);
+            eq(ctx, `${id} outcome`, threw ? "compute-error" : "ok", expectedStatus);
+            continue;
+        }
+        // ── Encoding B modes ──────────────────────────────────────────────────────
+        // These consume a committed Sift-compatible (Encoding B) AuthorizationV1 artifact
+        // with state_hash = signingHashFn(state_input), verify the signature
+        // (exercising the ed25519/expires_at/base64url path), then simulate
+        // Profile C step 10: computeStateHash(live_state_input) == authorization.state_hash.
+        if (mode === "encoding-b-live-state-match" ||
+            mode === "encoding-b-live-state-mismatch" ||
+            mode === "encoding-b-hash-strategy-mismatch") {
+            const stateInput = v.state_input;
+            const liveStateInput = (v.live_state_input ?? v.state_input);
+            const signingStrategy = String((v.signing_strategy ?? v.hash_strategy) ?? "provider");
+            const verifyStrategy = String((v.verify_strategy ?? v.hash_strategy) ?? "provider");
+            const committedHash = profileCGetHashFn(signingStrategy)(stateInput);
+            // Consume the committed authority fixture preserved by the one-way projection.
+            // Do not synthesize/re-sign an artifact: Go and Python verify these same bytes.
+            const auth = v.auth;
+            const opts = asRecord(v.opts);
+            const trustedKey = asRecord(opts.trustedKey);
+            eq(ctx, `${id} committed state hash`, auth.state_hash, committedHash);
+            const sigResult = adapter.verifyAuthorization(auth, {
+                now: Number(opts.now),
+                expectedIssuer: "oxdeai.policy-engine",
+                expectedAudience: "merchant-gateway",
+                trustedKeySets: {
+                    issuer: "oxdeai.policy-engine",
+                    version: "1",
+                    keys: [{ kid: String(trustedKey.kid), alg: trustedKey.alg, public_key: String(trustedKey.public_key) }],
+                },
+                requireSignatureVerification: true,
+                consumedAuthIds: [],
+            });
+            if (sigResult.status !== "ok") {
+                fail(ctx, `${id} signature: expected ok, got ${sigResult.status} — ${JSON.stringify(sigResult.violations)}`);
+                continue;
+            }
+            pass(ctx, `${id} signature`);
+            // Step 2: semantic state verification (Profile C step 10).
+            let liveHash;
+            let threw = false;
+            try {
+                liveHash = profileCGetHashFn(verifyStrategy)(liveStateInput);
+            }
+            catch {
+                threw = true;
+            }
+            let outcome;
+            if (threw) {
+                outcome = "compute-error";
+            }
+            else if (liveHash === committedHash) {
+                outcome = "ok";
+            }
+            else {
+                outcome = "state-hash-mismatch";
+            }
+            eq(ctx, `${id} outcome`, outcome, expectedStatus);
+            continue;
+        }
+        fail(ctx, `${id}: unknown mode "${mode}"`);
+    }
+}
+// ── SignedKRLV1 verification ───────────────────────────────────────────────────
+const KRL_ISSUER = "krl.issuer";
+const KRL_KID = "krl-2026-01";
+const KRL_T_ISSUED = 1_730_000_000;
+const KRL_T_NOW = 1_730_000_010;
+const KRL_T_NOT_AFTER = 1_730_003_600;
+const KRL_TRUSTED_KEYSET = {
+    issuer: KRL_ISSUER,
+    version: "1",
+    keys: [{
+            kid: KRL_KID,
+            alg: "Ed25519",
+            public_key: KRL_TEST_ONLY_ED25519_PUBLIC_KEY_PEM_DO_NOT_USE_IN_PRODUCTION,
+        }],
+};
+function buildValidKrlBase() {
+    return {
+        version: "SignedKRLV1",
+        issuer: KRL_ISSUER,
+        krl_version: 1,
+        issued_at: KRL_T_ISSUED,
+        not_after: KRL_T_NOT_AFTER,
+        revoked_kids: ["kid-provider-1", "kid-provider-2"],
+    };
+}
+function signValidKrl(override) {
+    const base = { ...buildValidKrlBase(), ...override };
+    const envelope = {
+        ...base,
+        signature: { alg: "Ed25519", kid: KRL_KID, sig: "" },
+    };
+    const payload = signedKrlSigningPayload(envelope);
+    const sig = signEd25519(SIGNING_DOMAINS.KRL_V1, payload, KRL_TEST_ONLY_ED25519_PRIVATE_KEY_PEM_DO_NOT_USE_IN_PRODUCTION);
+    return { ...envelope, signature: { alg: "Ed25519", kid: KRL_KID, sig } };
+}
+function validateSignedKrlVectors(ctx) {
+    const file = loadJson("signed-krl-verification.json");
+    for (const v of file.vectors) {
+        const id = String(v.id);
+        const mode = String(v.mode);
+        const expected = asRecord(v.expected);
+        let result;
+        if (mode === "valid") {
+            // Valid KRL — signature verifies, not expired
+            const krl = signValidKrl();
+            result = verifySignedKrl(krl, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "invalid-signature") {
+            // Tamper last 4 base64 characters of the signature
+            const krl = signValidKrl();
+            const tampered = {
+                ...krl,
+                signature: { ...krl.signature, sig: krl.signature.sig.slice(0, -4) + "AAAA" },
+            };
+            result = verifySignedKrl(tampered, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "expired") {
+            // Verification time is one second past not_after
+            const krl = signValidKrl();
+            result = verifySignedKrl(krl, { now: KRL_T_NOT_AFTER + 1, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "malformed-revoked-kids") {
+            // revoked_kids is a string, not an array — structural malformation
+            const raw = {
+                ...buildValidKrlBase(),
+                revoked_kids: "not-an-array",
+                signature: { alg: "Ed25519", kid: KRL_KID, sig: "placeholder" },
+            };
+            result = verifySignedKrl(raw, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "duplicate-revoked-kids") {
+            // Valid signature but revoked_kids has duplicate entries
+            const krl = signValidKrl({ revoked_kids: ["kid-1", "kid-1"] });
+            result = verifySignedKrl(krl, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "unknown-signing-kid") {
+            // kid tampered after signing — not found in trusted key sets
+            const krl = signValidKrl();
+            const wrongKid = {
+                ...krl,
+                signature: { ...krl.signature, kid: "unknown-kid" },
+            };
+            result = verifySignedKrl(wrongKid, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "signing-key-inactive") {
+            // The correct kid exists in the trusted set but is marked revoked
+            const krl = signValidKrl();
+            const revokedKeyset = {
+                ...KRL_TRUSTED_KEYSET,
+                keys: [{ ...KRL_TRUSTED_KEYSET.keys[0], status: "revoked" }],
+            };
+            result = verifySignedKrl(krl, { now: KRL_T_NOW, trustedKeySets: revokedKeyset });
+        }
+        else if (mode === "unsupported-alg") {
+            // signature.alg is not "Ed25519" — structural KRL_UNSUPPORTED_ALG before sig check
+            const raw = {
+                ...buildValidKrlBase(),
+                signature: { alg: "HMAC-SHA256", kid: KRL_KID, sig: "placeholder" },
+            };
+            result = verifySignedKrl(raw, { now: KRL_T_NOW, trustedKeySets: KRL_TRUSTED_KEYSET });
+        }
+        else if (mode === "version-regression") {
+            // krl_version=1 but caller knows previous version was 5
+            const krl = signValidKrl(); // krl_version = 1
+            result = verifySignedKrl(krl, {
+                now: KRL_T_NOW,
+                trustedKeySets: KRL_TRUSTED_KEYSET,
+                previousKrlVersionByIssuer: { [KRL_ISSUER]: 5 },
+            });
+        }
+        else {
+            fail(ctx, `${id}: unknown mode "${mode}"`);
+            continue;
+        }
+        eq(ctx, `${id} status`, result.status, String(expected.status));
+        eq(ctx, `${id} violations`, result.violations, expected.violations ?? []);
+    }
+}
 function main() {
     const ctx = { failures: [], passed: 0 };
     const adapter = coreAdapter;
-    console.log(`Running conformance validation with ${adapter.name}`);
-    validateIntentHashVectors(ctx, adapter);
-    validateAuthorizationVectors(ctx, adapter);
-    validateAuthorizationVerificationVectors(ctx, adapter);
-    validateAuthorizationSignatureVectors(ctx, adapter);
-    validateSnapshotVectors(ctx, adapter);
-    validateAuditChainVectors(ctx, adapter);
-    validateAuditVerificationVectors(ctx, adapter);
-    validateEnvelopeVectors(ctx, adapter);
-    validateEnvelopeSignatureVectors(ctx, adapter);
+    if (!jsonOutput)
+        console.log(`Running conformance validation with ${adapter.name}`);
+    try {
+        validateIntentHashVectors(ctx, adapter);
+        validateAuthorizationVectors(ctx, adapter);
+        const trustedTime = runTrustedTimeConformance(loadJson("trusted-time.json"), line => {
+            const match = /^(PASS|FAIL) ([^ :]+)/.exec(line);
+            if (match)
+                recordCase(match[2], match[1] === "PASS");
+            if (!jsonOutput)
+                console.log(line);
+        });
+        ctx.passed += trustedTime.passed;
+        ctx.failures.push(...trustedTime.failures);
+        validateAuthorizationVerificationVectors(ctx, adapter);
+        validateAuthorizationSignatureVectors(ctx, adapter);
+        validateSnapshotVectors(ctx, adapter);
+        validateAuditChainVectors(ctx, adapter);
+        validateAuditVerificationVectors(ctx, adapter);
+        validateEnvelopeVectors(ctx, adapter);
+        validateEnvelopeSignatureVectors(ctx, adapter);
+        validateDelegationParentHashVectors(ctx);
+        validateDelegationVerificationVectors(ctx);
+        validateDelegationChainVectors(ctx);
+        validateDelegationSignatureVectors(ctx);
+        validateKeyLifecycleVectors(ctx, adapter);
+        validateClockSemanticsVectors(ctx, adapter);
+        validateProfileCStateVerificationVectors(ctx, adapter);
+        validateSignedKrlVectors(ctx);
+    }
+    catch (error) {
+        ctx.failures.push(error instanceof Error ? error.message : String(error));
+    }
+    const scope = evidenceScope({ consumer: "packages/conformance/src/validate.ts", runtime: "TypeScript", selections: [...exercised].map(([representation, data]) => {
+            const ids = data.vectors.map(v => String(v.id)).filter(id => caseResults.has(id));
+            return { representation, data, consumer: "packages/conformance/src/validate.ts", runtime: "TypeScript", caseIds: ids, passedCaseIds: ids.filter(id => caseResults.get(id)) };
+        }) });
+    console.log(JSON.stringify({ result: ctx.failures.length ? "FAIL" : "PASS", passed: ctx.passed, failures: ctx.failures, evidenceScope: scope }));
     if (ctx.failures.length > 0) {
         console.error(`\nConformance failed: ${ctx.failures.length} assertion(s)`);
-        process.exit(1);
+        process.exitCode = 1;
+        return;
     }
-    console.log(`\nConformance passed: ${ctx.passed} assertions`);
+    if (!jsonOutput)
+        console.log(`\nConformance passed: ${ctx.passed} assertions (declared evidenceScope only)`);
 }
 main();
 //# sourceMappingURL=validate.js.map