project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/long-task-runner-freeze.js

@@ -1,41 +1,72 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { computeRawExecutionIdentity } from "./long-task-check-execution-policy.js";
-import { assertRepositoryPattern, classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
+import { assertRepositoryPattern, classifyRepositoryPatternOverlap, matchesRepoPattern, normalizeRepositoryFile, proveRepositoryPatternSubset, } from "./long-task-paths.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { nearestRunnerFile, npmCliPath, npxCliPath, } from "./long-task-runner-files.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
 import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
 import { freezeLocalVerifierDependencyClosure, packageScriptVerifierRoots, } from "./long-task-verifier-dependency-closure.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations) {
+import { compileObservationAuthorityPlan } from "./long-task-observation-authority.js";
+import { compileProcessRuntimeClosure } from "./long-task-process-runtime-closure.js";
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations, productionBindings, productionOwnerPaths, sourceBackedExecutionTarget, protectedAuthorityPaths = []) {
     const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
     const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
+    const protectedAuthorityFiles = protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `${check.key}.protected_authority_paths[${index}]`));
     for (const [index, pattern] of check.input_paths.entries()) {
         const normalized = assertRepositoryPattern(repository, pattern, `${check.key}.input_paths[${index}]`);
         if (!baseline.files.some((file) => matchesRepoPattern(file.path, normalized)) &&
+            !protectedAuthorityFiles.some((file) => matchesRepoPattern(file, normalized)) &&
             !expectedOutputs.some((output) => classifyRepositoryPatternOverlap(output, normalized).status ===
-                "proven_overlap"))
+                "proven_overlap") &&
+            !plannedBindingMayProvideInput(productionBindings, normalized))
             throw new Error(`input_path_not_found:${check.key}:${pattern}`);
     }
     check.artifact_globs.forEach((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.artifact_globs[${index}]`));
     const cwd = resolveInsideRepository(repository, check.runner.cwd, `${check.key}.cwd`);
     if (!(await stat(cwd).catch(() => null))?.isDirectory())
         throw new Error(`runner_cwd_not_found:${check.key}:${check.runner.cwd}`);
-    const target = await resolvedRunnerTarget(check, repository, cwd);
-    const verificationInputHashes = await freezeVerificationInputs(check, repository, baseline, cwd, target);
+    const target = await resolvedRunnerTarget(check, repository, cwd, executionTarget, productionBindings, sourceBackedExecutionTarget);
+    const verificationInputHashes = await freezeVerificationInputs(check, repository, baseline, cwd, target, executionTarget);
     validateSemanticFactOracleInputs(check.key, semanticFactExpectations, verificationInputHashes);
+    const runner = await freezeRunner(check, repository, cwd, target, verificationInputHashes);
+    const observationAuthorities = compileObservationAuthorityPlan({
+        check,
+        outcome_key: outcomeKey,
+        runner,
+        execution_target: executionTarget,
+        design_targets: designConformanceTargets,
+        semantic_fact_expectations: semanticFactExpectations,
+        production_bindings: productionBindings,
+        production_owner_paths: productionOwnerPaths,
+        source_backed_execution_target: sourceBackedExecutionTarget,
+        workspace_manifest: baseline,
+        protected_authority_paths: protectedAuthorityPaths,
+    });
+    const processRuntimeClosure = compileProcessRuntimeClosure({
+        check,
+        runner,
+        execution_target: executionTarget,
+        observation_authorities: observationAuthorities,
+        production_bindings: productionBindings,
+        production_owner_paths: productionOwnerPaths,
+        source_backed_execution_target: sourceBackedExecutionTarget,
+        protected_authority_paths: protectedAuthorityPaths,
+    });
     const compiled = {
         ...check,
         internal_id: `${prefix}.${check.key}`,
         outcome_key: outcomeKey,
         evidence_adapter: evidenceAdapterForRunner(check.runner.type),
-        runner: await freezeRunner(check, repository, cwd, target, verificationInputHashes),
+        runner,
         verification_input_hashes: verificationInputHashes,
         execution_target_definition: executionTarget,
         known_execution_targets: knownExecutionTargets,
         design_conformance_targets: designConformanceTargets,
         semantic_fact_expectations: semanticFactExpectations,
+        observation_authorities: observationAuthorities,
+        process_runtime_closure: processRuntimeClosure,
     };
     return {
         ...compiled,
@@ -54,7 +85,7 @@ function validateSemanticFactOracleInputs(checkKey, expectations, verificationIn
             throw new Error(`semantic_fact_oracle_verification_input_mismatch:${checkKey}:${oracle.key}:${oracle.identity}`);
     }
 }
-async function resolvedRunnerTarget(check, repository, cwd) {
+async function resolvedRunnerTarget(check, repository, cwd, executionTarget, productionBindings, sourceBackedExecutionTarget) {
     if (check.runner.type === "package_script") {
         const packageFile = await nearestRunnerFile(cwd, repository, "package.json");
         if (!packageFile)
@@ -62,12 +93,50 @@ async function resolvedRunnerTarget(check, repository, cwd) {
         return assertProtectedRepositoryFile(repository, packageFile, `${check.key}.package_json`);
     }
     const target = resolveInsideRepository(cwd, check.runner.target, `${check.key}.target`);
-    if (!(await stat(target).catch(() => null))?.isFile())
+    const targetInfo = await stat(target).catch(() => null);
+    if (!targetInfo?.isFile()) {
+        const relativeTarget = repoRelative(repository, target);
+        if (!targetInfo &&
+            plannedDirectProductRoot({
+                check,
+                executionTarget,
+                productionBindings,
+                sourceBackedExecutionTarget,
+                relativeTarget,
+            }))
+            return target;
         throw new Error(`${check.runner.type}_path_not_found:${check.key}:${check.runner.target}`);
+    }
     const protectedTarget = await assertProtectedRepositoryFile(repository, target, `${check.key}.runner_target`);
     repoRelative(repository, protectedTarget);
     return protectedTarget;
 }
+function plannedBindingMayProvideInput(bindings, inputPattern) {
+    return bindings.some((scoped) => scoped.binding.existence === "planned" &&
+        scoped.binding.carrier_paths.some((carrier) => isExactRepositoryFile(carrier, `${scoped.binding_ref}.carrier`) &&
+            proveRepositoryPatternSubset(carrier, inputPattern).status ===
+                "proven_subset"));
+}
+function plannedDirectProductRoot(input) {
+    return (input.check.runner.type === "project_binary" &&
+        input.check.execution_target.entrypoint === "root" &&
+        input.executionTarget.role === "product" &&
+        input.executionTarget.runtime_family === "process" &&
+        input.sourceBackedExecutionTarget?.target_ref ===
+            input.executionTarget.key &&
+        input.relativeTarget === input.executionTarget.root_entrypoint &&
+        input.productionBindings.some((scoped) => scoped.binding.existence === "planned" &&
+            scoped.binding.carrier_paths.some((carrier) => isExactRepositoryFile(carrier, `${scoped.binding_ref}.carrier`) &&
+                carrier === input.relativeTarget)));
+}
+function isExactRepositoryFile(value, label) {
+    try {
+        return normalizeRepositoryFile(value, label) === value;
+    }
+    catch {
+        return false;
+    }
+}
 async function freezeRunner(check, repository, cwd, target, verificationInputHashes) {
     const runner = check.runner;
     if (runner.argv.some((value) => value.includes("\0")))
@@ -135,7 +204,7 @@ async function freezeRunner(check, repository, cwd, target, verificationInputHas
         })),
     };
 }
-async function freezeVerificationInputs(check, repository, manifest, cwd, target) {
+async function freezeVerificationInputs(check, repository, manifest, cwd, target, executionTarget) {
     const result = {};
     for (const [index, source] of check.verification_inputs.entries()) {
         const pattern = assertRepositoryPattern(repository, source, `${check.key}.verification_inputs[${index}]`);
@@ -147,31 +216,42 @@ async function freezeVerificationInputs(check, repository, manifest, cwd, target
             result[file.path] = sha256Hex(await readFile(protectedFile));
         }
     }
-    const automatic = new Set([repoRelative(repository, target)]);
-    const packageFile = await nearestRunnerFile(cwd, repository, "package.json");
-    if (packageFile)
-        automatic.add(repoRelative(repository, packageFile));
-    for (const name of [
-        "package-lock.json",
-        "npm-shrinkwrap.json",
-        "pnpm-lock.yaml",
-        "yarn.lock",
-    ]) {
-        const file = await nearestRunnerFile(cwd, repository, name);
-        if (file)
-            automatic.add(repoRelative(repository, file));
-    }
-    if (check.runner.type === "playwright_test")
+    const directProductRoot = check.runner.type === "project_binary" &&
+        executionTarget.role === "product" &&
+        executionTarget.runtime_family === "process" &&
+        check.execution_target.entrypoint === "root";
+    const automatic = new Set(directProductRoot ? [] : [repoRelative(repository, target)]);
+    if (!directProductRoot) {
+        const packageFile = await nearestRunnerFile(cwd, repository, "package.json");
+        if (packageFile)
+            automatic.add(repoRelative(repository, packageFile));
         for (const name of [
-            "playwright.config.ts",
-            "playwright.config.js",
-            "playwright.config.mjs",
-            "playwright.config.cjs",
+            "package-lock.json",
+            "npm-shrinkwrap.json",
+            "pnpm-lock.yaml",
+            "yarn.lock",
         ]) {
             const file = await nearestRunnerFile(cwd, repository, name);
             if (file)
                 automatic.add(repoRelative(repository, file));
         }
+    }
+    if (check.runner.type === "playwright_test")
+        if (playwrightConfigArgument(check.runner.argv)) {
+            const file = resolveInsideRepository(cwd, playwrightConfigArgument(check.runner.argv), `${check.key}.playwright_config`);
+            automatic.add(repoRelative(repository, file));
+        }
+        else
+            for (const name of [
+                "playwright.config.ts",
+                "playwright.config.js",
+                "playwright.config.mjs",
+                "playwright.config.cjs",
+            ]) {
+                const file = await nearestRunnerFile(cwd, repository, name);
+                if (file)
+                    automatic.add(repoRelative(repository, file));
+            }
     for (const relative of automatic) {
         const file = manifest.files.find((candidate) => candidate.path === relative);
         if (!file)
@@ -196,6 +276,28 @@ async function freezeVerificationInputs(check, repository, manifest, cwd, target
     ]));
     return sortRecord(result);
 }
+export function playwrightConfigArgument(argv) {
+    const values = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === "--config") {
+            const next = argv[index + 1];
+            if (!next || next.startsWith("-"))
+                throw new Error("playwright_config_argument_missing");
+            values.push(next);
+            index += 1;
+        }
+        else if (value.startsWith("--config=")) {
+            const config = value.slice("--config=".length);
+            if (!config)
+                throw new Error("playwright_config_argument_missing");
+            values.push(config);
+        }
+    }
+    if (values.length > 1)
+        throw new Error("playwright_config_argument_ambiguous");
+    return values[0] ?? null;
+}
 function sortRecord(value) {
     return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
 }

package/dist/lib/long-task-runtime-types.d.ts

@@ -8,6 +8,7 @@ import type { EffectiveRiskLevel, RiskFactName } from "./long-task-risk-types.js
 import type { SemanticFactExpectationV2 } from "./semantic-fact-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
+import type { JsonPointerExactObservation } from "./long-task-json-pointer-observation.js";
 export interface FrozenRunnerV2 extends DeliveryRunnerV2 {
     executable: string;
     executable_argv_prefix: string[];
@@ -18,6 +19,74 @@ export interface FrozenRunnerV2 extends DeliveryRunnerV2 {
     package_script: string | null;
     execution_identity: string;
 }
+export type CompiledObservationAuthorityKindV2 = "package_static_json_exact" | "package_process_json_exact" | "external_confirmation";
+export type CompiledObservationActualProjectionV2 = "raw_exact" | "presence_boolean" | "truthy_boolean" | "falsy_boolean";
+export interface CompiledObservationAuthorityV2 {
+    obligation_ref: string;
+    fact_ref: string | null;
+    assertion_ref: string;
+    claim_refs: string[];
+    target_ref: string;
+    proof_surface: ProofSurface;
+    method: string;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    authority: CompiledObservationAuthorityKindV2;
+    expected_identity: string;
+    expected_value_sha256: string;
+    actual_projection: CompiledObservationActualProjectionV2;
+    observation_identity: string;
+    comparison: {
+        comparator: string;
+        mode: string;
+        parameters_sha256: string | null;
+        tolerance_sha256: string | null;
+        mask_sha256: string | null;
+    };
+    locator_policy: {
+        kind: "fixed_json_pointer";
+        value: string;
+    };
+    carrier_refs: Array<{
+        binding_ref: string;
+        carrier_paths: string[];
+    }>;
+    runtime_requirements: {
+        runtime_family: ExecutionTargetV2["runtime_family"];
+        target_role: ExecutionTargetV2["role"];
+        entrypoint: DeliveryCheckV2["execution_target"]["entrypoint"];
+        runner_type: DeliveryRunnerV2["type"];
+        resolved_runner_target: string;
+        declared_root_entrypoint: string;
+        resolved_runner_argv: string[];
+        declared_root_argv: string[] | null;
+        effect: DeliveryRunnerV2["effect"];
+        direct_root_match: boolean;
+    };
+}
+export interface SourceBackedExecutionTargetV2 {
+    target_ref: string;
+    canonical_target_ref: string;
+    source_claim_key: string;
+    source_item_key: string;
+    source_path: string;
+    source_text_sha256: string;
+    target_identity: string;
+}
+export interface CompiledProcessRuntimeClosureV2 {
+    target_ref: string;
+    source_target: SourceBackedExecutionTargetV2;
+    root_target: string;
+    root_argv_files: string[];
+    production_carrier_files: string[];
+    allowed_runtime_files: string[];
+    production_binding_refs: string[];
+    forbidden_role_matches: Array<{
+        path: string;
+        role: "expected_authority" | "verification" | "evidence";
+        pattern: string;
+    }>;
+    closure_identity: string;
+}
 export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     internal_id: string;
     outcome_key: string | null;
@@ -29,6 +98,8 @@ export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     known_execution_targets: ExecutionTargetV2[];
     design_conformance_targets: CompiledDesignTargetV2[];
     semantic_fact_expectations: SemanticFactExpectationV2[];
+    observation_authorities: CompiledObservationAuthorityV2[];
+    process_runtime_closure: CompiledProcessRuntimeClosureV2 | null;
 }
 export interface ProductClaimV2 {
     id: string;
@@ -160,6 +231,46 @@ export interface RawCommandExecutionV2 {
     attempts: number;
     duration_ms: number;
     error: string | null;
+    package_observations?: PackageObservationValueV2[];
+    host_execution_attestation?: HostExecutionAttestationV2 | null;
+}
+export interface PackageObservationValueV2 {
+    authority: Exclude<CompiledObservationAuthorityKindV2, "external_confirmation">;
+    observation_identity: string;
+    assertion_ref: string;
+    obligation_ref: string;
+    method: string;
+    raw_value: unknown;
+    observation: JsonPointerExactObservation | null;
+    reason: string | null;
+}
+export interface PackageProcessObservationV1 {
+    schema_version: "ty-context-product-observation-v1";
+    artifact_sha256: string;
+    observations: Record<string, unknown>;
+    value_sha256_by_identity: Record<string, string>;
+    package_observations: PackageObservationValueV2[];
+}
+export interface HostExecutionAttestationV2 {
+    raw_execution_identity: string;
+    executable_path: string;
+    declared_root_entrypoint: string;
+    actual_argv: string[];
+    declared_root_argv: string[];
+    direct_root_match: boolean;
+    pid: number;
+    started_at: string;
+    completed_at: string;
+    exit_code: number;
+    snapshot_sha256: string;
+    observation_execution_nonce: string;
+    observation_artifact_sha256: string;
+    process_runtime_closure_identity: string;
+}
+export interface CheckRunnerExecutionContextV2 {
+    snapshot_sha256?: string;
+    observation_authorities?: readonly CompiledObservationAuthorityV2[];
+    process_runtime_closure_identity?: string;
 }
 export interface CheckExecutionResultV2 {
     internal_id: string;

package/dist/lib/long-task-scoped-binding.d.ts

@@ -0,0 +1,13 @@
+import type { DeliveryBindingV2 } from "./long-task-delivery-types.js";
+/**
+ * Ephemeral compiler identity for one authored Outcome-local Binding.
+ * Authored Contracts keep their existing local Binding keys.
+ */
+export interface ScopedDeliveryBindingV2 {
+    outcome_key: string;
+    local_key: string;
+    binding_ref: string;
+    binding: DeliveryBindingV2;
+}
+export declare function scopeDeliveryBinding(outcomeKey: string, binding: DeliveryBindingV2): ScopedDeliveryBindingV2;
+export declare function scopeDeliveryBindings(outcomeKey: string, bindings: readonly DeliveryBindingV2[]): ScopedDeliveryBindingV2[];

package/dist/lib/long-task-scoped-binding.js

@@ -0,0 +1,11 @@
+export function scopeDeliveryBinding(outcomeKey, binding) {
+    return {
+        outcome_key: outcomeKey,
+        local_key: binding.key,
+        binding_ref: `${outcomeKey}.${binding.key}`,
+        binding,
+    };
+}
+export function scopeDeliveryBindings(outcomeKey, bindings) {
+    return bindings.map((binding) => scopeDeliveryBinding(outcomeKey, binding));
+}

package/dist/lib/long-task-semantic-contract-types.d.ts

@@ -22,6 +22,7 @@ export interface ExecutionTargetV2 {
     role: "product" | "support" | "observer";
     runtime_family: ExecutionTargetRuntimeFamilyV2;
     root_entrypoint: string;
+    root_argv?: string[];
     capabilities: ExecutionTargetCapabilityV2[];
 }
 export interface DeliveryStageV2 {
@@ -42,7 +43,7 @@ export interface ClaimApplicabilityV2 {
     given_refs: string[];
     when_refs: string[];
 }
-export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "semantic_fact" | "target_runtime" | "input_variation";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "semantic_fact" | "target_runtime" | "input_variation";
 export interface CheckExecutionTargetV2 {
     target_ref: string;
     entrypoint: "root" | "internal";

package/dist/lib/long-task-semantic-fact-binding-types.d.ts

@@ -8,11 +8,13 @@ export interface SemanticFactManifestRefV2 {
 }
 export interface SemanticFactBindingV2 {
     fact_ref: string;
+    fact_revision_digest?: string;
     claim_ref: string;
     applicability_ref: string;
 }
 export type SemanticFactProofBindingV2 = {
     proof_ref: string;
+    obligation_revision_digest?: string;
     fact_ref: string;
     method: string;
     proof_surface: ProofSurface;
@@ -22,6 +24,7 @@ export type SemanticFactProofBindingV2 = {
     assertion_ref: string;
 } | {
     proof_ref: string;
+    obligation_revision_digest?: string;
     fact_ref: string;
     method: string;
     proof_surface: ProofSurface;
@@ -37,6 +40,11 @@ export interface SemanticFactOutcomeBindingsV2 {
 export interface SemanticFactExpectationV2 {
     manifest_ref: string;
     manifest_sha256: string;
+    fact_key: string;
+    fact_revision_digest: string;
+    obligation_key: string;
+    obligation_revision_digest: string;
+    revision_identity_required: boolean;
     fact_ref: string;
     proof_ref: string;
     method: string;

package/dist/lib/long-task-semantic-fact-closure.js

@@ -14,7 +14,10 @@ export async function validateLongTaskSemanticFactClosure(contract, repository,
     await validateSemanticFactInputInventory(repository, sourceItems, contextFiles, manifest, designOwnedSourceItems);
     validateSemanticFactBasisClosure(manifest, sourceItems);
     await validateSemanticFactLocatedValues(repository, manifest, sourceItems);
-    const expectations = validateSemanticFactContractProjection(contract, manifest, index);
+    const expectations = validateSemanticFactContractProjection(contract, manifest, index, new Map(parsed.fact_revisions.map((item) => [item.key, item.revision_digest])), new Map(parsed.obligation_revisions.map((item) => [
+        item.key,
+        item.revision_digest,
+    ])), parsed.carrier === "compact_v1");
     return {
         manifest,
         manifest_sha256: parsed.sha256,

package/dist/lib/long-task-semantic-fact-contract-closure.d.ts

@@ -1,4 +1,4 @@
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
 import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactContractProjection(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1): Map<string, SemanticFactExpectationV2[]>;
+export declare function validateSemanticFactContractProjection(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, sourceRequiresRevisions: boolean): Map<string, SemanticFactExpectationV2[]>;

package/dist/lib/long-task-semantic-fact-contract-closure.js

@@ -1,7 +1,7 @@
 import { validateSemanticFactOutcomeBindings } from "./long-task-semantic-fact-contract-facts.js";
 import { validateSemanticFactProofBindings } from "./long-task-semantic-fact-contract-proofs.js";
 import { assertSameSemanticFactClosureSet, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactContractProjection(contract, manifest, index) {
+export function validateSemanticFactContractProjection(contract, manifest, index, factRevisions, obligationRevisions, sourceRequiresRevisions) {
     const expectations = new Map();
     const allFactBindings = [];
     const allProofBindings = [];
@@ -10,15 +10,27 @@ export function validateSemanticFactContractProjection(contract, manifest, index
         const facts = manifest.facts.filter((item) => item.outcome_ref === outcome.key);
         const proofs = manifest.proof_obligations.filter((proof) => facts.some((fact) => fact.key === proof.fact_ref));
         const bindings = outcome.semantic_fact_bindings;
+        const revisionsRequired = sourceRequiresRevisions ||
+            bindings.facts.some((item) => item.fact_revision_digest !== undefined) ||
+            bindings.proofs.some((item) => item.obligation_revision_digest !== undefined);
         assertSameSemanticFactClosureSet(bindings.facts.map((item) => item.fact_ref), facts.map((item) => item.key), `contract_fact_set:${outcome.key}`);
+        if (revisionsRequired) {
+            assertSameSemanticFactClosureSet(bindings.facts.map((item) => revisionPair(item.fact_ref, item.fact_revision_digest, `contract_fact_revision:${outcome.key}`)), facts.map((item) => revisionPair(item.key, factRevisions.get(item.key), `source_fact_revision:${outcome.key}`)), `contract_fact_revision_set:${outcome.key}`);
+            assertSameSemanticFactClosureSet(bindings.proofs.map((item) => revisionPair(item.proof_ref, item.obligation_revision_digest, `contract_obligation_revision:${outcome.key}`)), proofs.map((item) => revisionPair(item.key, obligationRevisions.get(item.key), `source_obligation_revision:${outcome.key}`)), `contract_obligation_revision_set:${outcome.key}`);
+        }
         assertSameSemanticFactClosureSet(bindings.proofs.map((item) => item.proof_ref), proofs.map((item) => item.key), `contract_proof_set:${outcome.key}`);
-        uniqueSemanticFactClosureValues(bindings.proofs.map((item) => item.authority === "machine"
-            ? `${item.check_ref}\0${item.assertion_ref}`
-            : `external\0${item.confirmation_ref}`), `contract_proof_target:${outcome.key}`);
-        validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings);
-        validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings);
+        uniqueSemanticFactClosureValues(bindings.proofs
+            .filter((item) => item.authority === "machine")
+            .map((item) => `${item.check_ref}\0${item.assertion_ref}`), `contract_proof_target:${outcome.key}`);
+        validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired);
+        validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired);
     }
     assertSameSemanticFactClosureSet(allFactBindings, manifest.facts.map((item) => item.key), "contract_all_fact_set");
     assertSameSemanticFactClosureSet(allProofBindings, manifest.proof_obligations.map((item) => item.key), "contract_all_proof_set");
     return expectations;
 }
+function revisionPair(key, digest, label) {
+    if (!digest)
+        throw new Error(`semantic_fact_closure_invalid:${label}:${key}:missing`);
+    return `${key}\0${digest}`;
+}

package/dist/lib/long-task-semantic-fact-contract-facts.d.ts

@@ -1,4 +1,4 @@
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactOutcomeBindings(outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, allFactBindings: string[]): void;
+export declare function validateSemanticFactOutcomeBindings(outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, allFactBindings: string[], factRevisions: Map<string, string>, revisionsRequired: boolean): void;

package/dist/lib/long-task-semantic-fact-contract-facts.js

@@ -1,10 +1,13 @@
 import { semanticFactClosureInvalid, uniqueSemanticFactClosureValues, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings) {
+export function validateSemanticFactOutcomeBindings(outcome, manifest, index, allFactBindings, factRevisions, revisionsRequired) {
     uniqueSemanticFactClosureValues(outcome.semantic_fact_bindings.facts.map((item) => item.claim_ref), `contract_fact_claim:${outcome.key}`);
     const applicabilityRefs = new Set(outcome.applicability.map((item) => item.key));
     for (const binding of outcome.semantic_fact_bindings.facts) {
         const fact = index.fact_by_ref.get(binding.fact_ref);
         const expectedClaim = `semantic_fact.${binding.fact_ref}`;
+        if (revisionsRequired &&
+            binding.fact_revision_digest !== factRevisions.get(binding.fact_ref))
+            semanticFactClosureInvalid("contract_fact_revision_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.fact_revision_digest ?? "missing"}:${factRevisions.get(binding.fact_ref) ?? "missing"}`);
         if (binding.claim_ref !== expectedClaim)
             semanticFactClosureInvalid("contract_fact_claim_identity_mismatch", `${outcome.key}:${binding.fact_ref}:${binding.claim_ref}:${expectedClaim}`);
         if (!applicabilityRefs.has(binding.applicability_ref))

package/dist/lib/long-task-semantic-fact-contract-proofs.d.ts

@@ -1,4 +1,4 @@
 import type { DeliveryContractV2, ExecutionTargetV2 } from "./long-task-delivery-types.js";
 import type { SemanticFactManifestIndexV1 } from "./semantic-fact-policy.js";
 import type { SemanticFactExpectationV2, SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function validateSemanticFactProofBindings(contract: DeliveryContractV2, outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, targetByRef: Map<string, ExecutionTargetV2>, expectations: Map<string, SemanticFactExpectationV2[]>, allProofBindings: string[]): void;
+export declare function validateSemanticFactProofBindings(contract: DeliveryContractV2, outcome: DeliveryContractV2["outcomes"][number], manifest: SemanticFactManifestV1, index: SemanticFactManifestIndexV1, targetByRef: Map<string, ExecutionTargetV2>, expectations: Map<string, SemanticFactExpectationV2[]>, allProofBindings: string[], factRevisions: Map<string, string>, obligationRevisions: Map<string, string>, revisionsRequired: boolean): void;

package/dist/lib/long-task-semantic-fact-contract-proofs.js

@@ -1,16 +1,20 @@
 import { sameSemanticFactClosureSet, semanticFactClosureInvalid, } from "./long-task-semantic-fact-closure-primitives.js";
-export function validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings) {
+export function validateSemanticFactProofBindings(contract, outcome, manifest, index, targetByRef, expectations, allProofBindings, factRevisions, obligationRevisions, revisionsRequired) {
     for (const binding of outcome.semantic_fact_bindings.proofs) {
         const proof = index.proof_by_ref.get(binding.proof_ref);
         const factBinding = outcome.semantic_fact_bindings.facts.find((item) => item.fact_ref === binding.fact_ref);
         if (!factBinding)
             semanticFactClosureInvalid("contract_proof_fact_binding_missing", `${outcome.key}:${binding.proof_ref}:${binding.fact_ref}`);
+        if (revisionsRequired &&
+            binding.obligation_revision_digest !==
+                obligationRevisions.get(binding.proof_ref))
+            semanticFactClosureInvalid("contract_obligation_revision_mismatch", `${outcome.key}:${binding.proof_ref}:${binding.obligation_revision_digest ?? "missing"}:${obligationRevisions.get(binding.proof_ref) ?? "missing"}`);
         validateProofIdentity(outcome, proof, binding);
         validateObserverTargets(proof, binding, targetByRef);
         if (binding.authority === "external_confirmation")
             validateExternalProofProjection(contract, outcome, binding, factBinding.claim_ref);
         else
-            validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations);
+            validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations, factRevisions, obligationRevisions, revisionsRequired);
         allProofBindings.push(binding.proof_ref);
     }
 }
@@ -37,7 +41,7 @@ function validateExternalProofProjection(contract, outcome, binding, claimRef) {
     if (!confirmation.impact_claims.includes(fullClaim))
         semanticFactClosureInvalid("semantic_fact_confirmation_lineage_missing", `${binding.confirmation_ref}:${fullClaim}`);
 }
-function validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations) {
+function validateMachineProofProjection(contract, outcome, manifest, index, binding, proof, factBinding, expectations, factRevisions, obligationRevisions, revisionsRequired) {
     const check = outcome.acceptance.checks.find((item) => item.key === binding.check_ref);
     if (!check)
         semanticFactClosureInvalid("semantic_fact_check_unknown", `${outcome.key}:${binding.check_ref}`);
@@ -62,6 +66,11 @@ function validateMachineProofProjection(contract, outcome, manifest, index, bind
     rows.push({
         manifest_ref: manifest.key,
         manifest_sha256: contract.semantic_fact_manifest.sha256,
+        fact_key: fact.key,
+        fact_revision_digest: factRevisions.get(fact.key),
+        obligation_key: proof.key,
+        obligation_revision_digest: obligationRevisions.get(proof.key),
+        revision_identity_required: revisionsRequired,
         fact_ref: fact.key,
         proof_ref: proof.key,
         method: proof.method,

package/dist/lib/long-task-semantic-fact-evidence.d.ts

@@ -3,9 +3,13 @@ type SemanticRecord = Extract<EvidenceCapabilityRecordV2, {
     capability: "semantic_fact";
 }>;
 export declare function validateSemanticFactEvidence(check: CompiledCheckV2, record: SemanticRecord, artifactHashes: Record<string, string>): string | null;
-export declare function semanticFactComparisonResultIdentity(value: {
+type SemanticFactExactComparisonMaterial = {
     fact_ref: string;
     proof_ref: string;
+    fact_key?: string;
+    fact_revision_digest?: string;
+    obligation_key?: string;
+    obligation_revision_digest?: string;
     target_ref: string;
     actual_value_sha256: string;
     expected_value_sha256: string;
@@ -14,8 +18,8 @@ export declare function semanticFactComparisonResultIdentity(value: {
     parameters_sha256: string;
     tolerance_sha256: string | null;
     mask_sha256: string | null;
-    passed: boolean;
-}): string;
+};
+export declare function semanticFactComparisonResultIdentity(value: SemanticFactExactComparisonMaterial): string;
 export declare function validateDistinctSemanticFactEvidence(records: EvidenceCapabilityRecordV2[]): string | null;
-export declare const typed_semantic_fact_runtime_evidence = "fact_ref+actual+comparison+verdict+oracle+environment";
+export declare const typed_semantic_fact_runtime_evidence = "obligation_key+obligation_revision_digest->fact_key+fact_revision_digest+actual+comparison+verdict+oracle+environment";
 export {};