project-tiny-context-harness 0.8.10 → 0.8.12

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);
+        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

@@ -6,6 +6,10 @@ export declare function validateSemanticFactEvidence(check: CompiledCheckV2, rec
 export declare function semanticFactComparisonResultIdentity(value: {
     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;
@@ -17,5 +21,5 @@ export declare function semanticFactComparisonResultIdentity(value: {
     passed: boolean;
 }): 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 {};

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

@@ -38,6 +38,10 @@ function validateSemanticFactEvidenceAuthority(check, record, expected) {
         semanticFactComparisonResultIdentity({
             fact_ref: record.fact_ref,
             proof_ref: record.proof_ref,
+            fact_key: record.fact_key,
+            fact_revision_digest: record.fact_revision_digest,
+            obligation_key: record.obligation_key,
+            obligation_revision_digest: record.obligation_revision_digest,
             target_ref: record.target_ref,
             actual_value_sha256: record.actual_observation.value_sha256,
             expected_value_sha256: expected.expected.sha256,
@@ -67,7 +71,22 @@ function sameSemanticFactIdentity(record, expected) {
         record.method === expected.method &&
         record.subject_ref === expected.subject_ref &&
         record.condition_ref === expected.condition_ref &&
-        record.property_ref === expected.property_ref);
+        record.property_ref === expected.property_ref &&
+        sameSemanticFactRevisionIdentity(record, expected));
+}
+function sameSemanticFactRevisionIdentity(record, expected) {
+    const present = record.fact_key !== undefined ||
+        record.fact_revision_digest !== undefined ||
+        record.obligation_key !== undefined ||
+        record.obligation_revision_digest !== undefined;
+    if (!expected.revision_identity_required && !present)
+        return true;
+    return (record.fact_key === expected.fact_key &&
+        record.fact_key === record.fact_ref &&
+        record.fact_revision_digest === expected.fact_revision_digest &&
+        record.obligation_key === expected.obligation_key &&
+        record.obligation_key === record.proof_ref &&
+        record.obligation_revision_digest === expected.obligation_revision_digest);
 }
 function validSemanticFactRedaction(sensitivity, redaction) {
     return ((sensitivity === "plain" && redaction === null) ||
@@ -118,6 +137,10 @@ function validateSemanticFactObservers(record, expected, artifactHashes) {
             semanticFactComparisonResultIdentity({
                 fact_ref: record.fact_ref,
                 proof_ref: record.proof_ref,
+                fact_key: record.fact_key,
+                fact_revision_digest: record.fact_revision_digest,
+                obligation_key: record.obligation_key,
+                obligation_revision_digest: record.obligation_revision_digest,
                 target_ref: observer.target_ref,
                 actual_value_sha256: observer.value_sha256,
                 expected_value_sha256: expected.expected.sha256,
@@ -133,7 +156,25 @@ function validateSemanticFactObservers(record, expected, artifactHashes) {
     return null;
 }
 export function semanticFactComparisonResultIdentity(value) {
-    return sha256Hex(canonicalValueJson(value));
+    const revisionIdentityPresent = value.fact_key !== undefined ||
+        value.fact_revision_digest !== undefined ||
+        value.obligation_key !== undefined ||
+        value.obligation_revision_digest !== undefined;
+    return sha256Hex(canonicalValueJson(revisionIdentityPresent
+        ? value
+        : {
+            fact_ref: value.fact_ref,
+            proof_ref: value.proof_ref,
+            target_ref: value.target_ref,
+            actual_value_sha256: value.actual_value_sha256,
+            expected_value_sha256: value.expected_value_sha256,
+            comparator: value.comparator,
+            mode: value.mode,
+            parameters_sha256: value.parameters_sha256,
+            tolerance_sha256: value.tolerance_sha256,
+            mask_sha256: value.mask_sha256,
+            passed: value.passed,
+        }));
 }
 export function validateDistinctSemanticFactEvidence(records) {
     const observations = new Set();
@@ -142,7 +183,9 @@ export function validateDistinctSemanticFactEvidence(records) {
     for (const record of records) {
         if (record.capability !== "semantic_fact")
             continue;
-        const identity = `${record.fact_ref}\0${record.proof_ref}`;
+        const identity = record.obligation_key
+            ? `${record.obligation_key}\0${record.obligation_revision_digest}\0${record.fact_key}\0${record.fact_revision_digest}`
+            : `${record.fact_ref}\0${record.proof_ref}`;
         if (identities.has(identity))
             return "semantic_fact_result_duplicate";
         identities.add(identity);
@@ -162,4 +205,4 @@ function sameSet(left, right) {
         new Set(left).size === left.length &&
         left.every((item) => right.includes(item)));
 }
-export const typed_semantic_fact_runtime_evidence = "fact_ref+actual+comparison+verdict+oracle+environment";
+export const typed_semantic_fact_runtime_evidence = "obligation_key+obligation_revision_digest->fact_key+fact_revision_digest+actual+comparison+verdict+oracle+environment";

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

@@ -13,13 +13,14 @@ export function parseSemanticFactOutcomeBindings(value, label) {
         manifest_ref: semanticRef(row.manifest_ref, `${label}.manifest_ref`),
         facts: array(row.facts, `${label}.facts`).map((item, index) => {
             const itemLabel = `${label}.facts[${index}]`;
-            const entry = object(item, itemLabel, [
-                "fact_ref",
-                "claim_ref",
-                "applicability_ref",
-            ]);
+            const entry = object(item, itemLabel, ["fact_ref", "claim_ref", "applicability_ref"], ["fact_revision_digest"]);
             return {
                 fact_ref: semanticRef(entry.fact_ref, `${itemLabel}.fact_ref`),
+                ...(Object.hasOwn(entry, "fact_revision_digest")
+                    ? {
+                        fact_revision_digest: sha256(entry.fact_revision_digest, `${itemLabel}.fact_revision_digest`),
+                    }
+                    : {}),
                 claim_ref: semanticRef(entry.claim_ref, `${itemLabel}.claim_ref`),
                 applicability_ref: semanticRef(entry.applicability_ref, `${itemLabel}.applicability_ref`),
             };
@@ -33,7 +34,12 @@ export function parseSemanticFactOutcomeBindings(value, label) {
                 "proof_surface",
                 "evidence_capabilities",
                 "authority",
-            ], ["check_ref", "assertion_ref", "confirmation_ref"]);
+            ], [
+                "obligation_revision_digest",
+                "check_ref",
+                "assertion_ref",
+                "confirmation_ref",
+            ]);
             const authority = literal(preliminary.authority, ["machine", "external_confirmation"], `${itemLabel}.authority`);
             if (authority === "machine") {
                 requireOwned(preliminary, itemLabel, ["check_ref", "assertion_ref"]);
@@ -45,6 +51,11 @@ export function parseSemanticFactOutcomeBindings(value, label) {
             }
             const base = {
                 proof_ref: semanticRef(preliminary.proof_ref, `${itemLabel}.proof_ref`),
+                ...(Object.hasOwn(preliminary, "obligation_revision_digest")
+                    ? {
+                        obligation_revision_digest: sha256(preliminary.obligation_revision_digest, `${itemLabel}.obligation_revision_digest`),
+                    }
+                    : {}),
                 fact_ref: semanticRef(preliminary.fact_ref, `${itemLabel}.fact_ref`),
                 method: semanticRef(preliminary.method, `${itemLabel}.method`),
                 proof_surface: literal(preliminary.proof_surface, PROOF_SURFACES, `${itemLabel}.proof_surface`),

package/dist/lib/long-task-shape-primitives.d.ts

@@ -17,5 +17,5 @@ export declare function semanticRef(value: unknown, label: string): string;
 export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
 export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
 export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
-export declare const EVIDENCE_CAPABILITIES: readonly ["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 declare const EVIDENCE_CAPABILITIES: readonly ["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 declare function fail(label: string, message: string): never;

package/dist/lib/long-task-shape-primitives.js

@@ -106,6 +106,7 @@ export const EVIDENCE_CAPABILITIES = [
     "visual_render",
     "design_conformance",
     "design_method",
+    "design_symbolic_certificate",
     "semantic_fact",
     "target_runtime",
     "input_variation",

package/dist/lib/long-task-source-item-parser.d.ts

@@ -1,9 +1,9 @@
 import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
-import type { DesignResourceHandoffInputV1 } from "./design-resource-handoff-types.js";
+import type { DesignResourceHandoffInput } from "./design-resource-handoff-input-types.js";
 import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
 export interface ParsedSourceDocument {
     items: CompiledSourceItemV2[];
-    designResourceHandoff: DesignResourceHandoffInputV1 | null;
+    designResourceHandoff: DesignResourceHandoffInput | null;
     semanticFactManifest: SemanticFactManifestV1 | null;
 }
 export declare function parseSourceItems(sourcePath: string, content: string): CompiledSourceItemV2[];

package/dist/lib/long-task-source-item-parser.js

@@ -1,10 +1,12 @@
 import { parseDesignResourceHandoffInputShape } from "./design-resource-handoff-shape.js";
+import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
+import { parseSemanticFactCompactCarrierShape } from "./semantic-fact-compact-carrier.js";
 import { parseSemanticFactManifestShape } from "./semantic-fact-manifest-shape.js";
 import { assertNoOpenOwnedSection, assertOwnedSourceSectionsClosed, consumeBackgroundBoundary, consumeOwnedText, consumeSourceItemBoundary, } from "./long-task-source-owned-sections.js";
 import { formalBlockBody, forEachSourceLine } from "./source-line-scanner.js";
 import { parseStrictYaml } from "./strict-codec.js";
-const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-v1[ \t]*$/u;
-const SEMANTIC_FACT_START = /^\s*```yaml[ \t]+semantic-fact-manifest-v1[ \t]*$/u;
+const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-(v1|v2)[ \t]*$/u;
+const SEMANTIC_FACT_START = /^\s*```yaml[ \t]+(semantic-fact-manifest-v1|semantic-fact-compact-carrier-v1)[ \t]*$/u;
 const FORMAL_BLOCK_END = /^\s*```[ \t]*$/u;
 export function parseSourceItems(sourcePath, content) {
     return parseSourceDocument(sourcePath, content).items;
@@ -52,9 +54,15 @@ function consumeOpenFormalBlock(state, line, startOffset) {
     if (!FORMAL_BLOCK_END.test(line))
         return true;
     try {
-        const value = parseStrictYaml(formalBlockBody(state.content, state.formalBlock.bodyStartOffset, startOffset, state.formalBlock.owner === "design-resource-handoff-v1"));
+        const value = parseStrictYaml(formalBlockBody(state.content, state.formalBlock.bodyStartOffset, startOffset, state.formalBlock.owner.startsWith("design-resource-handoff-")));
         if (state.formalBlock.owner === "design-resource-handoff-v1")
             state.designResourceHandoff = parseDesignResourceHandoffInputShape(value);
+        else if (state.formalBlock.owner === "design-resource-handoff-v2")
+            state.designResourceHandoff =
+                parseDesignResourceSymbolicHandoffShape(value);
+        else if (state.formalBlock.owner === "semantic-fact-compact-carrier-v1")
+            state.semanticFactManifest =
+                parseSemanticFactCompactCarrierShape(value).manifest;
         else
             state.semanticFactManifest = parseSemanticFactManifestShape(value);
     }
@@ -66,23 +74,24 @@ function consumeOpenFormalBlock(state, line, startOffset) {
     return true;
 }
 function startFormalBlock(state, line, lineNumber, nextOffset) {
-    const owner = DESIGN_RESOURCE_START.test(line)
-        ? "design-resource-handoff-v1"
-        : SEMANTIC_FACT_START.test(line)
-            ? "semantic-fact-manifest-v1"
-            : null;
+    const designMatch = DESIGN_RESOURCE_START.exec(line);
+    const owner = designMatch
+        ? designMatch[1] === "v2"
+            ? "design-resource-handoff-v2"
+            : "design-resource-handoff-v1"
+        : (SEMANTIC_FACT_START.exec(line)?.[1] ?? null);
     if (!owner)
         return false;
     assertNoOpenOwnedSection(state, lineNumber);
-    if (owner === "design-resource-handoff-v1") {
+    if (owner.startsWith("design-resource-handoff-")) {
         state.designResourceBlocks += 1;
         if (state.designResourceBlocks > 1)
-            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff-v1`);
+            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff`);
     }
     else {
         state.semanticFactBlocks += 1;
         if (state.semanticFactBlocks > 1)
-            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:semantic-fact-manifest-v1`);
+            throw new Error(`source_formal_block_duplicate:${state.sourcePath}:semantic-fact-manifest`);
     }
     state.formalBlock = {
         owner,

package/dist/lib/long-task-ui-design-policy.js

@@ -7,6 +7,7 @@ export function validateUiDesignBinding(context) {
 function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carriers, designTargetKeys, designAssertionRefs, report, }) {
     for (const target of binding.design_targets) {
         const label = `${outcome.key}:${binding.key}:${target.key}`;
+        const symbolic = target.fact_model === "symbolic_rules_v2";
         if (designTargetKeys.has(target.key))
             issue(report, "ui_design_target_key_duplicate", label);
         designTargetKeys.add(target.key);
@@ -14,10 +15,20 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         if (designAssertionRefs.has(assertionIdentity))
             issue(report, "ui_design_target_assertion_duplicate", label);
         designAssertionRefs.add(assertionIdentity);
-        unique(target.verification_method_bindings.map((item) => item.method), "ui_design_target_verification_method_duplicate", label, report);
-        unique(target.verification_method_bindings.map((item) => item.assertion_ref), "ui_design_target_verification_assertion_duplicate", label, report);
-        if (!target.verification_method_bindings.length)
+        unique((symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).map((item) => item.method), "ui_design_target_verification_method_duplicate", label, report);
+        unique((symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).map((item) => item.assertion_ref), "ui_design_target_verification_assertion_duplicate", label, report);
+        if (!(symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).length)
             issue(report, "ui_design_target_verification_methods_required", label);
+        if (symbolic &&
+            (target.condition_keys.length ||
+                target.verification_method_bindings.length))
+            issue(report, "ui_design_symbolic_ground_fields_forbidden", label);
         const methodArtifactPaths = new Set();
         const methodFactObligations = new Set();
         for (const [name, values] of [
@@ -26,7 +37,7 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
             ["claim_refs", target.claim_refs],
         ]) {
             unique(values, `ui_design_target_${name}_duplicate`, label, report);
-            if (!values.length)
+            if (!values.length && !(symbolic && name === "condition_keys"))
                 issue(report, `ui_design_target_${name}_required`, label);
         }
         for (const claimRef of target.claim_refs) {
@@ -44,6 +55,11 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         validateRootJourney(binding, check, label, report);
         validateCarrierInputs(check, carriers, label, report);
         validateDesignAssertion(target, check, label, report);
+        if (symbolic) {
+            validateSymbolicDesignBindings(target, check, label, methodArtifactPaths, report);
+            validateDesignFiles(target, check, label, report);
+            continue;
+        }
         for (const methodBinding of target.verification_method_bindings) {
             const identity = `${target.conformance_check_ref}\0${methodBinding.assertion_ref}`;
             if (methodBinding.assertion_ref !== target.conformance_assertion_ref &&
@@ -86,6 +102,50 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         validateDesignFiles(target, check, label, report);
     }
 }
+function validateSymbolicDesignBindings(target, check, label, artifactPaths, report) {
+    const obligationRefs = new Set();
+    for (const binding of target.symbolic_method_bindings ?? []) {
+        const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
+        if (!assertion)
+            issue(report, "ui_design_symbolic_method_assertion_unknown", `${label}:${binding.method}:${binding.assertion_ref}`);
+        else if (!assertion.evidence_capabilities.includes("design_method"))
+            issue(report, "ui_design_symbolic_method_capability_required", `${label}:${binding.method}`);
+        if (!binding.rule_expectations.length)
+            issue(report, "ui_design_symbolic_rule_expectations_required", `${label}:${binding.method}`);
+        unique(binding.rule_expectations.map((item) => item.obligation_ref), "ui_design_symbolic_obligation_duplicate", `${label}:${binding.method}`, report);
+        for (const expectation of binding.rule_expectations) {
+            if (obligationRefs.has(expectation.obligation_ref))
+                issue(report, "ui_design_symbolic_obligation_reused", `${label}:${expectation.obligation_ref}`);
+            obligationRefs.add(expectation.obligation_ref);
+        }
+        for (const artifactPath of [
+            binding.artifact_path,
+            binding.observation_path,
+        ])
+            validateSymbolicArtifactPath(artifactPath, target, check, label, artifactPaths, report);
+    }
+    const certificate = target.symbolic_certificate_binding;
+    if (!certificate) {
+        issue(report, "ui_design_symbolic_certificate_binding_required", label);
+        return;
+    }
+    const assertion = check.positive_assertions.find((item) => item.key === certificate.assertion_ref);
+    if (!assertion)
+        issue(report, "ui_design_symbolic_certificate_assertion_unknown", `${label}:${certificate.assertion_ref}`);
+    else if (!assertion.evidence_capabilities.includes("design_symbolic_certificate"))
+        issue(report, "ui_design_symbolic_certificate_capability_required", label);
+    if (!certificate.expectations.length)
+        issue(report, "ui_design_symbolic_certificate_expectations_required", label);
+    unique(certificate.expectations.map((item) => item.certificate_ref), "ui_design_symbolic_certificate_duplicate", label, report);
+    validateSymbolicArtifactPath(certificate.artifact_path, target, check, label, artifactPaths, report);
+}
+function validateSymbolicArtifactPath(artifactPath, _target, check, label, artifactPaths, report) {
+    if (artifactPaths.has(artifactPath))
+        issue(report, "ui_design_symbolic_evidence_artifact_reused", `${label}:${artifactPath}`);
+    artifactPaths.add(artifactPath);
+    if (!check.artifact_globs.some((pattern) => matchesRepoPattern(artifactPath, pattern)))
+        issue(report, "ui_design_symbolic_evidence_artifact_glob_missing", `${label}:${artifactPath}`);
+}
 function sameSet(left, right) {
     const leftSet = [...new Set(left)].sort();
     const rightSet = [...new Set(right)].sort();