project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,114 @@
+import { DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA, deriveDesignResourceFeasibilityConditionScopeSha256, parseDesignResourceFeasibilityDecisionProjections, } from "./design-resource-implementation-feasibility-source-decision.js";
+import { createV1ImplementationFeasibilityTargetModel, createV2ImplementationFeasibilityTargetModel, } from "./design-resource-implementation-feasibility-model.js";
+import { matchingFeasibilityBindingKeys, validateFeasibilityBindingOwnerRoots, } from "./long-task-design-feasibility-binding-owners.js";
+import { validateFeasibilityBlockers, validateSelectedPlannedOwnerClaims, validateTechnicalDecisionClaim, } from "./long-task-design-feasibility-source-closure.js";
+import { invalid } from "./long-task-design-resource-method-binding.js";
+export function validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, options = {}) {
+    const document = preflight.technical_feasibility_documents.find((item) => item.target_ref === contractTarget.target.key);
+    if (!document) {
+        if (!contractTarget.binding.component_binding_refs.length)
+            invalid("componentless_surface_requires_blocker_only_feasibility", contractTarget.target.key);
+        return {
+            attribution_mode: "legacy",
+            consumed_component_binding_refs: [],
+        };
+    }
+    const model = feasibilityTargetModel(preflight, contractTarget.target.key);
+    const decisions = compiledDecisionSources(document, sourceItems);
+    const outcome = contract.outcomes.find((item) => item.key === contractTarget.outcome_key);
+    const bindingsByKey = new Map(outcome.technical.bindings.map((binding) => [binding.key, binding]));
+    const componentBindings = contractTarget.binding.component_binding_refs.map((bindingRef) => {
+        const binding = bindingsByKey.get(bindingRef);
+        if (!binding)
+            invalid("feasibility_component_binding_unknown", `${contractTarget.target.key}:${bindingRef}`);
+        return binding;
+    });
+    const routeBinding = bindingsByKey.get(contractTarget.binding.route_binding_ref);
+    if (!routeBinding)
+        invalid("feasibility_route_binding_unknown", `${contractTarget.target.key}:${contractTarget.binding.route_binding_ref}`);
+    const hasCandidateCells = document.component_family_cells.some((cell) => cell.feasible_realizations.length > 0);
+    const allCellsBlockerOnly = document.component_family_cells.length > 0 &&
+        document.component_family_cells.every((cell) => cell.feasible_realizations.length === 0 && cell.blocker_refs.length > 0);
+    if (!componentBindings.length && hasCandidateCells)
+        invalid("feasibility_component_binding_required", contractTarget.target.key);
+    if (!componentBindings.length && !allCellsBlockerOnly)
+        invalid("componentless_surface_requires_blocker_only_feasibility", contractTarget.target.key);
+    validateFeasibilityBindingOwnerRoots(document, componentBindings, routeBinding);
+    const consumedComponentBindings = new Set();
+    for (const cell of document.component_family_cells) {
+        const blockerOnly = cell.feasible_realizations.length === 0 && cell.blocker_refs.length > 0;
+        if (blockerOnly)
+            continue;
+        const matching = cell.feasible_realizations
+            .map((realization) => ({
+            realization,
+            bindingKeys: matchingFeasibilityBindingKeys(realization, componentBindings),
+        }))
+            .filter((candidate) => candidate.bindingKeys.size > 0);
+        const required = cell.required_realization.realization_ref;
+        if (required !== null &&
+            (matching.length !== 1 || matching[0].realization.key !== required))
+            invalid("feasibility_required_realization_binding_mismatch", `${cell.key}:${required}:${matching.map((item) => item.realization.key).join(",")}`);
+        if (required === null && matching.length === 0)
+            invalid("feasibility_realization_binding_missing", cell.key);
+        if (required === null && matching.length > 1)
+            invalid("feasibility_realization_binding_ambiguous", `${cell.key}:${matching.map((item) => item.realization.key).join(",")}`);
+        const selected = matching.length === 1 ? matching[0] : null;
+        if (selected)
+            for (const bindingKey of selected.bindingKeys)
+                consumedComponentBindings.add(bindingKey);
+        if (required !== null)
+            validateTechnicalDecisionClaim(contract, contractTarget, decisions, cell.required_realization.technical_authority_source_refs, {
+                schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+                mode: "required_realization",
+                target_ref: cell.target_ref,
+                component_family_ref: cell.component_family_ref,
+                condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, cell.condition_profile_ref),
+                realization_ref: required,
+            }, `required_realization:${cell.key}`);
+        if (selected)
+            validateSelectedPlannedOwnerClaims(contract, contractTarget, document, model, decisions, selected.realization, componentBindings, cell);
+    }
+    if (!options.deferComponentBindingAttribution)
+        validateComponentBindingAttribution(contractTarget, consumedComponentBindings);
+    validateFeasibilityBlockers(contract, contractTarget, document, model, decisions);
+    return {
+        attribution_mode: "feasibility",
+        consumed_component_binding_refs: [...consumedComponentBindings].sort(),
+    };
+}
+function validateComponentBindingAttribution(contractTarget, consumedComponentBindings) {
+    for (const bindingRef of contractTarget.binding.component_binding_refs)
+        if (!consumedComponentBindings.has(bindingRef))
+            invalid("feasibility_component_binding_unattributed", `${contractTarget.target.key}:${bindingRef}`);
+}
+function feasibilityTargetModel(preflight, targetRef) {
+    if ("preflight_schema_version" in preflight) {
+        const target = preflight.handoff.targets.find((candidate) => candidate.key === targetRef);
+        return createV2ImplementationFeasibilityTargetModel(target, preflight.manifest);
+    }
+    const target = preflight.handoff.targets.find((candidate) => candidate.key === targetRef);
+    return createV1ImplementationFeasibilityTargetModel(preflight.handoff, target);
+}
+function compiledDecisionSources(document, sourceItems) {
+    const index = new Map();
+    for (const record of document.source_records) {
+        if (record.locator.kind !== "source_item")
+            continue;
+        const item = sourceItems.find((candidate) => candidate.source_path === record.path &&
+            candidate.key === record.locator.value);
+        if (!item)
+            invalid("feasibility_source_item_not_declared", `${record.key}:${record.path}#${record.locator.value}`);
+        if (item.text_sha256 !== record.locator.text_sha256)
+            invalid("feasibility_source_item_digest_mismatch", `${record.key}:${record.locator.text_sha256}:${item.text_sha256}`);
+        index.set(record.key, {
+            source_record_ref: record.key,
+            source_path: record.path,
+            source_item_key: item.key,
+            source_item_kind: item.kind,
+            text_sha256: item.text_sha256,
+            projections: parseDesignResourceFeasibilityDecisionProjections(record.path, item.key, item.normalized_text),
+        });
+    }
+    return index;
+}

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

@@ -0,0 +1,11 @@
+import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
+import { type DesignResourceFeasibilityDecisionProjection, type DesignResourceFeasibilityDecisionSourceIndex } from "./design-resource-implementation-feasibility-source-decision.js";
+import type { DesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DeliveryBindingV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { ContractDesignTarget } from "./long-task-design-resource-handoff.js";
+type FeasibilityCell = DesignResourceImplementationFeasibilityV1["component_family_cells"][number];
+type FeasibleRealization = FeasibilityCell["feasible_realizations"][number];
+export declare function validateSelectedPlannedOwnerClaims(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, decisions: DesignResourceFeasibilityDecisionSourceIndex, realization: FeasibleRealization, bindings: DeliveryBindingV2[], cell: FeasibilityCell): void;
+export declare function validateTechnicalDecisionClaim(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, decisions: DesignResourceFeasibilityDecisionSourceIndex, sourceRefs: string[], expectation: DesignResourceFeasibilityDecisionProjection, label: string): void;
+export declare function validateFeasibilityBlockers(contract: DeliveryContractV2, contractTarget: ContractDesignTarget, document: DesignResourceImplementationFeasibilityV1, model: DesignResourceImplementationFeasibilityTargetModel, decisions: DesignResourceFeasibilityDecisionSourceIndex): void;
+export {};

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

@@ -0,0 +1,87 @@
+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) {
+        if (owner.kind !== "planned_logical_owner")
+            continue;
+        if (!bindings.some((binding) => binding.existence === "planned" &&
+            (binding.key === owner.locator || binding.target === owner.locator)))
+            continue;
+        validateTechnicalDecisionClaim(contract, contractTarget, decisions, owner.authorization_source_refs, {
+            schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+            mode: "planned_owner_authorization",
+            target_ref: cell.target_ref,
+            component_family_ref: cell.component_family_ref,
+            condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, cell.condition_profile_ref),
+            owner_locator: owner.locator,
+        }, `planned_owner:${cell.key}:${owner.locator}`);
+    }
+}
+export function validateTechnicalDecisionClaim(contract, contractTarget, decisions, sourceRefs, expectation, label) {
+    const source = requireDecisionSource(sourceRefs, decisions, expectation, label, ["technical_obligation"], true);
+    const claim = exactSourceClaim(contract, source, label);
+    const validOutcomeClaim = claim.disposition.type === "claim" &&
+        claim.disposition.refs.some((ref) => ref.startsWith(`${contractTarget.outcome_key}.`));
+    if (!validOutcomeClaim && claim.disposition.type !== "global_constraint")
+        invalid("feasibility_technical_decision_claim_disposition_invalid", `${label}:${claim.key}:${claim.disposition.type}`);
+}
+export function validateFeasibilityBlockers(contract, contractTarget, document, model, decisions) {
+    for (const blocker of document.blockers) {
+        const source = requireDecisionSource(blocker.source_record_refs, decisions, {
+            schema_version: DESIGN_RESOURCE_FEASIBILITY_DECISION_SCHEMA,
+            mode: "feasibility_blocker",
+            target_ref: blocker.target_ref,
+            component_family_ref: blocker.component_family_ref,
+            condition_scope_sha256: deriveDesignResourceFeasibilityConditionScopeSha256(document, model, blocker.condition_profile_ref),
+            blocker_ref: blocker.key,
+            substrate_observation_refs: blocker.substrate_observation_refs,
+        }, `blocker:${blocker.key}`, ["decision", "external_confirmation"], false);
+        const claim = exactSourceClaim(contract, source, `blocker:${blocker.key}`);
+        if (source.source_item_kind === "decision") {
+            if (claim.disposition.type !== "decision_required")
+                invalid("feasibility_blocker_decision_required", `${blocker.key}:${claim.key}:${claim.disposition.type}`);
+            continue;
+        }
+        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.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) {
+    try {
+        return requireExactFeasibilityDecisionProjection(sourceRefs, decisions, expectation, label, { allReferencesMustBeSourceItems, allowedItemKinds });
+    }
+    catch (error) {
+        invalid("feasibility_source_decision_invalid", `${label}:${message(error)}`);
+    }
+}
+function exactSourceClaim(contract, source, label) {
+    if (!contract.task.source_paths.includes(source.source_path))
+        invalid("feasibility_authority_source_not_declared", `${label}:${source.source_path}`);
+    const sourceRef = `${source.source_path}#${source.source_item_key}`;
+    const matching = contract.source_claims.filter((claim) => claim.source_ref === sourceRef);
+    if (matching.length !== 1)
+        invalid("feasibility_authority_claim_count", `${label}:${sourceRef}:${matching.length}`);
+    return matching[0];
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -1,6 +1,6 @@
 import type { DesignResourceHandoffPreflightV1, DesignResourceHandoffTargetV1 } from "./design-resource-handoff-types.js";
 import type { DesignResourceHandoffPreflightV2 } from "./design-resource-symbolic-fact-types.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
 export interface ContractDesignTarget {
     outcome_key: string;
     binding: DeliveryContractV2["outcomes"][number]["product"]["surface_bindings"][number];
@@ -14,5 +14,7 @@ export interface LongTaskDesignHandoffConsumer {
     consume(preflight: DesignResourceHandoffPreflightV1 | DesignResourceHandoffPreflightV2): void;
     finish(): void;
 }
-export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string): Promise<void>;
-export declare function createLongTaskDesignHandoffConsumer(contract: DeliveryContractV2): LongTaskDesignHandoffConsumer;
+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

@@ -6,8 +6,10 @@ import { preflightParsedDesignResourceHandoffAny } from "./design-resource-hando
 import { assertSameSet, designSourceItemClaims, invalid, validateTargetIdentity, validateSymbolicTargetIdentity, validateSymbolicVerificationMethodBindings, validateVerificationMethodBindings, } from "./long-task-design-resource-method-binding.js";
 import { validateLongTaskDesignTargetCapabilities } from "./long-task-design-target-capabilities.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-export async function validateLongTaskDesignResourceHandoffs(contract, repository) {
-    const consumer = createLongTaskDesignHandoffConsumer(contract);
+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;
@@ -15,11 +17,28 @@ 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 createLongTaskDesignHandoffConsumer(contract) {
+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) => ({
         outcome_key: outcome.key,
         binding,
@@ -29,6 +48,7 @@ export function createLongTaskDesignHandoffConsumer(contract) {
     const indexedTargetKeys = new Set();
     const consumed = new Set();
     const validationErrors = new Map();
+    const feasibilityBindingAttributionBySurface = new Map();
     let duplicate = null;
     const unbound = [];
     const handoffSetIntegrity = createDesignResourceHandoffSetIntegrity(invalid);
@@ -54,6 +74,14 @@ export function createLongTaskDesignHandoffConsumer(contract) {
                 else
                     resourcePaths.set(resource.path, identity);
             }
+            for (const input of preflight.handoff.technical_feasibility_inputs) {
+                const identity = JSON.stringify(input);
+                const previous = resourcePaths.get(input.path);
+                if (previous && previous !== identity)
+                    recordCrossVersionIssue("handoff_set_feasibility_path_conflict", input.path);
+                else
+                    resourcePaths.set(input.path, identity);
+            }
             if (!("preflight_schema_version" in preflight))
                 handoffSetIntegrity.consume(preflight);
             for (const target of preflight.handoff.targets) {
@@ -75,6 +103,8 @@ export function createLongTaskDesignHandoffConsumer(contract) {
                             target,
                         };
                         validateSymbolicTargetIdentity(contractTarget, indexedTarget);
+                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
+                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
                         validateSymbolicCoverageClaims(contract, contractTarget, indexedTarget);
                         validateBlockerBindings(contract, contractTarget, indexedTarget);
                     }
@@ -84,6 +114,8 @@ export function createLongTaskDesignHandoffConsumer(contract) {
                             target: target,
                         };
                         validateTargetIdentity(contractTarget, indexedTarget);
+                        const feasibility = validateLongTaskDesignFeasibilityBindings(contract, contractTarget, preflight, sourceItems, { deferComponentBindingAttribution: true });
+                        recordFeasibilityBindingAttribution(feasibilityBindingAttributionBySurface, contractTarget, feasibility);
                         validateLongTaskDesignTargetCapabilities(contract, contractTarget, indexedTarget);
                         validateCoverageClaims(contract, contractTarget, indexedTarget);
                         validateBlockerBindings(contract, contractTarget, indexedTarget);
@@ -106,11 +138,39 @@ export function createLongTaskDesignHandoffConsumer(contract) {
                 if (validationErrors.has(contractTarget.target.key))
                     throw validationErrors.get(contractTarget.target.key);
             }
+            validateSurfaceFeasibilityBindingAttribution(contractTargets, feasibilityBindingAttributionBySurface);
             if (unbound.length)
                 invalid("handoff_target_unbound", unbound[0]);
         },
     };
 }
+function recordFeasibilityBindingAttribution(bySurface, contractTarget, result) {
+    const key = surfaceBindingIdentity(contractTarget);
+    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 attribution = bySurface.get(surfaceKey);
+        if (!attribution?.modes.has("feasibility"))
+            continue;
+        for (const bindingRef of contractTarget.binding.component_binding_refs)
+            if (!attribution.consumed_component_binding_refs.has(bindingRef))
+                invalid("feasibility_component_binding_unattributed", `${contractTarget.binding.key}:${bindingRef}`);
+    }
+}
+function surfaceBindingIdentity(contractTarget) {
+    return `${contractTarget.outcome_key}\0${contractTarget.binding.key}`;
+}
 function validateSymbolicCoverageClaims(contract, contractTarget, indexed) {
     const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
     const rows = indexed.preflight.handoff.coverage.filter((row) => row.target_ref === contractTarget.target.key);

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

@@ -10,7 +10,10 @@ export function validateTargetIdentity(contractTarget, indexed) {
     assertSameSet(target.condition_keys, handoffTarget.condition_refs, "target_conditions_mismatch", target.key);
     const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
         .path);
-    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths], "target_source_paths_mismatch", target.key);
+    const feasibilityPaths = indexed.preflight.handoff.technical_feasibility_inputs
+        .filter((item) => item.target_ref === handoffTarget.key)
+        .map((item) => item.path);
+    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths, ...feasibilityPaths], "target_source_paths_mismatch", target.key);
 }
 export function validateSymbolicTargetIdentity(contractTarget, indexed) {
     const { target } = contractTarget;
@@ -25,7 +28,10 @@ export function validateSymbolicTargetIdentity(contractTarget, indexed) {
         invalid("v2_ground_method_bindings_forbidden", target.key);
     const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
         .path);
-    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths], "target_source_paths_mismatch", target.key);
+    const feasibilityPaths = indexed.preflight.handoff.technical_feasibility_inputs
+        .filter((item) => item.target_ref === handoffTarget.key)
+        .map((item) => item.path);
+    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths, ...feasibilityPaths], "target_source_paths_mismatch", target.key);
 }
 export function validateSymbolicVerificationMethodBindings(contract, contractTarget, indexed, claimsBySourceItem) {
     const target = contractTarget.target;
@@ -56,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);
@@ -150,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))
@@ -179,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;