project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/long-task-design-feasibility-binding.d.ts

@@ -4,6 +4,7 @@ import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-deliv
 import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
 type DesignResourcePreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
 export interface LongTaskDesignFeasibilityBindingValidationResult {
+    attribution_mode: "feasibility" | "legacy";
     consumed_component_binding_refs: string[];
 }
 export interface LongTaskDesignFeasibilityBindingValidationOptions {

package/dist/lib/long-task-design-feasibility-binding.js

@@ -9,9 +9,8 @@ export function validateLongTaskDesignFeasibilityBindings(contract, contractTarg
         if (!contractTarget.binding.component_binding_refs.length)
             invalid("componentless_surface_requires_blocker_only_feasibility", contractTarget.target.key);
         return {
-            consumed_component_binding_refs: [
-                ...contractTarget.binding.component_binding_refs,
-            ],
+            attribution_mode: "legacy",
+            consumed_component_binding_refs: [],
         };
     }
     const model = feasibilityTargetModel(preflight, contractTarget.target.key);
@@ -74,6 +73,7 @@ export function validateLongTaskDesignFeasibilityBindings(contract, contractTarg
         validateComponentBindingAttribution(contractTarget, consumedComponentBindings);
     validateFeasibilityBlockers(contract, contractTarget, document, model, decisions);
     return {
+        attribution_mode: "feasibility",
         consumed_component_binding_refs: [...consumedComponentBindings].sort(),
     };
 }

package/dist/lib/long-task-design-feasibility-source-closure.js

@@ -1,4 +1,5 @@
 import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, requireExactFeasibilityDecisionProjection, } from "./design-resource-implementation-feasibility-source-decision.js";
+import { designFactObligationDescriptors, externalDesignObligationMatches, } from "./long-task-design-obligation.js";
 import { invalid } from "./long-task-design-resource-method-binding.js";
 export function validateSelectedPlannedOwnerClaims(contract, contractTarget, document, model, decisions, realization, bindings, cell) {
     for (const owner of realization.owner_candidates) {
@@ -45,15 +46,23 @@ export function validateFeasibilityBlockers(contract, contractTarget, document,
         if (claim.disposition.type !== "external_confirmation")
             invalid("feasibility_blocker_external_confirmation_required", `${blocker.key}:${claim.key}:${claim.disposition.type}`);
         const impactedTargetClaims = new Set(contractTarget.target.claim_refs.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`));
+        const exactTargetDesignObligations = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.outcome_key === contractTarget.outcome_key &&
+            descriptor.target_key === contractTarget.target.key);
         for (const confirmationRef of claim.disposition.refs) {
             const confirmation = contract.global.acceptance.external_confirmations.find((candidate) => candidate.key === confirmationRef);
             if (!confirmation)
                 invalid("feasibility_blocker_confirmation_unknown", `${blocker.key}:${confirmationRef}`);
             if (!confirmation.blocks_target)
                 invalid("feasibility_blocker_confirmation_not_blocking", `${blocker.key}:${confirmationRef}`);
-            if (!confirmation.impact_claims.some((claimRef) => impactedTargetClaims.has(claimRef)))
-                invalid("feasibility_blocker_confirmation_target_claim_missing", `${blocker.key}:${confirmationRef}`);
+            if (!confirmation.obligations?.some((obligation) => obligation.result_kind === "actual" &&
+                obligation.fact_ref !== null &&
+                obligation.proof_ref !== null))
+                invalid("feasibility_blocker_confirmation_exact_fact_required", `${blocker.key}:${confirmationRef}`);
         }
+        if (!contract.global.acceptance.external_confirmations.some((confirmation) => confirmation.blocks_target &&
+            confirmation.impact_claims.some((claimRef) => impactedTargetClaims.has(claimRef)) &&
+            confirmation.obligations?.some((obligation) => exactTargetDesignObligations.some((descriptor) => externalDesignObligationMatches(obligation, descriptor)))))
+            invalid("feasibility_blocker_confirmation_target_claim_missing", `${blocker.key}:${contractTarget.target.key}`);
     }
 }
 function requireDecisionSource(sourceRefs, decisions, expectation, label, allowedItemKinds, allReferencesMustBeSourceItems) {

package/dist/lib/long-task-design-obligation.d.ts

@@ -0,0 +1,50 @@
+import type { DeliveryCheckV2, DeliveryContractV2, DeliveryDesignFactExpectationV2, EvidenceCapabilityV2, ExternalConfirmationV2, ProofSurface } from "./long-task-delivery-types.js";
+type DesignObligationContract = {
+    outcomes: ReadonlyArray<{
+        key: string;
+        product: Pick<DeliveryContractV2["outcomes"][number]["product"], "surface_bindings">;
+        acceptance: {
+            checks: ReadonlyArray<Pick<DeliveryCheckV2, "key" | "proof_surface" | "positive_assertions" | "negative_assertions">>;
+        };
+    }>;
+};
+export interface DesignFactObligationDescriptorV1 {
+    source_obligation_ref: string;
+    outcome_key: string;
+    check_key: string;
+    target_key: string;
+    assertion_ref: string;
+    local_claim_ref: string;
+    claim_ref: string;
+    applicability_ref: string;
+    fact_ref: string;
+    method: string;
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    expected_authority_ref: string;
+    expected: DeliveryDesignFactExpectationV2["expected"];
+    comparison: DeliveryDesignFactExpectationV2["comparison"];
+    observation_sensitivity: "plain" | "protected";
+}
+export declare function designGroundObligationRef(targetKey: string, method: string, conditionKey: string, factRef: string): string;
+export declare function designFactObligationDescriptors(contract: DesignObligationContract): DesignFactObligationDescriptorV1[];
+export declare function exactExternalDesignObligationRefs(contract: DesignObligationContract & {
+    global: {
+        acceptance: {
+            external_confirmations: readonly ExternalConfirmationV2[];
+        };
+    };
+}, outcomeKey: string, checkKey: string): Set<string>;
+export declare function externalDesignObligationMatches(obligation: NonNullable<ExternalConfirmationV2["obligations"]>[number], descriptor: DesignFactObligationDescriptorV1): boolean;
+export declare function findDesignFactObligation(contract: DesignObligationContract, identity: {
+    outcome_key: string | null;
+    claim_ref: string;
+    applicability_ref: string;
+    fact_ref: string | null;
+    proof_ref: string | null;
+    method: string;
+    proof_surface: ProofSurface;
+    required_evidence_capabilities?: readonly EvidenceCapabilityV2[];
+    evidence_capabilities?: readonly EvidenceCapabilityV2[];
+}): DesignFactObligationDescriptorV1 | null;
+export {};

package/dist/lib/long-task-design-obligation.js

@@ -0,0 +1,99 @@
+export function designGroundObligationRef(targetKey, method, conditionKey, factRef) {
+    return `design.${targetKey}.${method}.${conditionKey}.${factRef}`;
+}
+export function designFactObligationDescriptors(contract) {
+    const result = [];
+    for (const outcome of contract.outcomes)
+        for (const surface of outcome.product.surface_bindings ?? [])
+            for (const target of surface.design_targets) {
+                const check = outcome.acceptance.checks.find((candidate) => candidate.key === target.conformance_check_ref);
+                if (!check)
+                    continue;
+                for (const binding of target.verification_method_bindings)
+                    for (const artifact of binding.evidence_artifacts)
+                        for (const expectation of artifact.fact_expectations) {
+                            const descriptor = descriptorForExpectation(outcome.key, check, target.key, binding.assertion_ref, designGroundObligationRef(target.key, binding.method, artifact.condition_key, expectation.fact_ref), expectation.fact_ref, binding.method, expectation);
+                            if (descriptor)
+                                result.push(descriptor);
+                        }
+                for (const binding of target.symbolic_method_bindings ?? [])
+                    for (const expectation of binding.rule_expectations) {
+                        const descriptor = descriptorForExpectation(outcome.key, check, target.key, binding.assertion_ref, expectation.obligation_ref, expectation.fact_rule_ref, binding.method, expectation);
+                        if (descriptor)
+                            result.push(descriptor);
+                    }
+            }
+    return result;
+}
+export function exactExternalDesignObligationRefs(contract, outcomeKey, checkKey) {
+    const confirmations = contract.global.acceptance.external_confirmations;
+    return new Set(designFactObligationDescriptors(contract)
+        .filter((descriptor) => descriptor.outcome_key === outcomeKey &&
+        descriptor.check_key === checkKey &&
+        confirmations.some((confirmation) => confirmation.blocks_target &&
+            confirmation.obligations?.some((obligation) => externalDesignObligationMatches(obligation, descriptor))))
+        .map((descriptor) => descriptor.source_obligation_ref));
+}
+export function externalDesignObligationMatches(obligation, descriptor) {
+    return (obligation.claim_ref === descriptor.claim_ref &&
+        obligation.applicability_ref === descriptor.applicability_ref &&
+        obligation.fact_ref === descriptor.fact_ref &&
+        obligation.proof_ref === descriptor.source_obligation_ref &&
+        obligation.method === descriptor.method &&
+        obligation.proof_surface === descriptor.proof_surface &&
+        sameSet(obligation.evidence_capabilities, descriptor.evidence_capabilities) &&
+        obligation.expected_authority_ref === descriptor.expected_authority_ref &&
+        obligation.result_kind === "actual" &&
+        obligation.judgment_basis === undefined);
+}
+export function findDesignFactObligation(contract, identity) {
+    if (!identity.outcome_key || !identity.fact_ref || !identity.proof_ref)
+        return null;
+    const capabilities = identity.evidence_capabilities ??
+        identity.required_evidence_capabilities ??
+        [];
+    const candidates = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.source_obligation_ref === identity.proof_ref &&
+        descriptor.outcome_key === identity.outcome_key &&
+        descriptor.claim_ref === identity.claim_ref &&
+        descriptor.applicability_ref === identity.applicability_ref &&
+        descriptor.fact_ref === identity.fact_ref &&
+        descriptor.method === identity.method &&
+        descriptor.proof_surface === identity.proof_surface &&
+        sameSet(descriptor.evidence_capabilities, capabilities));
+    return candidates.length === 1 ? candidates[0] : null;
+}
+function descriptorForExpectation(outcomeKey, check, targetKey, assertionRef, sourceObligationRef, factRef, method, expectation) {
+    const assertion = findAssertion(check, assertionRef);
+    if (!assertion ||
+        assertion.claims.length !== 1 ||
+        !assertion.applicability_ref)
+        return null;
+    const localClaimRef = assertion.claims[0];
+    return {
+        source_obligation_ref: sourceObligationRef,
+        outcome_key: outcomeKey,
+        check_key: check.key,
+        target_key: targetKey,
+        assertion_ref: assertionRef,
+        local_claim_ref: localClaimRef,
+        claim_ref: `${outcomeKey}.${localClaimRef}`,
+        applicability_ref: assertion.applicability_ref,
+        fact_ref: factRef,
+        method,
+        proof_surface: check.proof_surface,
+        evidence_capabilities: [...assertion.evidence_capabilities].sort(),
+        expected_authority_ref: `design-proof:${sourceObligationRef}`,
+        expected: expectation.expected,
+        comparison: expectation.comparison,
+        observation_sensitivity: expectation.observation_sensitivity,
+    };
+}
+function findAssertion(check, assertionRef) {
+    return ([...check.positive_assertions, ...check.negative_assertions].find((assertion) => assertion.key === assertionRef) ?? null);
+}
+function sameSet(left, right) {
+    return (left.length === right.length &&
+        new Set(left).size === left.length &&
+        new Set(right).size === right.length &&
+        left.every((value) => right.includes(value)));
+}

package/dist/lib/long-task-design-resource-handoff.d.ts

@@ -14,5 +14,7 @@ export interface LongTaskDesignHandoffConsumer {
     consume(preflight: DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2): void;
     finish(): void;
 }
-export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[]): Promise<void>;
+export type LongTaskDesignHandoffPreflight = DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2;
+export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string, sourceItems: CompiledSourceItemV2[]): Promise<LongTaskDesignHandoffPreflight[]>;
+export declare function validateProjectDesignAuthoritySet(preflights: LongTaskDesignHandoffPreflight[]): void;
 export declare function createLongTaskDesignHandoffConsumer(contract: DeliveryContractV2, sourceItems?: CompiledSourceItemV2[]): LongTaskDesignHandoffConsumer;

package/dist/lib/long-task-design-resource-handoff.js

@@ -9,6 +9,7 @@ import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { validateLongTaskDesignFeasibilityBindings } from "./long-task-design-feasibility-binding.js";
 export async function validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems) {
     const consumer = createLongTaskDesignHandoffConsumer(contract, sourceItems);
+    const preflights = [];
     for (const sourcePath of contract.task.source_paths) {
         if (!sourcePath.toLowerCase().endsWith(".md"))
             continue;
@@ -16,9 +17,26 @@ export async function validateLongTaskDesignResourceHandoffs(contract, repositor
         const content = await readFile(file, "utf8");
         if (!containsDesignResourceHandoff(content))
             continue;
-        consumer.consume(await preflightParsedDesignResourceHandoffAny(repository, parseDesignResourceHandoffMarkdown(sourcePath, content)));
+        const preflight = await preflightParsedDesignResourceHandoffAny(repository, parseDesignResourceHandoffMarkdown(sourcePath, content));
+        preflights.push(preflight);
+        consumer.consume(preflight);
     }
+    validateProjectDesignAuthoritySet(preflights);
     consumer.finish();
+    return preflights;
+}
+export function validateProjectDesignAuthoritySet(preflights) {
+    let expected = null;
+    for (const preflight of preflights) {
+        const identity = preflight.project_design_authority_resolution.identity;
+        if (!identity)
+            continue;
+        const canonical = JSON.stringify(identity);
+        if (expected === null)
+            expected = canonical;
+        else if (expected !== canonical)
+            invalid("project_design_authority_identity_conflict", `${JSON.parse(expected).closure_digest}:${identity.closure_digest}`);
+    }
 }
 export function createLongTaskDesignHandoffConsumer(contract, sourceItems = []) {
     const contractTargets = contract.outcomes.flatMap((outcome) => outcome.product.surface_bindings.flatMap((binding) => binding.design_targets.map((target) => ({
@@ -30,7 +48,7 @@ export function createLongTaskDesignHandoffConsumer(contract, sourceItems = [])
     const indexedTargetKeys = new Set();
     const consumed = new Set();
     const validationErrors = new Map();
-    const feasibilityBindingRefsBySurface = new Map();
+    const feasibilityBindingAttributionBySurface = new Map();
     let duplicate = null;
     const unbound = [];
     const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
@@ -86,7 +104,7 @@ export function createLongTaskDesignHandoffConsumer(contract, sourceItems = [])
                         };
                         validateSymbolicTargetIdentity(contractTarget, indexedTarget);
                         const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingRefsBySurface, contractTarget, feasibility.consumed_component_binding_refs);
+                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
                         validateSymbolicCoverageClaims(contract, contractTarget, indexedTarget);
                         validateBlockerBindings(contract, contractTarget, indexedTarget);
                     }
@@ -97,7 +115,7 @@ export function createLongTaskDesignHandoffConsumer(contract, sourceItems = [])
                         };
                         validateTargetIdentity(contractTarget, indexedTarget);
                         const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
-                        recordFeasibilityBindingAttribution(feasibilityBindingRefsBySurface, contractTarget, feasibility.consumed_component_binding_refs);
+                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
                         validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
                         validateCoverageClaims(contract, contractTarget, indexedTarget);
                         validateBlockerBindings(contract, contractTarget, indexedTarget);
@@ -120,27 +138,33 @@ export function createLongTaskDesignHandoffConsumer(contract, sourceItems = [])
                 if (validationErrors.has(contractTarget.target.key))
                     throw validationErrors.get(contractTarget.target.key);
             }
-            validateSurfaceFeasibilityBindingAttribution(contractTargets, feasibilityBindingRefsBySurface);
+            validateSurfaceFeasibilityBindingAttribution(contractTargets, feasibilityBindingAttributionBySurface);
             if (unbound.length)
                 invalid("handoff_target_unbound", unbound[0]);
         },
     };
 }
-function recordFeasibilityBindingAttribution(bySurface, contractTarget, bindingRefs) {
+function recordFeasibilityBindingAttribution(bySurface, contractTarget, result) {
     const key = surfaceBindingIdentity(contractTarget);
-    const consumed = bySurface.get(key) ?? new Set();
-    for (const bindingRef of bindingRefs)
-        consumed.add(bindingRef);
-    bySurface.set(key, consumed);
+    const attribution = bySurface.get(key) ?? {
+        modes: new Set(),
+        consumed_component_binding_refs: new Set(),
+    };
+    attribution.modes.add(result.attribution_mode);
+    for (const bindingRef of result.consumed_component_binding_refs)
+        attribution.consumed_component_binding_refs.add(bindingRef);
+    bySurface.set(key, attribution);
 }
 function validateSurfaceFeasibilityBindingAttribution(contractTargets, bySurface) {
     const surfaces = new Map();
     for (const contractTarget of contractTargets)
         surfaces.set(surfaceBindingIdentity(contractTarget), contractTarget);
     for (const [surfaceKey, contractTarget] of surfaces) {
-        const consumed = bySurface.get(surfaceKey) ?? new Set();
+        const attribution = bySurface.get(surfaceKey);
+        if (!attribution?.modes.has("feasibility"))
+            continue;
         for (const bindingRef of contractTarget.binding.component_binding_refs)
-            if (!consumed.has(bindingRef))
+            if (!attribution.consumed_component_binding_refs.has(bindingRef))
                 invalid("feasibility_component_binding_unattributed", `${contractTarget.binding.key}:${bindingRef}`);
     }
 }

package/dist/lib/long-task-design-resource-method-binding.js

@@ -62,6 +62,8 @@ export function validateSymbolicVerificationMethodBindings(contract, contractTar
         const expected = preflight.manifest.semantic_proof_obligations
             .filter((obligation) => obligation.method === binding.method)
             .map((obligation) => symbolicRuleExpectation(preflight, obligation.key));
+        const sourceItems = new Set(expected.flatMap((expectation) => preflight.manifest.fact_rules.find((item) => item.key === expectation.fact_rule_ref)?.source_item_refs ?? []));
+        validateMethodAssertionClaimOwnership(target, assertion.claims, sourceItems, claimsBySourceItem, "v2_verification_method_claim_not_owned", `${target.key}:${binding.method}`);
         assertCanonicalRowsByKey(binding.rule_expectations, expected, "obligation_ref", "v2_rule_expectations_mismatch", `${target.key}:${binding.method}`);
         for (const expectation of expected) {
             const rule = preflight.manifest.fact_rules.find((item) => item.key === expectation.fact_rule_ref);
@@ -156,6 +158,7 @@ export function validateVerificationMethodBindings(target, check, facts, proofs,
         const sourceItems = new Set(facts
             .filter((fact) => proofs.some((proof) => proof.fact_ref === fact.key && proof.method === binding.method))
             .flatMap((fact) => fact.source_item_refs));
+        validateMethodAssertionClaimOwnership(target, assertion.claims, sourceItems, claimsBySourceItem, "verification_method_claim_not_owned", `${target.key}:${binding.method}`);
         for (const sourceItemRef of sourceItems)
             for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
                 if (!assertedClaims.has(claimRef))
@@ -185,6 +188,15 @@ function claimsAssertedByRootOrMethod(target, check, methodClaims) {
     const rootAssertion = check.positive_assertions.find((item) => item.key === target.conformance_assertion_ref);
     return new Set([...(rootAssertion?.claims ?? []), ...methodClaims]);
 }
+function validateMethodAssertionClaimOwnership(target, methodClaims, sourceItems, claimsBySourceItem, code, detail) {
+    const allowedClaims = new Set(target.claim_refs);
+    for (const sourceItemRef of sourceItems)
+        for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
+            allowedClaims.add(claimRef);
+    for (const claimRef of methodClaims)
+        if (!allowedClaims.has(claimRef))
+            invalid(code, `${detail}:${claimRef}`);
+}
 function designFactExpectation(indexed, factRef, proofRef) {
     const handoff = indexed.preflight.handoff;
     const fact = handoff.facts.find((item) => item.key === factRef);

package/dist/lib/long-task-effective-external-takeover.d.ts

@@ -0,0 +1,15 @@
+import type { ClaimApplicabilityV2, CompiledOutcomeV2, DeliveryContractV2, DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
+export declare function effectiveBlockingExternalRows(reachability: AcceptanceReachabilityV1 | null | undefined): AcceptanceReachabilityV1["effective_external_routes"];
+export declare function outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome: DeliveryOutcomeV2, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
+export declare function resultApplicabilityEffectivelyExternallyBlocked(reachability: AcceptanceReachabilityV1 | null | undefined, outcomeKey: string, applicabilityRef: string, targetRef: string): boolean;
+export declare function resultApplicabilityProfiles(outcome: Pick<CompiledOutcomeV2, "applicability" | "product">, options?: {
+    target_ref?: string;
+    journey_role?: ClaimApplicabilityV2["journey_role"];
+}): ClaimApplicabilityV2[];
+export declare function outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome: Pick<CompiledOutcomeV2, "key" | "applicability" | "product">, reachability: AcceptanceReachabilityV1 | null | undefined, options?: {
+    target_ref?: string;
+    journey_role?: ClaimApplicabilityV2["journey_role"];
+}): boolean;
+export declare function outcomeResultFullyEffectivelyExternallyBlocked(outcome: Pick<CompiledOutcomeV2, "key" | "applicability" | "product">, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
+export declare function allOutcomeResultsFullyEffectivelyExternallyBlocked(contract: Pick<DeliveryContractV2, "outcomes">, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;

package/dist/lib/long-task-effective-external-takeover.js

@@ -0,0 +1,109 @@
+import { claimObligationRef, sameSet, } from "./long-task-acceptance-reachability-helpers.js";
+export function effectiveBlockingExternalRows(reachability) {
+    return (reachability?.effective_external_routes ?? []).filter((row) => row.authority === "external_confirmation" &&
+        row.status === "external_fulfillable" &&
+        row.completion_role === "blocking" &&
+        row.acceptance_effect === "required");
+}
+function effectivePopulationRows(outcomeKey, reachability) {
+    return effectiveBlockingExternalRows(reachability).filter((row) => row.outcome_key === outcomeKey &&
+        row.proof_surface === "population_coverage" &&
+        row.method === "population_set_equality" &&
+        row.fact_ref !== null &&
+        row.proof_ref !== null &&
+        row.source_obligation_ref === row.proof_ref &&
+        row.required_evidence_capabilities.includes("semantic_fact") &&
+        row.required_evidence_capabilities.includes("population_coverage"));
+}
+function requiredExternalPopulationProofs(outcome, localClaimRef) {
+    return outcome.semantic_fact_bindings.facts
+        .filter((binding) => binding.claim_ref === localClaimRef)
+        .flatMap((factBinding) => outcome.semantic_fact_bindings.proofs
+        .filter((proofBinding) => proofBinding.fact_ref === factBinding.fact_ref &&
+        proofBinding.authority === "external_confirmation" &&
+        proofBinding.method === "population_set_equality" &&
+        proofBinding.proof_surface === "population_coverage")
+        .map((proofBinding) => ({
+        factBinding,
+        proofBinding,
+        confirmationRef: proofBinding.authority === "external_confirmation"
+            ? proofBinding.confirmation_ref
+            : null,
+    })));
+}
+function populationProofRequirementEffectivelyBlocked(outcome, requirement, rows) {
+    const { factBinding, proofBinding, confirmationRef } = requirement;
+    const profile = outcome.applicability.find((candidate) => candidate.key === factBinding.applicability_ref);
+    if (!profile)
+        return false;
+    return (rows.filter((row) => row.claim_ref === `${outcome.key}.${factBinding.claim_ref}` &&
+        row.local_claim_ref === factBinding.claim_ref &&
+        row.applicability_ref === factBinding.applicability_ref &&
+        row.target_ref === profile.target_ref &&
+        row.fact_ref === factBinding.fact_ref &&
+        row.proof_ref === proofBinding.proof_ref &&
+        row.source_obligation_ref === proofBinding.proof_ref &&
+        row.method === proofBinding.method &&
+        row.proof_surface === proofBinding.proof_surface &&
+        row.confirmation_ref === confirmationRef &&
+        sameSet(row.required_evidence_capabilities, proofBinding.evidence_capabilities)).length === 1);
+}
+function populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows) {
+    const requirements = requiredExternalPopulationProofs(outcome, localClaimRef);
+    return (requirements.length > 0 &&
+        requirements.every((requirement) => populationProofRequirementEffectivelyBlocked(outcome, requirement, rows)));
+}
+export function outcomePopulationSemanticProofFullyEffectivelyExternallyBlocked(outcome, reachability) {
+    const population = outcome.acceptance.population;
+    if (!population?.claims.length)
+        return false;
+    const rows = effectivePopulationRows(outcome.key, reachability);
+    return population.claims.every((localClaimRef) => populationClaimFullyEffectivelyExternallyBlocked(outcome, localClaimRef, rows));
+}
+function effectiveBlockingResultRows(reachability, outcomeKey) {
+    const claimRef = `${outcomeKey}.result`;
+    return effectiveBlockingExternalRows(reachability).filter((row) => {
+        const ordinaryObligationRef = claimObligationRef(claimRef, row.applicability_ref, row.proof_surface);
+        return (row.outcome_key === outcomeKey &&
+            row.claim_ref === claimRef &&
+            row.local_claim_ref === "result" &&
+            row.fact_ref === null &&
+            row.proof_ref === null &&
+            row.source_obligation_ref === ordinaryObligationRef);
+    });
+}
+export function resultApplicabilityEffectivelyExternallyBlocked(reachability, outcomeKey, applicabilityRef, targetRef) {
+    const rows = effectiveBlockingResultRows(reachability, outcomeKey).filter((row) => row.applicability_ref === applicabilityRef &&
+        row.target_ref === targetRef);
+    return rows.length === 1;
+}
+export function resultApplicabilityProfiles(outcome, options = {}) {
+    const profiles = new Map(outcome.applicability.map((profile) => [profile.key, profile]));
+    return outcome.product.result_applicability_refs
+        .map((ref) => profiles.get(ref))
+        .filter((profile) => Boolean(profile))
+        .filter((profile) => (options.target_ref === undefined ||
+        profile.target_ref === options.target_ref) &&
+        (options.journey_role === undefined ||
+            profile.journey_role === options.journey_role));
+}
+export function outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability, options = {}) {
+    const profiles = resultApplicabilityProfiles(outcome, options);
+    if (!profiles.length)
+        return false;
+    const requiredRefs = new Set(profiles.map((profile) => profile.key));
+    const rows = effectiveBlockingResultRows(reachability, outcome.key).filter((row) => requiredRefs.has(row.applicability_ref));
+    return (rows.length === profiles.length &&
+        profiles.every((profile) => rows.filter((row) => row.applicability_ref === profile.key &&
+            row.target_ref === profile.target_ref).length === 1));
+}
+export function outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability) {
+    if (resultApplicabilityProfiles(outcome).length !==
+        outcome.product.result_applicability_refs.length)
+        return false;
+    return outcomeResultScopeFullyEffectivelyExternallyBlocked(outcome, reachability);
+}
+export function allOutcomeResultsFullyEffectivelyExternallyBlocked(contract, reachability) {
+    return (contract.outcomes.length > 0 &&
+        contract.outcomes.every((outcome) => outcomeResultFullyEffectivelyExternallyBlocked(outcome, reachability)));
+}

package/dist/lib/long-task-effective-external-ui-takeover.d.ts

@@ -0,0 +1,5 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
+type DeliveryOutcomeV2 = DeliveryContractV2["outcomes"][number];
+export declare function outcomeUiProofFullyEffectivelyExternallyBlocked(contract: DeliveryContractV2, outcome: DeliveryOutcomeV2, reachability: AcceptanceReachabilityV1 | null | undefined): boolean;
+export {};

package/dist/lib/long-task-effective-external-ui-takeover.js

@@ -0,0 +1,117 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
+import { designFactObligationDescriptors } from "./long-task-design-obligation.js";
+import { effectiveBlockingExternalRows } from "./long-task-effective-external-takeover.js";
+function designObligationEffectivelyBlocked(descriptor, rows) {
+    return (rows.filter((row) => row.source_obligation_ref === descriptor.source_obligation_ref &&
+        row.claim_ref === descriptor.claim_ref &&
+        row.local_claim_ref === descriptor.local_claim_ref &&
+        row.applicability_ref === descriptor.applicability_ref &&
+        row.proof_surface === descriptor.proof_surface &&
+        row.fact_ref === descriptor.fact_ref &&
+        row.proof_ref === descriptor.source_obligation_ref).length === 1);
+}
+function claimApplicabilityKey(localClaimRef, applicabilityRef) {
+    return `${localClaimRef}\0${applicabilityRef}`;
+}
+function controlClaimApplicabilities(outcome) {
+    const entries = new Set();
+    for (const control of outcome.product.controls)
+        for (const fact of controlFieldFacts(control))
+            for (const applicabilityRef of fact.applicability_refs)
+                entries.add(claimApplicabilityKey(`control.${control.key}.${fact.claim_field}`, applicabilityRef));
+    return entries;
+}
+function designTargetAssertionRefs(target) {
+    return new Set([
+        target.conformance_assertion_ref,
+        ...target.verification_method_bindings.map((binding) => binding.assertion_ref),
+        ...(target.symbolic_method_bindings ?? []).map((binding) => binding.assertion_ref),
+        ...(target.symbolic_certificate_binding
+            ? [target.symbolic_certificate_binding.assertion_ref]
+            : []),
+    ]);
+}
+function addDesignAssertionClaimApplicabilities(entries, check, assertionRefs) {
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ])
+        if (assertionRefs.has(assertion.key) &&
+            assertion.claims.length === 1 &&
+            assertion.applicability_ref)
+            entries.add(claimApplicabilityKey(assertion.claims[0], assertion.applicability_ref));
+}
+function allUiClaimApplicabilities(outcome) {
+    const entries = controlClaimApplicabilities(outcome);
+    for (const surface of outcome.product.surface_bindings)
+        for (const target of surface.design_targets) {
+            const check = outcome.acceptance.checks.find((candidate) => candidate.key === target.conformance_check_ref);
+            if (!check)
+                return null;
+            addDesignAssertionClaimApplicabilities(entries, check, designTargetAssertionRefs(target));
+        }
+    return entries;
+}
+function matchingCoordinates(outcome, localClaimRef, applicabilityRef, targetRef) {
+    return outcome.acceptance.checks.flatMap((check) => [...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => assertionMatchesClaimApplicability(assertion, localClaimRef, applicabilityRef))
+        .map(() => ({
+        local_claim_ref: localClaimRef,
+        applicability_ref: applicabilityRef,
+        target_ref: targetRef,
+        proof_surface: check.proof_surface,
+    })));
+}
+function assertionMatchesClaimApplicability(assertion, localClaimRef, applicabilityRef) {
+    return (assertion.claims.length === 1 &&
+        assertion.claims[0] === localClaimRef &&
+        assertion.applicability_ref === applicabilityRef);
+}
+function coordinateKey(coordinate) {
+    return [
+        coordinate.local_claim_ref,
+        coordinate.applicability_ref,
+        coordinate.target_ref,
+        coordinate.proof_surface,
+    ].join("\0");
+}
+function uiClaimCoordinates(outcome) {
+    const entries = allUiClaimApplicabilities(outcome);
+    if (!entries)
+        return null;
+    const profiles = new Map(outcome.applicability.map((profile) => [profile.key, profile]));
+    const coordinates = new Map();
+    for (const entry of entries) {
+        const [localClaimRef, applicabilityRef] = entry.split("\0");
+        const profile = profiles.get(applicabilityRef);
+        if (!profile)
+            return null;
+        const matching = matchingCoordinates(outcome, localClaimRef, applicabilityRef, profile.target_ref);
+        if (!matching.length)
+            return null;
+        for (const coordinate of matching)
+            coordinates.set(coordinateKey(coordinate), coordinate);
+    }
+    return coordinates;
+}
+function ordinaryUiCoordinateEffectivelyBlocked(outcomeKey, coordinate, rows) {
+    return (rows.filter((row) => row.claim_ref === `${outcomeKey}.${coordinate.local_claim_ref}` &&
+        row.local_claim_ref === coordinate.local_claim_ref &&
+        row.applicability_ref === coordinate.applicability_ref &&
+        row.target_ref === coordinate.target_ref &&
+        row.proof_surface === coordinate.proof_surface &&
+        row.fact_ref === null &&
+        row.proof_ref === null).length === 1);
+}
+export function outcomeUiProofFullyEffectivelyExternallyBlocked(contract, outcome, reachability) {
+    const rows = effectiveBlockingExternalRows(reachability).filter((row) => row.outcome_key === outcome.key);
+    const designObligations = designFactObligationDescriptors(contract).filter((descriptor) => descriptor.outcome_key === outcome.key);
+    if (!designObligations.every((descriptor) => designObligationEffectivelyBlocked(descriptor, rows)))
+        return false;
+    const coordinates = uiClaimCoordinates(outcome);
+    if (!coordinates)
+        return false;
+    if (!designObligations.length && !coordinates.size)
+        return false;
+    return [...coordinates.values()].every((coordinate) => ordinaryUiCoordinateEffectivelyBlocked(outcome.key, coordinate, rows));
+}