project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/lib/long-task-acceptance-reachability-types.d.ts

@@ -0,0 +1,91 @@
+import type { CompiledClaimsV2 } from "./long-task-claims.js";
+import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityV2, ProofSurface } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export type AcceptanceReachabilityStatusV1 = "machine_admitted" | "external_fulfillable" | "unreachable";
+export interface AcceptanceObligationReachabilityV1 {
+    obligation_ref: string;
+    source_obligation_ref: string;
+    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: EvidenceCapabilityV2[];
+    authority: "machine" | "external_confirmation" | "none";
+    confirmation_ref: string | null;
+    status: AcceptanceReachabilityStatusV1;
+    reason: string | null;
+    session_group: string | null;
+}
+export interface AcceptanceReachabilityV1 {
+    completion_authority: DeliveryContractV2["task"]["target_profile"]["completion_authority"];
+    total: number;
+    machine_admitted: number;
+    external_fulfillable: number;
+    unreachable: number;
+    obligations: AcceptanceObligationReachabilityV1[];
+    effective_external_routes: EffectiveExternalObligationV1[];
+}
+export interface MachineAuthorityRouteV1 {
+    check_key: string;
+    assertion_key: string;
+    proof_surface: ProofSurface;
+    method?: string;
+    required_evidence_capabilities: EvidenceCapabilityV2[];
+    semantic_identity?: string | null;
+}
+export interface ExternalAuthorityRouteV1 {
+    confirmation_ref: string;
+    obligation_key?: string;
+    proof_surface: ProofSurface;
+    method?: string;
+    required_evidence_capabilities?: EvidenceCapabilityV2[];
+    advisory_to_machine?: boolean;
+    authority_ambiguous?: boolean;
+    authority_unresolved?: boolean;
+    expected_authority_ref?: string;
+    semantic_identity?: string | null;
+}
+export interface ObligationAuthorityCandidatesV1 {
+    source_obligation_ref: string;
+    proof_surface_selection?: "required" | "optional";
+    machine_candidates: MachineAuthorityRouteV1[];
+    external_candidates: ExternalAuthorityRouteV1[];
+}
+export interface ExpectedExternalObligation {
+    source_obligation_ref: string;
+    outcome_key: string | null;
+    claim_ref: string;
+    local_claim_ref: string;
+    applicability_ref: string;
+    fact_ref: string | null;
+    proof_ref: string | null;
+    method: string;
+    proof_surface: ProofSurface;
+    evidence_capabilities: EvidenceCapabilityV2[];
+    expected_authority_ref: string;
+    confirmation_ref: string;
+    required_polarity: "positive" | "negative";
+    completion_role: "blocking" | "advisory";
+    acceptance_effect: "required" | "none";
+    semantic_identity: string | null;
+    machine_obligation_ref: string | null;
+}
+export interface EffectiveExternalObligationV1 extends AcceptanceObligationReachabilityV1 {
+    local_claim_ref: string;
+    target_ref: string;
+    expected_authority_ref: string;
+    required_polarity: "positive" | "negative";
+    completion_role: "blocking" | "advisory";
+    acceptance_effect: "required" | "none";
+    semantic_identity: string;
+    machine_obligation_ref: string | null;
+}
+export interface AcceptanceReachabilityInputV1 {
+    contract: DeliveryContractV2;
+    claims: CompiledClaimsV2;
+    manifest: SemanticFactManifestV1;
+    compiled_checks: CompiledCheckV2[];
+}

package/dist/lib/long-task-acceptance-reachability-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/long-task-acceptance-reachability.d.ts

@@ -0,0 +1,4 @@
+import type { AcceptanceReachabilityInputV1, AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
+export type { AcceptanceObligationReachabilityV1, AcceptanceReachabilityStatusV1, AcceptanceReachabilityV1, EffectiveExternalObligationV1, } from "./long-task-acceptance-reachability-types.js";
+export declare function compileAcceptanceReachability(input: AcceptanceReachabilityInputV1): AcceptanceReachabilityV1;
+export declare function assertAcceptanceReachable(reachability: AcceptanceReachabilityV1): void;

package/dist/lib/long-task-acceptance-reachability.js

@@ -0,0 +1,115 @@
+import { compileClaimReachability } from "./long-task-acceptance-reachability-claims.js";
+import { compileDesignFactReachability } from "./long-task-acceptance-reachability-design.js";
+import { addUnboundBlockingConfirmationRows, validateExternalDeclarations, } from "./long-task-acceptance-reachability-external.js";
+import { compileSemanticFactReachability } from "./long-task-acceptance-reachability-semantic.js";
+import { effectiveExternalRouteRef, pendingExternalRow, } from "./long-task-acceptance-reachability-helpers.js";
+import { claimApplicabilityProfile } from "./long-task-applicability-identity.js";
+import { effectiveExternalObligationSemanticIdentity } from "./long-task-obligation-semantic-identity.js";
+export function compileAcceptanceReachability(input) {
+    const rows = [];
+    const expectedExternal = [];
+    compileClaimReachability(input, rows, expectedExternal);
+    compileSemanticFactReachability(input, rows, expectedExternal);
+    compileDesignFactReachability(input, rows, expectedExternal);
+    addUnboundBlockingConfirmationRows(input.contract, rows, expectedExternal);
+    const externalMatches = validateExternalDeclarations(input.contract, input.manifest, expectedExternal, input.compiled_checks);
+    const effectiveExternal = applyExternalReachability(input, rows, expectedExternal, externalMatches);
+    const sorted = rows.sort((left, right) => left.source_obligation_ref.localeCompare(right.source_obligation_ref));
+    return {
+        completion_authority: input.contract.task.target_profile.completion_authority,
+        total: sorted.length,
+        machine_admitted: sorted.filter((row) => row.status === "machine_admitted")
+            .length,
+        external_fulfillable: sorted.filter((row) => row.status === "external_fulfillable").length,
+        unreachable: sorted.filter((row) => row.status === "unreachable").length,
+        obligations: sorted,
+        effective_external_routes: effectiveExternal.sort((left, right) => effectiveExternalRouteRef(left.confirmation_ref, left.source_obligation_ref).localeCompare(effectiveExternalRouteRef(right.confirmation_ref, right.source_obligation_ref))),
+    };
+}
+export function assertAcceptanceReachable(reachability) {
+    const unreachable = reachability.obligations.filter((row) => row.status === "unreachable");
+    if (unreachable.length)
+        throw new Error(`acceptance_obligation_unreachable:${unreachable
+            .map((row) => `${row.source_obligation_ref}:${row.reason}`)
+            .join(",")}`);
+}
+function applyExternalReachability(input, rows, expectedExternal, matches) {
+    const effective = [];
+    for (const expected of expectedExternal) {
+        const row = rows.find((candidate) => candidate.source_obligation_ref === expected.source_obligation_ref &&
+            candidate.confirmation_ref === expected.confirmation_ref);
+        if (expected.completion_role === "blocking" &&
+            input.contract.task.target_profile.completion_authority === "machine_only") {
+            if (row) {
+                row.status = "unreachable";
+                row.reason = "completion_authority_machine_only";
+            }
+            continue;
+        }
+        const match = matches.get(effectiveExternalRouteRef(expected.confirmation_ref, expected.source_obligation_ref));
+        if (!match) {
+            if (row) {
+                row.status = "unreachable";
+                row.reason = "external_confirmation_decomposition_invalid";
+            }
+            else {
+                rows.push({
+                    ...pendingExternalRow(expected.source_obligation_ref, expected.outcome_key, expected.claim_ref, expected.applicability_ref, expected.fact_ref, expected.proof_ref, expected.method, expected.proof_surface, expected.evidence_capabilities, expected.confirmation_ref),
+                    authority: "none",
+                    reason: "external_confirmation_decomposition_invalid",
+                });
+            }
+            continue;
+        }
+        const applicability = claimApplicabilityProfile(input.contract, expected.outcome_key, expected.applicability_ref);
+        if (!applicability) {
+            if (row) {
+                row.status = "unreachable";
+                row.reason = "external_confirmation_decomposition_invalid";
+            }
+            continue;
+        }
+        const semanticIdentity = effectiveExternalObligationSemanticIdentity(input, expected);
+        if (!semanticIdentity) {
+            if (row) {
+                row.status = "unreachable";
+                row.reason = "external_confirmation_decomposition_invalid";
+            }
+            continue;
+        }
+        if (row) {
+            row.obligation_ref = match.obligation_key;
+            row.status = "external_fulfillable";
+            row.reason = null;
+            row.session_group = match.session_group;
+        }
+        effective.push({
+            obligation_ref: match.obligation_key,
+            source_obligation_ref: expected.source_obligation_ref,
+            outcome_key: expected.outcome_key,
+            claim_ref: expected.claim_ref,
+            local_claim_ref: expected.local_claim_ref,
+            applicability_ref: expected.applicability_ref,
+            target_ref: applicability.target_ref,
+            fact_ref: expected.fact_ref,
+            proof_ref: expected.proof_ref,
+            method: expected.method,
+            proof_surface: expected.proof_surface,
+            required_evidence_capabilities: [
+                ...expected.evidence_capabilities,
+            ].sort(),
+            expected_authority_ref: expected.expected_authority_ref,
+            required_polarity: expected.required_polarity,
+            authority: "external_confirmation",
+            confirmation_ref: expected.confirmation_ref,
+            status: "external_fulfillable",
+            reason: null,
+            session_group: match.session_group,
+            completion_role: expected.completion_role,
+            acceptance_effect: expected.acceptance_effect,
+            semantic_identity: semanticIdentity,
+            machine_obligation_ref: expected.machine_obligation_ref,
+        });
+    }
+    return effective;
+}

package/dist/lib/long-task-activation-validation.d.ts

@@ -1,16 +1,22 @@
 import type { AuthoringPreflightDiagnosticV1 } from "./long-task-authoring-preflight-types.js";
 import { type CompiledClaimsV2 } from "./long-task-claims.js";
 import type { CompiledCheckV2, CompiledOutcomeV2, CompiledSourceItemV2, ContextAuthoritySnapshotV2, DeliveryContractV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import { type ProofAdequacyByCheckV2 } from "./long-task-proof-adequacy.js";
 import { type RiskDecisionV2 } from "./long-task-risk.js";
+import { type AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability.js";
+import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
 export interface ActivationValidationResult {
     claims: CompiledClaimsV2 | null;
     risk: RiskDecisionV2 | null;
     source_hashes: Record<string, string> | null;
     source_items: CompiledSourceItemV2[] | null;
     context_snapshot: ContextAuthoritySnapshotV2 | null;
+    project_design_authority: DesignAuthorityIdentityV1 | null;
     workspace: WorkspaceManifestV2 | null;
     global_checks: CompiledCheckV2[];
     outcomes: CompiledOutcomeV2[];
+    proof_adequacy: ProofAdequacyByCheckV2 | null;
+    acceptance_reachability: AcceptanceReachabilityV1 | null;
 }
 export declare function validateContractForActivation(options: {
     contract: DeliveryContractV2;

package/dist/lib/long-task-activation-validation.js

@@ -1,13 +1,15 @@
-import { captureContextGraphSnapshot } from "./context-graph-snapshot.js";
+import { captureContextGraphSnapshotWithPhysicalFiles } from "./context-graph-snapshot.js";
 import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.js";
 import { compileProductClaimCoverage, } from "./long-task-claims.js";
 import { hashDeclaredFiles, validateCounterfactualPaths, validateTechnicalPaths, validateVerificationInputSeparation, } from "./long-task-delivery-preflight.js";
 import { validateClaimEvidenceSensitivity } from "./long-task-evidence-sensitivity-policy.js";
 import { validateSemanticConformance } from "./long-task-conformance-policy.js";
-import { deliveryContractStructureDiagnostics, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
+import { deliveryContractStructureDiagnostics, validateResolvedCompletionAuthorityClosure, validateDeliveryContractStructure, } from "./long-task-delivery-validation.js";
 import { validateRawExecutionObservationOwnership } from "./long-task-observation-ownership.js";
 import { validateLongTaskDesignResourceHandoffs } from "./long-task-design-resource-handoff.js";
+import { exactExternalDesignObligationRefs } from "./long-task-design-obligation.js";
 import { validateLongTaskSemanticFactClosure } from "./long-task-semantic-fact-closure.js";
+import { proofAdequacyCheckKey, validateLongTaskProofAdequacy, } from "./long-task-proof-adequacy.js";
 import { freezeDeliveryCheck } from "./long-task-runner-freeze.js";
 import { scopeDeliveryBindings } from "./long-task-scoped-binding.js";
 import { classifyLongTaskRisk, validateRiskProof, } from "./long-task-risk.js";
@@ -15,15 +17,21 @@ import { validateSourceContinuity } from "./long-task-source-continuity.js";
 import { compileSourceInventory } from "./long-task-source-inventory.js";
 import { validateSourceTargetContinuity } from "./long-task-source-target-continuity.js";
 import { validateSourceAnchors } from "./long-task-source-validation.js";
+import { assertAcceptanceReachable, compileAcceptanceReachability, } from "./long-task-acceptance-reachability.js";
+import { exactExternalClaimActualObligationRefsByAssertion } from "./long-task-acceptance-reachability-helpers.js";
 import { captureWorkspaceManifest, repoRelative, } from "./long-task-workspace.js";
 export async function validateContractForActivation(options) {
     const { contract, repository, workdir, mode } = options;
     const diagnostics = options.diagnostics ?? [];
+    const structureOptions = {
+        allowDeferredDesignComponentBindingClosure: true,
+        deferCompletionAuthorityClosure: true,
+    };
     if (mode === "collect")
-        for (const error of deliveryContractStructureDiagnostics(contract))
+        for (const error of deliveryContractStructureDiagnostics(contract, structureOptions))
             addDiagnosticError(diagnostics, error);
     else
-        validateDeliveryContractStructure(contract);
+        validateDeliveryContractStructure(contract, structureOptions);
     const claims = await attempt(mode, diagnostics, () => compileProductClaimCoverage(contract));
     if (mode === "fail_fast") {
         const decisions = contract.source_claims
@@ -45,15 +53,18 @@ export async function validateContractForActivation(options) {
             : undefined);
         return items;
     });
-    await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository));
+    const designHandoffs = await attempt(mode, diagnostics, () => validateLongTaskDesignResourceHandoffs(contract, repository, sourceItems ?? []));
+    const projectDesignAuthority = designHandoffs?.find((handoff) => handoff.project_design_authority_resolution.identity !== null)?.project_design_authority_resolution.identity ?? null;
     const risk = await attempt(mode, diagnostics, () => {
-        const decision = classifyLongTaskRisk(contract);
-        validateRiskProof(contract, decision);
-        return decision;
+        return classifyLongTaskRisk(contract);
     });
-    const context = await attempt(mode, diagnostics, () => captureContextGraphSnapshot(repository, contract.task.context_refs, contract.task.context_snapshot_mode));
-    const semanticFactClosure = sourceItems && context
-        ? await attempt(mode, diagnostics, () => validateLongTaskSemanticFactClosure(contract, repository, sourceItems, context.files))
+    const contextCapture = await attempt(mode, diagnostics, () => captureContextGraphSnapshotWithPhysicalFiles(repository, contract.task.context_refs, contract.task.context_snapshot_mode));
+    const context = contextCapture?.snapshot ?? null;
+    const semanticFactClosure = sourceItems && contextCapture
+        ? await attempt(mode, diagnostics, () => validateLongTaskSemanticFactClosure(contract, repository, sourceItems, contextCapture, designHandoffs ?? undefined))
+        : null;
+    const proofAdequacy = semanticFactClosure
+        ? await attempt(mode, diagnostics, () => validateLongTaskProofAdequacy(contract, semanticFactClosure.manifest, semanticFactClosure.expectations_by_check))
         : null;
     const workdirRelative = repoRelative(repository, workdir);
     const workspace = await attempt(mode, diagnostics, async () => {
@@ -64,45 +75,82 @@ export async function validateContractForActivation(options) {
     if (!workspace)
         return emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context);
     const observationAuthorityPaths = [
-        ...workspace.files
-            .map((file) => file.path)
-            .filter((file) => file === workdirRelative || file.startsWith(`${workdirRelative}/`)),
-        `${workdirRelative}/delivery-contract.yaml`,
-        ...Object.keys(sourceHashes ?? {}),
-        ...(context?.files ?? []),
-    ];
+        ...new Set([
+            ...workspace.files
+                .map((file) => file.path)
+                .filter((file) => file === workdirRelative || file.startsWith(`${workdirRelative}/`)),
+            `${workdirRelative}/delivery-contract.yaml`,
+            ...Object.keys(sourceHashes ?? {}),
+            ...(context?.files ?? []),
+            ...(designHandoffs ?? []).flatMap((handoff) => handoff.project_design_authority_resolution.member_paths),
+        ]),
+    ].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
     const globalChecks = [];
     for (const check of contract.global.acceptance.checks) {
         const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
         if (!executionTarget)
             continue;
-        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], contract.outcomes.flatMap((outcome) => scopeDeliveryBindings(outcome.key, outcome.technical.bindings)), contract.outcomes.flatMap((outcome) => outcome.product.owner.path_globs), sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), null, check.key);
+        const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, null, repository, workspace, executionTarget, contract.task.execution_targets, [], [], contract.outcomes.flatMap((outcome) => scopeDeliveryBindings(outcome.key, outcome.technical.bindings)), contract.outcomes.flatMap((outcome) => outcome.product.owner.path_globs), sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths, proofAdequacy?.[proofAdequacyCheckKey(null, check.key)], new Set(), exactExternalClaimActualObligationRefsByAssertion(contract, null, check, proofAdequacy?.[proofAdequacyCheckKey(null, check.key)]
+            ?.expected_authority_refs ?? {})), null, check.key);
         if (frozen)
             globalChecks.push(frozen);
     }
     const outcomes = [];
     for (const outcome of contract.outcomes) {
         const checks = [];
+        const blockedDesignAssertionRefsByCheck = new Map();
         for (const check of outcome.acceptance.checks) {
             const executionTarget = contract.task.execution_targets.find((target) => target.key === check.execution_target.target_ref);
             if (!executionTarget)
                 continue;
-            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargetsForCheck(outcome, check.key), semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths), outcome.key, check.key);
-            if (frozen)
+            const designTargets = designTargetsForCheck(outcome, check.key);
+            const externalDesignObligationRefs = exactExternalDesignObligationRefs(contract, outcome.key, check.key);
+            const externalClaimObligationRefsByAssertion = exactExternalClaimActualObligationRefsByAssertion(contract, outcome.key, check, proofAdequacy?.[proofAdequacyCheckKey(outcome.key, check.key)]
+                ?.expected_authority_refs ?? {});
+            const frozen = await attempt(mode, diagnostics, () => freezeDeliveryCheck(check, outcome.key, repository, workspace, executionTarget, contract.task.execution_targets, designTargets, semanticFactClosure?.expectations_by_check.get(check.key) ?? [], scopeDeliveryBindings(outcome.key, outcome.technical.bindings), outcome.product.owner.path_globs, sourceBackedExecutionTargets.get(executionTarget.key) ?? null, observationAuthorityPaths, proofAdequacy?.[proofAdequacyCheckKey(outcome.key, check.key)], externalDesignObligationRefs, externalClaimObligationRefsByAssertion), outcome.key, check.key);
+            if (frozen) {
+                blockedDesignAssertionRefsByCheck.set(check.key, removedAssertionRefs(check, frozen));
                 checks.push(frozen);
+            }
         }
         outcomes.push({
             ...outcome,
             internal_id: `OUT.${outcome.key}`,
             generated_claims: claims?.by_outcome[outcome.key] ?? [],
             risk_reasons: risk?.reasons_by_outcome[outcome.key] ?? [],
-            acceptance: { ...outcome.acceptance, checks },
+            acceptance: {
+                ...outcome.acceptance,
+                checks,
+                counterfactual_controls: outcome.acceptance.counterfactual_controls.map((control) => projectCounterfactualControl(control, outcome.acceptance.checks.find((check) => check.key === control.check_key), blockedDesignAssertionRefsByCheck.get(control.check_key) ??
+                    new Set())),
+            },
         });
     }
     const allChecks = [
         ...globalChecks,
         ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
     ];
+    const acceptanceReachability = claims && semanticFactClosure
+        ? compileAcceptanceReachability({
+            contract,
+            claims,
+            manifest: semanticFactClosure.manifest,
+            compiled_checks: allChecks,
+        })
+        : null;
+    await attempt(mode, diagnostics, () => validateResolvedCompletionAuthorityClosure(contract, globalChecks, outcomes, acceptanceReachability, mode === "collect"
+        ? (error) => addDiagnosticError(diagnostics, new Error(error))
+        : undefined));
+    if (risk)
+        await attempt(mode, diagnostics, () => validateRiskProof(contract, risk, acceptanceReachability, outcomes));
+    if (acceptanceReachability) {
+        if (mode === "fail_fast")
+            assertAcceptanceReachable(acceptanceReachability);
+        else
+            for (const obligation of acceptanceReachability.obligations)
+                if (obligation.status === "unreachable")
+                    addDiagnosticError(diagnostics, new Error(`acceptance_obligation_unreachable:${obligation.source_obligation_ref}:${obligation.reason}`), obligation.outcome_key);
+    }
     await attempt(mode, diagnostics, () => validateVerificationInputSeparation(contract, allChecks, workdirRelative));
     await attempt(mode, diagnostics, () => validateRawExecutionObservationOwnership(allChecks));
     if (allGlobalChecksFrozen(contract, globalChecks) &&
@@ -117,7 +165,7 @@ export async function validateContractForActivation(options) {
         if (risk)
             await attempt(mode, diagnostics, () => validateSemanticConformance(contract, risk.effective_level, allChecks, mode === "collect"
                 ? (error) => addDiagnosticError(diagnostics, new Error(error))
-                : undefined));
+                : undefined, acceptanceReachability));
     }
     return {
         claims,
@@ -125,9 +173,12 @@ export async function validateContractForActivation(options) {
         source_hashes: sourceHashes,
         source_items: sourceItems,
         context_snapshot: context,
+        project_design_authority: projectDesignAuthority,
         workspace,
         global_checks: globalChecks,
         outcomes,
+        proof_adequacy: proofAdequacy,
+        acceptance_reachability: acceptanceReachability,
     };
 }
 function designTargetsForCheck(outcome, checkKey) {
@@ -140,6 +191,25 @@ function designTargetsForCheck(outcome, checkKey) {
         target_ref: binding.target_ref,
     })));
 }
+function removedAssertionRefs(source, compiled) {
+    const retained = new Set([...compiled.positive_assertions, ...compiled.negative_assertions].map((assertion) => assertion.key));
+    return new Set([...source.positive_assertions, ...source.negative_assertions]
+        .map((assertion) => assertion.key)
+        .filter((assertionRef) => !retained.has(assertionRef)));
+}
+function projectCounterfactualControl(control, check, externallyBlockedAssertionRefs) {
+    if (!check || !externallyBlockedAssertionRefs.size)
+        return control;
+    const externallyBlockedClaims = new Set([...check.positive_assertions, ...check.negative_assertions]
+        .filter((assertion) => externallyBlockedAssertionRefs.has(assertion.key))
+        .flatMap((assertion) => assertion.claims));
+    return {
+        ...control,
+        claims: control.claims.filter((claimRef) => !externallyBlockedClaims.has(claimRef)),
+        expected_assertion_failures: control.expected_assertion_failures.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+        preserved_assertions: control.preserved_assertions.filter((assertionRef) => !externallyBlockedAssertionRefs.has(assertionRef)),
+    };
+}
 async function attempt(mode, diagnostics, action, outcomeKey, checkKey) {
     try {
         return await action();
@@ -158,9 +228,12 @@ function emptyCompiledResult(claims, risk, sourceHashes, sourceItems, context) {
         source_hashes: sourceHashes,
         source_items: sourceItems,
         context_snapshot: context,
+        project_design_authority: null,
         workspace: null,
         global_checks: [],
         outcomes: [],
+        proof_adequacy: null,
+        acceptance_reachability: null,
     };
 }
 function allGlobalChecksFrozen(contract, checks) {

package/dist/lib/long-task-active-authority-lock-context.d.ts

@@ -0,0 +1,4 @@
+import type { ActiveAuthorityLockToken } from "./long-task-state.js";
+export declare function runWithActiveAuthorityLockToken<T>(token: ActiveAuthorityLockToken, action: () => Promise<T>): Promise<T>;
+export declare function assertActiveAuthorityLockToken(token: ActiveAuthorityLockToken, repositoryRoot: string): void;
+export declare function currentActiveAuthorityLockToken(repositoryRoot: string): ActiveAuthorityLockToken | null;

package/dist/lib/long-task-active-authority-lock-context.js

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import path from "node:path";
+const activeAuthorityLockTokens = new WeakSet();
+const activeAuthorityLockContext = new AsyncLocalStorage();
+export async function runWithActiveAuthorityLockToken(token, action) {
+    activeAuthorityLockTokens.add(token);
+    try {
+        return await activeAuthorityLockContext.run(token, action);
+    }
+    finally {
+        activeAuthorityLockTokens.delete(token);
+    }
+}
+export function assertActiveAuthorityLockToken(token, repositoryRoot) {
+    if (!activeAuthorityLockTokens.has(token) ||
+        normalizePath(token.repository_root) !== normalizePath(repositoryRoot))
+        throw new Error("active_authority_lock_token_invalid");
+}
+export function currentActiveAuthorityLockToken(repositoryRoot) {
+    const token = activeAuthorityLockContext.getStore();
+    if (!token)
+        return null;
+    assertActiveAuthorityLockToken(token, repositoryRoot);
+    return token;
+}
+function normalizePath(value) {
+    const normalized = path.resolve(value).replace(/\\/gu, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/lib/long-task-applicability-identity.d.ts

@@ -0,0 +1,25 @@
+import type { ClaimApplicabilityV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare function claimApplicabilityProfile(contract: Pick<DeliveryContractV2, "global" | "outcomes">, outcomeKey: string | null, applicabilityRef: string): ClaimApplicabilityV2 | null;
+export declare function canonicalApplicabilityProfile(profile: ClaimApplicabilityV2): {
+    target_ref: string;
+    journey_role: ClaimApplicabilityV2["journey_role"];
+    dimensions: Array<{
+        key: string;
+        value: string;
+    }>;
+    given_refs: string[];
+    when_refs: string[];
+};
+export declare function canonicalApplicabilityIdentity(profile: ClaimApplicabilityV2): string;
+export declare function sameApplicabilityProfile(left: ClaimApplicabilityV2, right: ClaimApplicabilityV2): boolean;
+export interface OutcomeApplicabilityPairV1 {
+    outcome_ref: string;
+    applicability_ref: string;
+}
+export declare function globalCompatibleOutcomeApplicabilityCoverage(contract: Pick<DeliveryContractV2, "outcomes">, globalProfile: ClaimApplicabilityV2): {
+    target_outcome_refs: string[];
+    required_pairs: OutcomeApplicabilityPairV1[];
+    missing_outcome_refs: string[];
+};
+export declare function sameOutcomeApplicabilityCoverage(required: readonly OutcomeApplicabilityPairV1[], actual: readonly OutcomeApplicabilityPairV1[]): boolean;
+export declare function outcomeApplicabilityPairIdentity(pair: OutcomeApplicabilityPairV1): string;

package/dist/lib/long-task-applicability-identity.js

@@ -0,0 +1,60 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function claimApplicabilityProfile(contract, outcomeKey, applicabilityRef) {
+    const profiles = outcomeKey
+        ? contract.outcomes.find((outcome) => outcome.key === outcomeKey)
+            ?.applicability
+        : contract.global.applicability;
+    return profiles?.find((profile) => profile.key === applicabilityRef) ?? null;
+}
+export function canonicalApplicabilityProfile(profile) {
+    return {
+        target_ref: profile.target_ref,
+        journey_role: profile.journey_role,
+        dimensions: [...profile.dimensions]
+            .sort((left, right) => left.key.localeCompare(right.key) ||
+            left.value.localeCompare(right.value))
+            .map((dimension) => ({
+            key: dimension.key,
+            value: dimension.value,
+        })),
+        given_refs: [...profile.given_refs].sort(),
+        when_refs: [...profile.when_refs],
+    };
+}
+export function canonicalApplicabilityIdentity(profile) {
+    return sha256Hex(canonicalValueJson(canonicalApplicabilityProfile(profile)));
+}
+export function sameApplicabilityProfile(left, right) {
+    return (canonicalApplicabilityIdentity(left) ===
+        canonicalApplicabilityIdentity(right));
+}
+export function globalCompatibleOutcomeApplicabilityCoverage(contract, globalProfile) {
+    const targetOutcomes = contract.outcomes.filter((outcome) => outcome.applicability.some((profile) => profile.target_ref === globalProfile.target_ref));
+    const missing = [];
+    const required = targetOutcomes.flatMap((outcome) => {
+        const compatible = outcome.applicability.filter((profile) => sameApplicabilityProfile(globalProfile, profile));
+        if (!compatible.length)
+            missing.push(outcome.key);
+        return compatible.map((profile) => ({
+            outcome_ref: outcome.key,
+            applicability_ref: profile.key,
+        }));
+    });
+    return {
+        target_outcome_refs: targetOutcomes.map((outcome) => outcome.key).sort(),
+        required_pairs: sortOutcomeApplicabilityPairs(required),
+        missing_outcome_refs: missing.sort(),
+    };
+}
+export function sameOutcomeApplicabilityCoverage(required, actual) {
+    const left = sortOutcomeApplicabilityPairs(required).map(outcomeApplicabilityPairIdentity);
+    const right = sortOutcomeApplicabilityPairs(actual).map(outcomeApplicabilityPairIdentity);
+    return (left.length === right.length &&
+        left.every((identity, index) => identity === right[index]));
+}
+export function outcomeApplicabilityPairIdentity(pair) {
+    return `${pair.outcome_ref}\0${pair.applicability_ref}`;
+}
+function sortOutcomeApplicabilityPairs(pairs) {
+    return [...pairs].sort((left, right) => outcomeApplicabilityPairIdentity(left).localeCompare(outcomeApplicabilityPairIdentity(right)));
+}

package/dist/lib/long-task-authoring-preflight-diagnostics.js

@@ -1,5 +1,13 @@
 import { applyDiagnosticRepairOrder } from "./long-task-authoring-preflight-repair-order.js";
 export function addAuthoringDiagnostics(contract, parsed, diagnostics) {
+    if (parsed.compatibility.completion_authority_defaulted_to_machine_only)
+        diagnostics.push({
+            level: "warning",
+            code: "completion_authority_legacy_default_machine_only",
+            message: "target_profile.completion_authority is absent and was deterministically defaulted to machine_only; blocking External Confirmation routes remain unreachable.",
+            refs: ["task.target_profile.completion_authority"],
+            repair_hint: "Keep machine_only explicitly, or make an Authority decision to declare declared_authorities and fully decompose every blocking external obligation before Compile.",
+        });
     if (parsed.outcome_files.length)
         diagnostics.push({
             level: "warning",

package/dist/lib/long-task-authoring-preflight-types.d.ts

@@ -1,4 +1,5 @@
 import type { ClaimCoverageSummaryV2 } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability.js";
 export interface AuthoringPreflightDiagnosticV1 {
     level: "error" | "decision_required" | "warning" | "info";
     code: string;
@@ -39,6 +40,7 @@ export interface AuthoringPreflightResultV1 {
     outcomes: string[];
     source_coverage: SourceCoverageV1;
     claim_coverage: ClaimCoverageSummaryV2;
+    acceptance_reachability: AcceptanceReachabilityV1;
     revision_preview: AuthoringRevisionPreviewV1;
     diagnostics: AuthoringPreflightDiagnosticV1[];
 }

package/dist/lib/long-task-authoring-preflight-types.js

@@ -26,6 +26,15 @@ export function emptyPreflightResult(diagnostics) {
             unresolved: [],
         },
         claim_coverage: emptyClaimCoverage(),
+        acceptance_reachability: {
+            completion_authority: "machine_only",
+            total: 0,
+            machine_admitted: 0,
+            external_fulfillable: 0,
+            unreachable: 0,
+            obligations: [],
+            effective_external_routes: [],
+        },
         revision_preview: {
             active: false,
             authority_revision: null,