project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-risk.js

@@ -1,4 +1,6 @@
-import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
+import { machineAuthorizedAssertionExists } from "./long-task-acceptance-reachability-helpers.js";
+import { outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked, outcomeResultFullyEffectivelyExternallyBlocked, } from "./long-task-effective-external-takeover.js";
+import { outcomeUiProofFullyEffectivelyExternallyBlocked } from "./long-task-effective-external-ui-takeover.js";
 const STRICT_FACTS = new Set([
     "public_api_or_schema_change",
     "persistent_data_change",
@@ -39,32 +41,44 @@ export function classifyLongTaskRisk(contract) {
         reasons_by_outcome: reasonsByOutcome,
     };
 }
-export function validateRiskProof(contract, decision) {
+export function validateRiskProof(contract, decision, reachability, compiledOutcomes) {
     const errors = [];
     if (!contract.outcomes.length)
         errors.push("outcome_required");
     for (const check of contract.global.acceptance.checks)
         validateCheck(check, "global", errors);
     for (const outcome of contract.outcomes)
-        validateOutcome(contract, outcome, errors);
+        validateOutcome(contract, outcome, errors, reachability, compiledOutcomes?.find((candidate) => candidate.key === outcome.key), compiledOutcomes !== undefined);
     if (decision.effective_level === "strict")
-        validateStrict(contract, decision, errors);
+        validateStrict(contract, decision, errors, reachability, compiledOutcomes);
     if (errors.length)
         throw new Error(`delivery_contract_preflight_failed:\n${errors.join("\n")}`);
 }
-function validateOutcome(contract, outcome, errors) {
-    const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
-    const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, outcome.key);
-    if (!checks.size && !resultExternallyBlocked)
+function validateOutcome(contract, outcome, errors, reachability, compiledOutcome, useCompiledAuthority = false) {
+    const declaredChecks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
+    const resultExternallyBlocked = outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability);
+    const hasMachineProof = useCompiledAuthority
+        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], { authority_scope: "ordinary_claim", outcome_key: outcome.key })
+        : declaredChecks.size > 0;
+    if (!hasMachineProof && !resultExternallyBlocked)
         errors.push(`outcome_without_executable_check:${outcome.key}`);
     if (!outcome.technical.expected_change_paths.length)
         errors.push(`expected_change_paths_empty:${outcome.key}`);
-    for (const check of checks.values())
+    for (const check of declaredChecks.values())
         validateCheck(check, outcome.key, errors);
+    const hasMachineUiProof = useCompiledAuthority
+        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
+            authority_scope: "ordinary_claim",
+            outcome_key: outcome.key,
+            proof_surface: "ui_browser",
+        })
+        : [...declaredChecks.values()].some((check) => check.proof_surface === "ui_browser");
+    const uiProofExternallyBlocked = useCompiledAuthority &&
+        outcomeUiProofFullyEffectivelyExternallyBlocked(contract, outcome, reachability);
     if ((outcome.product.owner_surfaces.length ||
         outcome.product.controls.length) &&
-        !resultExternallyBlocked &&
-        ![...checks.values()].some((check) => check.proof_surface === "ui_browser"))
+        !hasMachineUiProof &&
+        !uiProofExternallyBlocked)
         errors.push(`ui_outcome_requires_ui_browser_proof:${outcome.key}`);
     const referenced = [
         ...(outcome.acceptance.population
@@ -75,18 +89,28 @@ function validateOutcome(contract, outcome, errors) {
         ...outcome.technical.bindings.flatMap((binding) => binding.verification_check_key ? [binding.verification_check_key] : []),
     ];
     for (const checkKey of referenced)
-        if (!checks.has(checkKey))
+        if (!declaredChecks.has(checkKey))
             errors.push(`outcome_check_reference_unknown:${outcome.key}:${checkKey}`);
 }
-function validateStrict(contract, decision, errors) {
+function validateStrict(contract, decision, errors, reachability, compiledOutcomes) {
     const explicitStrictWithoutFacts = contract.risk.requested_level === "strict" && decision.reasons.length === 0;
     for (const outcome of contract.outcomes) {
-        if (outcomeResultExternallyBlocked(contract, outcome.key))
+        if (outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability))
             continue;
+        const compiledOutcome = compiledOutcomes?.find((candidate) => candidate.key === outcome.key);
+        const useCompiledAuthority = compiledOutcomes !== undefined;
         const facts = new Set(decision.reasons_by_outcome[outcome.key]);
         const checks = outcome.acceptance.checks;
-        const hasNegative = checks.some((check) => check.negative_assertions.length > 0);
-        const hasCounterfactual = outcome.acceptance.counterfactual_controls.length > 0;
+        const hasNegative = useCompiledAuthority
+            ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
+                authority_scope: "ordinary_claim",
+                outcome_key: outcome.key,
+                polarity: "negative",
+            })
+            : checks.some((check) => check.negative_assertions.length > 0);
+        const hasCounterfactual = useCompiledAuthority
+            ? hasMachineCounterfactual(compiledOutcome)
+            : outcome.acceptance.counterfactual_controls.length > 0;
         if (explicitStrictWithoutFacts) {
             if (!hasNegative)
                 errors.push(`strict_negative_assertion_required:${outcome.key}`);
@@ -95,11 +119,11 @@ function validateStrict(contract, decision, errors) {
         }
         if (facts.has("security_boundary_change") ||
             facts.has("permission_boundary_change"))
-            requireStrictProof(outcome, "security_boundary", hasNegative, hasCounterfactual, errors);
+            requireStrictProof(outcome, "security_boundary", hasMachineSurfaceProof(outcome, compiledOutcome, "security_boundary", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
         if (facts.has("public_api_or_schema_change"))
-            requireStrictProof(outcome, "api_contract", hasNegative, hasCounterfactual, errors);
+            requireStrictProof(outcome, "api_contract", hasMachineSurfaceProof(outcome, compiledOutcome, "api_contract", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
         if (facts.has("persistent_data_change") || facts.has("data_migration")) {
-            requireStrictProof(outcome, "data_state", hasNegative, hasCounterfactual, errors);
+            requireStrictProof(outcome, "data_state", hasMachineSurfaceProof(outcome, compiledOutcome, "data_state", useCompiledAuthority), hasNegative, hasCounterfactual, errors);
             if (!outcome.technical.rollback_and_recovery)
                 errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
         }
@@ -107,20 +131,45 @@ function validateStrict(contract, decision, errors) {
             !outcome.technical.rollback_and_recovery)
             errors.push(`strict_rollback_and_recovery_required:${outcome.key}`);
         if (facts.has("full_population_operation")) {
-            if (!checks.some((check) => check.proof_surface === "population_coverage"))
+            if (!strictPopulationCoverageProofSatisfied(outcome, compiledOutcome, reachability, useCompiledAuthority))
                 errors.push(`strict_population_coverage_proof_required:${outcome.key}`);
             if (!outcome.acceptance.population)
                 errors.push(`strict_population_declaration_required:${outcome.key}`);
         }
         if (facts.has("critical_user_path") &&
             facts.has("weak_observability") &&
-            !checks.some((check) => check.proof_surface === "ui_browser" ||
-                check.proof_surface === "runtime_behavior"))
+            !(hasMachineSurfaceProof(outcome, compiledOutcome, "ui_browser", useCompiledAuthority) ||
+                hasMachineSurfaceProof(outcome, compiledOutcome, "runtime_behavior", useCompiledAuthority)))
             errors.push(`strict_critical_path_observable_proof_required:${outcome.key}`);
     }
 }
-function requireStrictProof(outcome, surface, hasNegative, hasCounterfactual, errors) {
-    if (!outcome.acceptance.checks.some((check) => check.proof_surface === surface))
+function strictPopulationCoverageProofSatisfied(outcome, compiledOutcome, reachability, useCompiledAuthority) {
+    return (hasMachineSurfaceProof(outcome, compiledOutcome, "population_coverage", useCompiledAuthority) ||
+        (useCompiledAuthority &&
+            outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome, reachability)));
+}
+function hasMachineSurfaceProof(outcome, compiledOutcome, surface, useCompiledAuthority) {
+    return useCompiledAuthority
+        ? machineAuthorizedAssertionExists(compiledOutcome?.acceptance.checks ?? [], {
+            authority_scope: "ordinary_claim",
+            outcome_key: outcome.key,
+            proof_surface: surface,
+        })
+        : outcome.acceptance.checks.some((check) => check.proof_surface === surface);
+}
+function hasMachineCounterfactual(outcome) {
+    if (!outcome)
+        return false;
+    return outcome.acceptance.counterfactual_controls.some((control) => control.claims.length > 0 &&
+        control.expected_assertion_failures.some((assertionRef) => machineAuthorizedAssertionExists(outcome.acceptance.checks, {
+            authority_scope: "ordinary_claim",
+            outcome_key: outcome.key,
+            check_key: control.check_key,
+            assertion_key: assertionRef,
+        })));
+}
+function requireStrictProof(outcome, surface, hasSurfaceProof, hasNegative, hasCounterfactual, errors) {
+    if (!hasSurfaceProof)
         errors.push(`strict_${surface}_proof_required:${outcome.key}`);
     if (!hasNegative)
         errors.push(`strict_negative_assertion_required:${outcome.key}`);

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

@@ -1,6 +1,7 @@
 import { parseGlobalCounterfactuals } from "./long-task-acceptance-shape.js";
+import { parseSemanticFactGlobalBindings } from "./long-task-semantic-fact-shape.js";
 import { parseCheck } from "./long-task-check-shape.js";
-import { array, boolean, key, literal, object, parseApplicableKeyedStatements, parseClaimApplicability, parseKeyedPaths, repositoryFiles, string, strings, } from "./long-task-delivery-shape.js";
+import { array, boolean, EVIDENCE_CAPABILITIES, key, literal, object, parseApplicableKeyedStatements, parseClaimApplicability, parseKeyedPaths, repositoryFile, repositoryFiles, string, strings, } from "./long-task-delivery-shape.js";
 import { EXECUTION_TARGET_CAPABILITIES } from "./execution-target-capabilities.js";
 const RISK_FACTS = [
     "public_api_or_schema_change",
@@ -24,12 +25,7 @@ export function parseTask(value) {
         "source_paths",
         "context_refs",
     ], ["context_snapshot_mode"]);
-    const targetProfile = object(row.target_profile, "task.target_profile", [
-        "key",
-        "description",
-        "required_state",
-        "required_target_refs",
-    ]);
+    const targetProfile = object(row.target_profile, "task.target_profile", ["key", "description", "required_state", "required_target_refs"], ["completion_authority"]);
     return {
         id: key(row.id, "task.id"),
         title: string(row.title, "task.title"),
@@ -43,6 +39,9 @@ export function parseTask(value) {
                 "production_release_ready",
             ], "task.target_profile.required_state"),
             required_target_refs: strings(targetProfile.required_target_refs, "task.target_profile.required_target_refs").map((item, index) => key(item, `task.target_profile.required_target_refs[${index}]`)),
+            completion_authority: Object.hasOwn(targetProfile, "completion_authority")
+                ? literal(targetProfile.completion_authority, ["machine_only", "declared_authorities"], "task.target_profile.completion_authority")
+                : "machine_only",
         },
         execution_targets: array(row.execution_targets, "task.execution_targets").map((item, index) => {
             const label = `task.execution_targets[${index}]`;
@@ -119,7 +118,13 @@ export function parseRisk(value) {
     };
 }
 export function parseGlobal(value) {
-    const row = object(value, "global", [], ["applicability", "product", "technical", "acceptance"]);
+    const row = object(value, "global", [], [
+        "applicability",
+        "semantic_fact_bindings",
+        "product",
+        "technical",
+        "acceptance",
+    ]);
     const product = object(Object.hasOwn(row, "product") ? row.product : {}, "global.product", [], ["non_goals"]);
     const technical = object(Object.hasOwn(row, "technical") ? row.technical : {}, "global.technical", [], ["constraints", "forbidden_paths", "forbidden_shortcuts"]);
     const acceptance = object(Object.hasOwn(row, "acceptance") ? row.acceptance : {}, "global.acceptance", [], ["checks", "counterfactual_controls", "external_confirmations"]);
@@ -127,6 +132,11 @@ export function parseGlobal(value) {
         applicability: Object.hasOwn(row, "applicability")
             ? parseClaimApplicability(row.applicability, "global.applicability")
             : [],
+        ...(Object.hasOwn(row, "semantic_fact_bindings")
+            ? {
+                semantic_fact_bindings: parseSemanticFactGlobalBindings(row.semantic_fact_bindings, "global.semantic_fact_bindings"),
+            }
+            : {}),
         product: {
             non_goals: Object.hasOwn(product, "non_goals")
                 ? parseApplicableKeyedStatements(product.non_goals, "global.product.non_goals")
@@ -160,6 +170,13 @@ export function parseGlobal(value) {
                         "kind",
                         "impact_claims",
                         "blocks_target",
+                    ], [
+                        "actor",
+                        "target_ref",
+                        "environment_identity",
+                        "scenario",
+                        "evidence_requirements",
+                        "obligations",
                     ]);
                     return {
                         key: key(entry.key, `${label}.key`),
@@ -174,9 +191,132 @@ export function parseGlobal(value) {
                         ], `${label}.kind`),
                         impact_claims: strings(entry.impact_claims, `${label}.impact_claims`),
                         blocks_target: boolean(entry.blocks_target, `${label}.blocks_target`),
+                        ...(Object.hasOwn(entry, "actor")
+                            ? { actor: parseExternalActor(entry.actor, `${label}.actor`) }
+                            : {}),
+                        ...(Object.hasOwn(entry, "target_ref")
+                            ? { target_ref: key(entry.target_ref, `${label}.target_ref`) }
+                            : {}),
+                        ...(Object.hasOwn(entry, "environment_identity")
+                            ? {
+                                environment_identity: string(entry.environment_identity, `${label}.environment_identity`),
+                            }
+                            : {}),
+                        ...(Object.hasOwn(entry, "scenario")
+                            ? {
+                                scenario: parseExternalScenario(entry.scenario, `${label}.scenario`),
+                            }
+                            : {}),
+                        ...(Object.hasOwn(entry, "evidence_requirements")
+                            ? {
+                                evidence_requirements: parseExternalStatements(entry.evidence_requirements, `${label}.evidence_requirements`),
+                            }
+                            : {}),
+                        ...(Object.hasOwn(entry, "obligations")
+                            ? {
+                                obligations: parseExternalObligations(entry.obligations, `${label}.obligations`),
+                            }
+                            : {}),
                     };
                 })
                 : [],
         },
     };
 }
+function parseExternalActor(value, label) {
+    const row = object(value, label, ["id", "role", "authority_kind"], ["identity_assurance"]);
+    return {
+        id: string(row.id, `${label}.id`),
+        role: string(row.role, `${label}.role`),
+        authority_kind: literal(row.authority_kind, ["human", "expert", "external_system"], `${label}.authority_kind`),
+        ...(Object.hasOwn(row, "identity_assurance")
+            ? {
+                identity_assurance: parseExternalIdentityAssurance(row.identity_assurance, `${label}.identity_assurance`),
+            }
+            : {}),
+    };
+}
+function parseExternalIdentityAssurance(value, label) {
+    const tagged = object(value, label, ["scheme"], ["key_id", "public_key_ref"]);
+    const scheme = literal(tagged.scheme, ["ed25519", "declared_only"], `${label}.scheme`);
+    if (scheme === "declared_only") {
+        object(value, label, ["scheme"]);
+        return { scheme };
+    }
+    const row = object(value, label, ["scheme", "key_id", "public_key_ref"]);
+    return {
+        scheme,
+        key_id: key(row.key_id, `${label}.key_id`),
+        public_key_ref: repositoryFile(row.public_key_ref, `${label}.public_key_ref`),
+    };
+}
+function parseExternalScenario(value, label) {
+    const row = object(value, label, ["given", "when"]);
+    return {
+        given: parseExternalStatements(row.given, `${label}.given`),
+        when: parseExternalStatements(row.when, `${label}.when`),
+    };
+}
+function parseExternalStatements(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, ["key", "statement"]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            statement: string(row.statement, `${itemLabel}.statement`),
+        };
+    });
+}
+function parseExternalObligations(value, label) {
+    return array(value, label).map((item, index) => {
+        const itemLabel = `${label}[${index}]`;
+        const row = object(item, itemLabel, [
+            "key",
+            "claim_ref",
+            "applicability_ref",
+            "fact_ref",
+            "proof_ref",
+            "method",
+            "proof_surface",
+            "evidence_capabilities",
+            "expected_authority_ref",
+            "result_kind",
+        ], ["judgment_basis"]);
+        return {
+            key: key(row.key, `${itemLabel}.key`),
+            claim_ref: string(row.claim_ref, `${itemLabel}.claim_ref`),
+            applicability_ref: key(row.applicability_ref, `${itemLabel}.applicability_ref`),
+            fact_ref: row.fact_ref === null
+                ? null
+                : string(row.fact_ref, `${itemLabel}.fact_ref`),
+            proof_ref: row.proof_ref === null
+                ? null
+                : string(row.proof_ref, `${itemLabel}.proof_ref`),
+            method: string(row.method, `${itemLabel}.method`),
+            proof_surface: literal(row.proof_surface, [
+                "ui_browser",
+                "runtime_behavior",
+                "api_contract",
+                "data_state",
+                "security_boundary",
+                "population_coverage",
+                "implementation_structure",
+            ], `${itemLabel}.proof_surface`),
+            evidence_capabilities: strings(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
+            expected_authority_ref: string(row.expected_authority_ref, `${itemLabel}.expected_authority_ref`),
+            result_kind: literal(row.result_kind, ["actual", "judgment"], `${itemLabel}.result_kind`),
+            ...(Object.hasOwn(row, "judgment_basis")
+                ? {
+                    judgment_basis: parseExternalJudgmentBasis(row.judgment_basis, `${itemLabel}.judgment_basis`),
+                }
+                : {}),
+        };
+    });
+}
+function parseExternalJudgmentBasis(value, label) {
+    const row = object(value, label, ["kind", "source_ref"]);
+    return {
+        kind: literal(row.kind, ["subjective_preference", "expert_assessment", "authorization"], `${label}.kind`),
+        source_ref: key(row.source_ref, `${label}.source_ref`),
+    };
+}

package/dist/lib/long-task-runner-freeze.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, SemanticFactExpectationV2, SourceBackedExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 import type { ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[], productionBindings: ScopedDeliveryBindingV2[], productionOwnerPaths: string[], sourceBackedExecutionTarget: SourceBackedExecutionTargetV2 | null, protectedAuthorityPaths?: readonly string[]): Promise<CompiledCheckV2>;
+import type { CheckProofAdequacyV2 } from "./long-task-proof-adequacy.js";
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[], semanticFactExpectations: SemanticFactExpectationV2[], productionBindings: ScopedDeliveryBindingV2[], productionOwnerPaths: string[], sourceBackedExecutionTarget: SourceBackedExecutionTargetV2 | null, protectedAuthorityPaths?: readonly string[], proofAdequacy?: CheckProofAdequacyV2, externalDesignObligationRefs?: ReadonlySet<string>, externalClaimObligationRefsByAssertion?: ReadonlyMap<string, string>): Promise<CompiledCheckV2>;
 export declare function playwrightConfigArgument(argv: readonly string[]): string | null;

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

@@ -8,12 +8,18 @@ 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";
-import { compileObservationAuthorityPlan } from "./long-task-observation-authority.js";
+import { compileObservationAuthorityPlan, projectExternallyOwnedClaimAssertions, projectExternallyOwnedDesignAssertions, } 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 = []) {
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets, semanticFactExpectations, productionBindings, productionOwnerPaths, sourceBackedExecutionTarget, protectedAuthorityPaths = [], proofAdequacy = {
+    completion_role: "diagnostic",
+    expected_authority_refs: {},
+    required_evidence_capabilities: {},
+}, externalDesignObligationRefs = new Set(), externalClaimObligationRefsByAssertion = new Map()) {
     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}]`));
+    const protectedAuthorityFiles = [
+        ...new Set(protectedAuthorityPaths.map((file, index) => normalizeRepositoryFile(file, `${check.key}.protected_authority_paths[${index}]`))),
+    ].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
     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)) &&
@@ -42,23 +48,28 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         production_owner_paths: productionOwnerPaths,
         source_backed_execution_target: sourceBackedExecutionTarget,
         workspace_manifest: baseline,
-        protected_authority_paths: protectedAuthorityPaths,
+        protected_authority_paths: protectedAuthorityFiles,
+        external_design_obligation_refs: externalDesignObligationRefs,
+        external_claim_obligation_refs_by_assertion: externalClaimObligationRefsByAssertion,
     });
+    const designProjection = projectExternallyOwnedDesignAssertions(check, designConformanceTargets, observationAuthorities, externalDesignObligationRefs);
+    const claimProjection = projectExternallyOwnedClaimAssertions(designProjection.check, observationAuthorities, externalClaimObligationRefsByAssertion);
+    const machineCheck = claimProjection.check;
     const processRuntimeClosure = compileProcessRuntimeClosure({
-        check,
+        check: machineCheck,
         runner,
         execution_target: executionTarget,
         observation_authorities: observationAuthorities,
         production_bindings: productionBindings,
         production_owner_paths: productionOwnerPaths,
         source_backed_execution_target: sourceBackedExecutionTarget,
-        protected_authority_paths: protectedAuthorityPaths,
+        protected_authority_paths: protectedAuthorityFiles,
     });
     const compiled = {
-        ...check,
+        ...machineCheck,
         internal_id: `${prefix}.${check.key}`,
         outcome_key: outcomeKey,
-        evidence_adapter: evidenceAdapterForRunner(check.runner.type),
+        evidence_adapter: evidenceAdapterForRunner(machineCheck.runner.type),
         runner,
         verification_input_hashes: verificationInputHashes,
         execution_target_definition: executionTarget,
@@ -66,7 +77,11 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         design_conformance_targets: designConformanceTargets,
         semantic_fact_expectations: semanticFactExpectations,
         observation_authorities: observationAuthorities,
+        protected_authority_paths: protectedAuthorityFiles,
         process_runtime_closure: processRuntimeClosure,
+        completion_role: proofAdequacy.completion_role,
+        expected_authority_refs: proofAdequacy.expected_authority_refs,
+        required_evidence_capabilities: proofAdequacy.required_evidence_capabilities,
     };
     return {
         ...compiled,

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

@@ -1,14 +1,16 @@
-import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, DeliveryRunnerV2, ProofSurface } from "./long-task-contract-types.js";
+import type { CompiledExternalConfirmationIdentityAssuranceV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, DeliveryRunnerV2, ProofSurface } from "./long-task-contract-types.js";
 import type { EvidenceCapabilityV2, ExecutionTargetV2 } from "./long-task-semantic-contract-types.js";
 import type { CompiledDesignTargetV2 } from "./long-task-ui-surface-types.js";
 import type { AuthorityHashesV2, ContextAuthoritySnapshotV2, InitialTaskBaseV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
 import type { EvidenceAdapter } from "./long-task-evidence-adapter-types.js";
 import type { EvidenceCapabilityRecordV2 } from "./long-task-evidence-capability-types.js";
 import type { EffectiveRiskLevel, RiskFactName } from "./long-task-risk-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability.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";
+import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
 export interface FrozenRunnerV2 extends DeliveryRunnerV2 {
     executable: string;
     executable_argv_prefix: string[];
@@ -33,6 +35,7 @@ export interface CompiledObservationAuthorityV2 {
     authority: CompiledObservationAuthorityKindV2;
     expected_identity: string;
     expected_value_sha256: string;
+    expected_value?: unknown;
     actual_projection: CompiledObservationActualProjectionV2;
     observation_identity: string;
     comparison: {
@@ -99,7 +102,11 @@ export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     design_conformance_targets: CompiledDesignTargetV2[];
     semantic_fact_expectations: SemanticFactExpectationV2[];
     observation_authorities: CompiledObservationAuthorityV2[];
+    protected_authority_paths?: string[];
     process_runtime_closure: CompiledProcessRuntimeClosureV2 | null;
+    completion_role: "semantic" | "diagnostic";
+    expected_authority_refs: Record<string, string>;
+    required_evidence_capabilities: Record<string, EvidenceCapabilityV2[]>;
 }
 export interface ProductClaimV2 {
     id: string;
@@ -163,6 +170,7 @@ export interface CompiledDeliveryContractV2 {
     source_hashes: Record<string, string>;
     source_items: CompiledSourceItemV2[];
     context_snapshot: ContextAuthoritySnapshotV2;
+    project_design_authority?: DesignAuthorityIdentityV1 | null;
     verifier_identity: VerifierIdentityV2;
     effective_risk: EffectiveRiskLevel;
     risk_reasons: string[];
@@ -172,6 +180,8 @@ export interface CompiledDeliveryContractV2 {
     authority_materials: NextAuthorityMaterialsV2;
     authority_revision: number;
     claim_coverage: ClaimCoverageSummaryV2;
+    acceptance_reachability: AcceptanceReachabilityV1;
+    external_confirmation_identity_assurances: Record<string, CompiledExternalConfirmationIdentityAssuranceV2>;
     semantic_fact_manifest: DeliveryContractV2["semantic_fact_manifest"];
     task: DeliveryContractV2["task"];
     risk: DeliveryContractV2["risk"];
@@ -199,6 +209,29 @@ export interface LongTaskFindingV2 {
     criterion?: string;
     observation?: string;
     owner_paths?: string[];
+    source_fragment_refs?: string[];
+    fact_refs?: string[];
+    proof_obligation_refs?: string[];
+    expected_authority_refs?: string[];
+    actual_evidence_refs?: string[];
+    implementation_owner?: {
+        label: string;
+        path_globs: string[];
+    };
+    verification_owner?: {
+        kind: "machine_check";
+        outcome_key: string | null;
+        check_key: string;
+        runner_target: string;
+        input_paths: string[];
+    } | {
+        kind: "external_confirmation";
+        confirmation_ref: string;
+        owner: string;
+        target_ref: string;
+    };
+    invalidation_reasons?: string[];
+    rerun_obligation_refs?: string[];
     message: string;
     expected?: unknown;
     actual?: unknown;
@@ -306,45 +339,6 @@ export interface ProgressRecordV2 {
     findings: LongTaskFindingV2[];
     completed_at: string;
 }
-export interface TargetedVerificationResultV2 {
-    schema_version: "long-task-targeted-progress-v2";
-    compiled_identity: string;
-    snapshot_sha256: string;
-    acceptance_authorized: false;
-    selected_outcome: string | null;
-    selected_check: string | null;
-    updated_progress_records: string[];
-    check_results: CheckExecutionResultV2[];
-    findings: LongTaskFindingV2[];
-    completed_at: string;
-}
-export type OutcomeStatusV2 = "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
-export type StageStatusV2 = "locked" | "ready" | "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
-export interface FinalReceiptV2 {
-    schema_version: "long-task-final-receipt-v2";
-    receipt_sha256: string;
-    authority_scope: "audit_only";
-    reusable_for_acceptance: false;
-    workflow_status: "machine_accepted" | "machine_accepted_external_pending" | "needs_work" | "blocked_external";
-    target_profile: DeliveryContractV2["task"]["target_profile"];
-    target_state: DeliveryContractV2["task"]["target_profile"]["required_state"] | "not_accepted" | "blocked_external";
-    stage_results: Record<string, "passed" | "failed" | "blocked_external" | "blocked_dependency">;
-    compiled_identity: string;
-    contract_sha256: string;
-    snapshot_sha256: string;
-    git_head: string;
-    git_tree: string;
-    source_hashes: Record<string, string>;
-    context_hashes: Record<string, string>;
-    verifier_identity: VerifierIdentityV2;
-    check_results: CheckExecutionResultV2[];
-    outcome_results: Record<string, "passed" | "failed" | "blocked_external">;
-    external_confirmations: DeliveryContractV2["global"]["acceptance"]["external_confirmations"];
-    findings: LongTaskFindingV2[];
-    snapshot_preparation_ms: number;
-    started_at: string;
-    completed_at: string;
-}
 export type StrictRiskObligationV2 = {
     outcome_key: string;
     risk_fact: RiskFactName;

package/dist/lib/long-task-semantic-assurance-policy.js

@@ -1,3 +1,4 @@
+import { canonicalApplicabilityIdentity } from "./long-task-applicability-identity.js";
 export function validateSemanticAssuranceShape(contract, report) {
     if (contract.task.context_snapshot_mode !== "full")
         issue(report, "long_task_full_context_required", contract.task.context_snapshot_mode);
@@ -21,17 +22,7 @@ function validateApplicabilityScope(scope, profiles, report) {
             expectedDimensionKeys = sortedKeys;
         else if (!same(expectedDimensionKeys, sortedKeys))
             issue(report, "applicability_dimension_set_mismatch", `${scope}:${profile.key}:${expectedDimensionKeys.join(",")}:${sortedKeys.join(",")}`);
-        const dimensions = [...profile.dimensions]
-            .sort((left, right) => left.key.localeCompare(right.key))
-            .map((dimension) => `${dimension.key}=${dimension.value}`)
-            .join(",");
-        const cell = [
-            profile.target_ref,
-            profile.journey_role,
-            dimensions,
-            [...profile.given_refs].sort().join(","),
-            profile.when_refs.join(","),
-        ].join("|");
+        const cell = canonicalApplicabilityIdentity(profile);
         const owner = cells.get(cell);
         if (owner)
             issue(report, "applicability_cell_duplicate", `${scope}:${profile.key}:${owner}`);

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

@@ -15,6 +15,7 @@ export interface TargetProfileV2 {
     description: string;
     required_state: TargetCompletionStateV2;
     required_target_refs: string[];
+    completion_authority: "machine_only" | "declared_authorities";
 }
 export interface ExecutionTargetV2 {
     key: string;
@@ -43,7 +44,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" | "design_symbolic_certificate" | "semantic_fact" | "target_runtime" | "input_variation";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "actual_provenance" | "external_side_effect" | "distinct_identity" | "data_state" | "population_coverage" | "failure_injection" | "recovery" | "visual_render" | "design_conformance" | "design_method" | "design_symbolic_certificate" | "semantic_fact" | "target_runtime" | "input_variation";
 export interface CheckExecutionTargetV2 {
     target_ref: string;
     entrypoint: "root" | "internal";