project-tiny-context-harness 0.8.11 → 0.8.13

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

@@ -1,4 +1,5 @@
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { evaluateExactDigestComparison, } from "./long-task-exact-comparison.js";
+import { canonicalValueJson } from "./strict-codec.js";
 export function validateSemanticFactEvidence(check, record, artifactHashes) {
     const expectations = check.semantic_fact_expectations.filter((item) => item.assertion_ref === record.assertion_key);
     if (expectations.length !== 1)
@@ -15,8 +16,6 @@ export function validateSemanticFactEvidence(check, record, artifactHashes) {
     const observerError = validateSemanticFactObservers(record, expected, artifactHashes);
     if (observerError)
         return observerError;
-    if (record.verdict !== "passed" || record.comparison.passed !== true)
-        return "semantic_fact_failed";
     return null;
 }
 function validateSemanticFactEvidenceAuthority(check, record, expected) {
@@ -34,24 +33,9 @@ function validateSemanticFactEvidenceAuthority(check, record, expected) {
         return "semantic_fact_expected_value_mismatch";
     if (!sameSemanticFactComparisonAuthority(record, expected))
         return "semantic_fact_comparison_authority_mismatch";
-    if (record.comparison.result_sha256 !==
-        semanticFactComparisonResultIdentity({
-            fact_ref: record.fact_ref,
-            proof_ref: record.proof_ref,
-            target_ref: record.target_ref,
-            actual_value_sha256: record.actual_observation.value_sha256,
-            expected_value_sha256: expected.expected.sha256,
-            comparator: record.comparison.comparator,
-            mode: record.comparison.mode,
-            parameters_sha256: record.comparison.parameters.sha256,
-            tolerance_sha256: record.comparison.tolerance?.sha256 ?? null,
-            mask_sha256: record.comparison.mask?.sha256 ?? null,
-            passed: record.comparison.passed,
-        }))
-        return "semantic_fact_comparison_result_identity_mismatch";
-    if (record.comparison.comparator === "exact_value" &&
-        record.actual_observation.value_sha256 !== expected.expected.sha256)
-        return "semantic_fact_exact_value_mismatch";
+    const exactError = validateSemanticFactExactComparison(record, expected);
+    if (exactError)
+        return exactError;
     if (canonicalValueJson(record.oracle) !== canonicalValueJson(expected.oracle) ||
         canonicalValueJson(record.environment) !==
             canonicalValueJson(expected.environment))
@@ -67,14 +51,33 @@ 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) ||
         (sensitivity === "protected" && redaction !== null));
 }
 function sameSemanticFactComparisonAuthority(record, expected) {
-    return (record.comparison.comparator === expected.comparison.comparator &&
+    return (expected.comparison.comparator === "exact_value" &&
+        expected.comparison.mode === "exact" &&
+        expected.comparison.tolerance === null &&
+        expected.comparison.mask === null &&
+        record.comparison.comparator === expected.comparison.comparator &&
         record.comparison.mode === expected.comparison.mode &&
         canonicalValueJson(record.comparison.parameters) ===
             canonicalValueJson(expected.comparison.parameters) &&
@@ -83,6 +86,17 @@ function sameSemanticFactComparisonAuthority(record, expected) {
         canonicalValueJson(record.comparison.mask) ===
             canonicalValueJson(expected.comparison.mask));
 }
+function validateSemanticFactExactComparison(record, expected) {
+    const recomputed = evaluateSemanticFactExactComparison(expected, record.target_ref, record.actual_observation.value_sha256);
+    if (!recomputed.passed)
+        return "semantic_fact_exact_value_mismatch";
+    if (record.comparison.passed !== recomputed.passed ||
+        record.verdict !== semanticFactVerdict(recomputed.passed))
+        return "project_submitted_verdict_disagrees_with_harness";
+    return record.comparison.result_sha256 === recomputed.result_sha256
+        ? null
+        : "semantic_fact_comparison_result_identity_mismatch";
+}
 function validateSemanticFactArtifacts(record, expected, artifactHashes) {
     if (artifactHashes[record.actual_observation.artifact_path] !==
         record.actual_observation.artifact_sha256)
@@ -110,30 +124,74 @@ function validateSemanticFactObservers(record, expected, artifactHashes) {
         observerObservations.add(observation);
         if (artifactHashes[observer.artifact_path] !== observer.artifact_sha256)
             return "semantic_fact_observer_artifact_mismatch";
-        if (observer.passed !== true ||
-            (record.comparison.comparator === "exact_value" &&
-                observer.value_sha256 !== expected.expected.sha256))
+        const recomputed = evaluateSemanticFactExactComparison(expected, observer.target_ref, observer.value_sha256);
+        if (!recomputed.passed)
             return "semantic_fact_observer_failed";
-        if (observer.comparison_result_sha256 !==
-            semanticFactComparisonResultIdentity({
-                fact_ref: record.fact_ref,
-                proof_ref: record.proof_ref,
-                target_ref: observer.target_ref,
-                actual_value_sha256: observer.value_sha256,
-                expected_value_sha256: expected.expected.sha256,
-                comparator: record.comparison.comparator,
-                mode: record.comparison.mode,
-                parameters_sha256: record.comparison.parameters.sha256,
-                tolerance_sha256: record.comparison.tolerance?.sha256 ?? null,
-                mask_sha256: record.comparison.mask?.sha256 ?? null,
-                passed: observer.passed,
-            }))
+        if (observer.passed !== recomputed.passed)
+            return "project_submitted_verdict_disagrees_with_harness";
+        if (observer.comparison_result_sha256 !== recomputed.result_sha256)
             return "semantic_fact_observer_comparison_identity_mismatch";
     }
     return null;
 }
 export function semanticFactComparisonResultIdentity(value) {
-    return sha256Hex(canonicalValueJson(value));
+    return evaluateSemanticFactExactComparisonMaterial(value).result_sha256;
+}
+function evaluateSemanticFactExactComparison(expected, targetRef, actualValueSha256) {
+    return evaluateSemanticFactExactComparisonMaterial({
+        fact_ref: expected.fact_ref,
+        proof_ref: expected.proof_ref,
+        fact_key: expected.fact_key,
+        fact_revision_digest: expected.fact_revision_digest,
+        obligation_key: expected.obligation_key,
+        obligation_revision_digest: expected.obligation_revision_digest,
+        target_ref: targetRef,
+        actual_value_sha256: actualValueSha256,
+        expected_value_sha256: expected.expected.sha256,
+        comparator: expected.comparison.comparator,
+        mode: expected.comparison.mode,
+        parameters_sha256: expected.comparison.parameters.sha256,
+        tolerance_sha256: expected.comparison.tolerance?.sha256 ?? null,
+        mask_sha256: expected.comparison.mask?.sha256 ?? null,
+    });
+}
+function evaluateSemanticFactExactComparisonMaterial(value) {
+    return evaluateExactDigestComparison({
+        identity: semanticFactComparisonIdentity(value),
+        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,
+    });
+}
+function semanticFactComparisonIdentity(value) {
+    const revisionIdentityPresent = value.fact_key !== undefined ||
+        value.fact_revision_digest !== undefined ||
+        value.obligation_key !== undefined ||
+        value.obligation_revision_digest !== undefined;
+    return revisionIdentityPresent
+        ? {
+            kind: "semantic_fact_non_ui",
+            fact_ref: value.fact_ref,
+            proof_ref: value.proof_ref,
+            fact_key: value.fact_key,
+            fact_revision_digest: value.fact_revision_digest,
+            obligation_key: value.obligation_key,
+            obligation_revision_digest: value.obligation_revision_digest,
+            target_ref: value.target_ref,
+        }
+        : {
+            kind: "semantic_fact_non_ui",
+            fact_ref: value.fact_ref,
+            proof_ref: value.proof_ref,
+            target_ref: value.target_ref,
+        };
+}
+function semanticFactVerdict(passed) {
+    return passed ? "passed" : "failed";
 }
 export function validateDistinctSemanticFactEvidence(records) {
     const observations = new Set();
@@ -142,7 +200,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 +222,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-claim-validation.js

@@ -1,11 +1,13 @@
 import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
 import { fail } from "./long-task-delivery-shape.js";
+import { executionTargetSourceTargetRef } from "./long-task-source-target-index.js";
 export function validateSourceClaimMappings(contract, compiledClaims, report) {
     validateSourcePresence(contract, report);
     const sources = new Set(contract.task.source_paths);
     const productClaims = new Set(Object.values(compiledClaims.by_outcome)
         .flat()
         .map((claim) => claim.id));
+    const executionTargetClaims = new Set(contract.task.execution_targets.map((target) => executionTargetSourceTargetRef(target.key)));
     const globalClaims = new Map(compiledClaims.by_global.map((claim) => [claim.local_key, claim]));
     const coveredGlobalClaims = new Set(Object.entries(compiledClaims.summary.claims_by_global)
         .filter(([, value]) => value.covered)
@@ -22,7 +24,8 @@ export function validateSourceClaimMappings(contract, compiledClaims, report) {
             for (const reference of disposition.refs) {
                 if (reference.endsWith(".result"))
                     issue(report, "source_claim_result_overcompression", `${claim.key}:${reference}`);
-                if (!productClaims.has(reference))
+                if (!productClaims.has(reference) &&
+                    !executionTargetClaims.has(reference))
                     issue(report, "source_claim_product_ref_unknown", `${claim.key}:${reference}`);
             }
         if (disposition.type === "acceptance") {

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-input-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-source-target-continuity.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledSourceItemV2, DeliveryContractV2, SourceBackedExecutionTargetV2 } from "./long-task-delivery-types.js";
 type ValidationReporter = (message: string) => void;
-export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): void;
+export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): Map<string, SourceBackedExecutionTargetV2>;
 export {};

package/dist/lib/long-task-source-target-continuity.js

@@ -1,11 +1,14 @@
 import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { buildCanonicalSourceTargetIndex, sourceKindForTarget, } from "./long-task-source-target-index.js";
+import { buildCanonicalSourceTargetIndex, executionTargetSourceTargetRef, sourceKindForTarget, } from "./long-task-source-target-index.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 export function validateSourceTargetContinuity(contract, items, report) {
     const state = sourceContinuityState(contract, items);
     for (const claim of contract.source_claims)
         validateSourceClaimContinuity(claim, state, report);
     validateAcceptanceBindingContinuity(contract, state, report);
     validateArchitectureContinuity(state, report);
+    validateRequiredExecutionTargetContinuity(contract, state, report);
+    return state.executionTargetAuthorities;
 }
 function sourceContinuityState(contract, items) {
     return {
@@ -19,6 +22,7 @@ function sourceContinuityState(contract, items) {
             .filter((item) => item.aspect === "architecture")
             .map((item) => item.key)),
         ownedArchitectureItems: new Set(),
+        executionTargetAuthorities: new Map(),
     };
 }
 function validateSourceClaimContinuity(claim, state, report) {
@@ -46,7 +50,9 @@ function validateSourceClaimContinuity(claim, state, report) {
     }
     if (target.normalized_text !== undefined &&
         target.normalized_text !== item.normalized_text) {
-        issue(report, `source_target_statement_mismatch:${claim.key}:${ref}`);
+        issue(report, target.execution_target_ref
+            ? `process_root_source_identity_mismatch:${target.execution_target_ref}:${claim.key}`
+            : `source_target_statement_mismatch:${claim.key}:${ref}`);
         return;
     }
     const owner = state.owners.get(ref);
@@ -73,6 +79,33 @@ function validateSourceClaimContinuity(claim, state, report) {
         state.sourceBackedGlobalClaims.add(ref);
     if (target.kind === "acceptance")
         state.acceptanceBindings.push({ claim, target });
+    if (target.execution_target_ref)
+        state.executionTargetAuthorities.set(target.execution_target_ref, {
+            target_ref: target.execution_target_ref,
+            canonical_target_ref: ref,
+            source_claim_key: claim.key,
+            source_item_key: item.key,
+            source_path: item.source_path,
+            source_text_sha256: item.text_sha256,
+            target_identity: sha256Hex(canonicalValueJson({
+                canonical_target_ref: ref,
+                source_claim_key: claim.key,
+                source_item_key: item.key,
+                source_path: item.source_path,
+                source_text_sha256: item.text_sha256,
+                normalized_text: item.normalized_text,
+            })),
+        });
+}
+function validateRequiredExecutionTargetContinuity(contract, state, report) {
+    for (const targetRef of contract.task.target_profile.required_target_refs) {
+        if (state.executionTargetAuthorities.has(targetRef))
+            continue;
+        const target = contract.task.execution_targets.find((candidate) => candidate.key === targetRef);
+        issue(report, target?.runtime_family === "process"
+            ? `process_root_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`
+            : `execution_target_source_binding_required:${targetRef}:${executionTargetSourceTargetRef(targetRef)}`);
+    }
 }
 function validateAcceptanceBindingContinuity(contract, state, report) {
     for (const { claim, target } of state.acceptanceBindings) {

package/dist/lib/long-task-source-target-index.d.ts

@@ -7,6 +7,9 @@ export interface CanonicalSourceTarget {
     outcome_key?: string;
     risk_fact?: keyof DeliveryContractV2["risk"]["facts"];
     affected_outcome?: string;
+    execution_target_ref?: string;
 }
 export declare function buildCanonicalSourceTargetIndex(contract: DeliveryContractV2): Map<string, CanonicalSourceTarget>;
+export declare function executionTargetSourceTargetRef(targetKey: string): string;
+export declare function executionTargetSourceStatement(targetValue: DeliveryContractV2["task"]["execution_targets"][number]): string;
 export declare function sourceKindForTarget(target: CanonicalSourceTarget): SourceItemKind | null;

package/dist/lib/long-task-source-target-index.js

@@ -1,7 +1,13 @@
 import { controlFieldFacts } from "./long-task-control-fields.js";
 import { normalizeSourceItemText } from "./long-task-source-item-parser.js";
+import { canonicalValueJson } from "./strict-codec.js";
 export function buildCanonicalSourceTargetIndex(contract) {
     const targets = [];
+    for (const executionTarget of contract.task.execution_targets)
+        targets.push({
+            ...target(executionTargetSourceTargetRef(executionTarget.key), "technical_obligation", executionTargetSourceStatement(executionTarget)),
+            execution_target_ref: executionTarget.key,
+        });
     for (const outcome of contract.outcomes) {
         targets.push(target(`${outcome.key}.result`, "outcome_result", outcome.product.observable_result, outcome.key));
         for (const requirement of outcome.product.requirements)
@@ -52,6 +58,19 @@ export function buildCanonicalSourceTargetIndex(contract) {
         targets.push(target(item.key, "external_confirmation", item.description));
     return new Map(targets.map((item) => [item.ref, item]));
 }
+export function executionTargetSourceTargetRef(targetKey) {
+    return `execution_target.${targetKey}`;
+}
+export function executionTargetSourceStatement(targetValue) {
+    return `Execution target authority: ${canonicalValueJson({
+        key: targetValue.key,
+        role: targetValue.role,
+        runtime_family: targetValue.runtime_family,
+        root_entrypoint: targetValue.root_entrypoint,
+        root_argv: [...(targetValue.root_argv ?? [])],
+        capabilities: [...new Set(targetValue.capabilities)].sort(),
+    })}.`;
+}
 function target(ref, kind, text, outcomeKey, scope) {
     return {
         ref,

package/dist/lib/long-task-stage-policy.js

@@ -1,3 +1,4 @@
+import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
 export function validateDeliveryStages(contract, report) {
     unique(contract.stages.map((stage) => stage.key), "stage_key_duplicate", report);
     const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
@@ -60,17 +61,22 @@ function validateStageGateClosure(contract, report) {
                     issue(report, "stage_outcome_missing_gate_dependency", `${stage.key}:${outcome.key}:${dependencyGate}`);
         }
         const stageGateChecks = gate.acceptance.checks.filter((check) => check.journey_roles.includes("stage_gate"));
-        if (!stageGateChecks.length)
+        const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, gate.key);
+        if (!stageGateChecks.length && !resultExternallyBlocked)
             issue(report, "stage_gate_check_required", `${stage.key}:${gate.key}`);
-        else if (!stageGateChecks.some((check) => provesGate(check, gate)))
+        else if (!resultExternallyBlocked &&
+            !stageGateChecks.some((check) => provesGate(check, gate)))
             issue(report, "stage_gate_target_runtime_result_required", `${stage.key}:${gate.key}`);
-        for (const targetRef of contract.task.target_profile.required_target_refs)
+        for (const targetRef of resultExternallyBlocked
+            ? []
+            : contract.task.target_profile.required_target_refs)
             if (!stageGateChecks.some((check) => check.execution_target.target_ref === targetRef &&
                 check.execution_target.entrypoint === "root" &&
                 provesGate(check, gate)))
                 issue(report, "stage_gate_required_target_proof_missing", `${stage.key}:${targetRef}`);
         const stageOutcomes = contract.outcomes.filter((candidate) => candidate.stage === stage.key);
-        if (stageOutcomes.length > 1 &&
+        if (!resultExternallyBlocked &&
+            stageOutcomes.length > 1 &&
             !stageGateChecks.some((check) => [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("cross_surface_consistency"))))
             issue(report, "stage_gate_cross_surface_consistency_required", `${stage.key}:${stageOutcomes.map((outcome) => outcome.key).join(",")}`);
     }

package/dist/lib/long-task-static-observation-freeze.d.ts

@@ -0,0 +1,83 @@
+import { type JsonPointerExactBudget, type JsonPointerExactLocator, type JsonPointerExactObservation } from "./long-task-json-pointer-observation.js";
+import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
+export type StaticObservationFreezeErrorCode = "static_observation_not_in_pre_run_snapshot" | "static_observation_changed_by_runner" | "static_observation_manifest_invalid" | "static_observation_path_escape" | "static_observation_root_invalid" | "static_observation_parent_not_directory" | "static_observation_symlink_not_allowed" | "static_observation_hardlink_not_allowed" | "static_observation_not_regular_file" | "static_observation_size_limit";
+export declare class StaticObservationFreezeError extends Error {
+    readonly code: StaticObservationFreezeErrorCode;
+    readonly artifact_path: string;
+    readonly cause_code: string | null;
+    constructor(code: StaticObservationFreezeErrorCode, artifactPath: string, causeCode?: string | null);
+}
+export interface StaticObservationManifestMembership {
+    path: string;
+    mode: number;
+    declared_size: number;
+    /** Git/blob identity from the workspace manifest; never a content digest. */
+    manifest_object_identity: string;
+}
+export interface StaticObservationFileIdentity {
+    device: string;
+    inode: string;
+    mode: number;
+    links: string;
+    size: number;
+    modified_time_ns: string;
+    changed_time_ns: string;
+    birth_time_ns: string;
+    content_sha256: string;
+}
+export interface VerifiedObservationInputFile {
+    readonly artifact_path: string;
+    readonly manifest_membership: StaticObservationManifestMembership;
+    readonly pre_run_identity: StaticObservationFileIdentity;
+    readonly post_run_identity: StaticObservationFileIdentity;
+}
+export interface VerifiedStaticObservationCarrier extends VerifiedObservationInputFile {
+    copyFrozenBytes(): Uint8Array;
+    extractJsonPointerExactObservation(input: {
+        locator: JsonPointerExactLocator;
+        sensitivity: string;
+        budget?: JsonPointerExactBudget;
+    }): JsonPointerExactObservation;
+    extractJsonPointerExactValue(input: {
+        locator: JsonPointerExactLocator;
+        sensitivity: string;
+        budget?: JsonPointerExactBudget;
+    }): {
+        raw_value: unknown;
+        observation: JsonPointerExactObservation;
+    };
+}
+export interface FrozenObservationInputFile {
+    readonly artifact_path: string;
+    readonly manifest_membership: StaticObservationManifestMembership;
+    readonly pre_run_identity: StaticObservationFileIdentity;
+    verifyPostRun(): Promise<VerifiedObservationInputFile>;
+    dispose(): void;
+}
+export interface FrozenStaticObservationCarrier extends FrozenObservationInputFile {
+    verifyPostRun(): Promise<VerifiedStaticObservationCarrier>;
+}
+export interface ObservationInputFreezeBudget {
+    readonly seen_artifact_paths: Set<string>;
+    total_artifact_bytes: number;
+    readonly max_artifacts: number;
+    readonly max_total_artifact_bytes: number;
+}
+export declare function createObservationInputFreezeBudget(input: {
+    max_artifacts: number;
+    max_total_artifact_bytes: number;
+}): ObservationInputFreezeBudget;
+export declare function freezeStaticObservationCarrier(input: {
+    snapshot_root: string;
+    workspace_manifest: WorkspaceManifestV2;
+    artifact_path: string;
+    budget?: JsonPointerExactBudget;
+    input_freeze_budget?: ObservationInputFreezeBudget;
+}): Promise<FrozenStaticObservationCarrier>;
+export declare function freezeObservationInputFile(input: {
+    snapshot_root: string;
+    workspace_manifest: WorkspaceManifestV2;
+    artifact_path: string;
+    max_file_bytes: number;
+    budget?: ObservationInputFreezeBudget;
+}): Promise<FrozenObservationInputFile>;