project-tiny-context-harness 0.8.17 → 0.11.0

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

@@ -4,12 +4,19 @@ import { addAuthoringDiagnostics, addDiagnosticError, normalizeAuthoringDiagnost
 import { emptyClaimCoverage, emptyPreflightResult, } from "./long-task-authoring-preflight-types.js";
 import { validateContractForActivation } from "./long-task-activation-validation.js";
 import { parseDeliveryContractBundle } from "./long-task-delivery-parser.js";
-import { changedWorkspacePaths, changedWorkspacePathsFromHead, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+import { canonicalExistingLongTaskWorkdir, changedWorkspacePaths, changedWorkspacePathsFromHead, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
 import { classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, workspaceScopeErrors, } from "./long-task-workspace-scope.js";
 export async function preflightDeliveryContract(workdirInput, projectRootInput = process.cwd()) {
     const diagnostics = [];
     const repository = await repositoryRoot(projectRootInput);
-    const workdir = path.resolve(workdirInput);
+    let workdir;
+    try {
+        workdir = await canonicalExistingLongTaskWorkdir(repository, workdirInput);
+    }
+    catch (error) {
+        addDiagnosticError(diagnostics, error);
+        return emptyPreflightResult(normalizeAuthoringDiagnostics(diagnostics));
+    }
     let parsed;
     try {
         parsed = await parseDeliveryContractBundle(workdir, repository, {
@@ -80,6 +87,15 @@ export async function preflightDeliveryContract(workdirInput, projectRootInput =
         outcomes: contract.outcomes.map((outcome) => outcome.key),
         source_coverage: sourceCoverage(contract),
         claim_coverage: validation.claims?.summary ?? emptyClaimCoverage(),
+        acceptance_reachability: validation.acceptance_reachability ?? {
+            completion_authority: contract.task.target_profile.completion_authority,
+            total: 0,
+            machine_admitted: 0,
+            external_fulfillable: 0,
+            unreachable: 0,
+            obligations: [],
+            effective_external_routes: [],
+        },
         revision_preview: authoringRevisionPreview(contract, validation.source_hashes, validation.source_items, validation.context_snapshot, active),
         diagnostics: normalizedDiagnostics,
     };

package/dist/lib/long-task-authority-material-diff.js

@@ -113,6 +113,10 @@ function flattenProductSemantics(projection) {
             "task.target_profile.required_target_refs",
             [...projection.target_profile.required_target_refs].sort(),
         ],
+        [
+            "task.target_profile.completion_authority",
+            projection.target_profile.completion_authority,
+        ],
     ]);
     for (const target of projection.execution_targets) {
         const prefix = `task.execution_targets.${target.key}`;

package/dist/lib/long-task-authority-materials.js

@@ -137,10 +137,29 @@ export function projectGlobalSemantics(contract) {
             given_refs: [...item.given_refs],
             when_refs: [...item.when_refs],
         })),
+        semantic_fact_bindings: contract.global.semantic_fact_bindings
+            ? {
+                manifest_ref: contract.global.semantic_fact_bindings.manifest_ref,
+                obligations: [...contract.global.semantic_fact_bindings.obligations]
+                    .sort((left, right) => globalSemanticObligationKey(left).localeCompare(globalSemanticObligationKey(right)))
+                    .map((item) => ({ ...item })),
+            }
+            : null,
         constraints: applicableStatements(contract.global.technical.constraints),
         forbidden_shortcuts: applicableStatements(contract.global.technical.forbidden_shortcuts),
     };
 }
+function globalSemanticObligationKey(item) {
+    return [
+        item.claim_ref,
+        item.applicability_ref,
+        item.target_ref,
+        item.outcome_ref,
+        item.fact_ref,
+        item.proof_ref,
+        item.method,
+    ].join("\0");
+}
 function keyedStatements(values) {
     return [...values]
         .sort(keyOrder)

package/dist/lib/long-task-authority-policy.d.ts

@@ -30,6 +30,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         source_ref: "scope";
         statement: "semantic_user_review";
         disposition: "semantic_user_review";
+        judgment_basis: "semantic_user_review";
     };
     readonly risk: {
         requested_level: "semantic_user_review";
@@ -37,6 +38,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
     };
     readonly global: {
         applicability: "semantic_user_review";
+        semantic_fact_bindings: "semantic_user_review";
         product: "semantic_user_review";
         technical: "semantic_user_review";
         acceptance: "proof_additive";
@@ -243,6 +245,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         applicability_ref: "proof_additive";
         observation: "proof_additive";
         evidence_capabilities: "proof_additive";
+        expected_authority_ref: "semantic_user_review";
         operator: "proof_additive";
         expected: "proof_additive";
     };

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

@@ -13,6 +13,7 @@ const SOURCE_CLAIM_AUTHORITY_POLICY = {
     source_ref: "scope",
     statement: "semantic_user_review",
     disposition: "semantic_user_review",
+    judgment_basis: "semantic_user_review",
 };
 const RISK_AUTHORITY_POLICY = {
     requested_level: "semantic_user_review",
@@ -20,6 +21,7 @@ const RISK_AUTHORITY_POLICY = {
 };
 const GLOBAL_AUTHORITY_POLICY = {
     applicability: "semantic_user_review",
+    semantic_fact_bindings: "semantic_user_review",
     product: "semantic_user_review",
     technical: "semantic_user_review",
     acceptance: "proof_additive",
@@ -226,6 +228,7 @@ const ASSERTION_AUTHORITY_POLICY = {
     applicability_ref: "proof_additive",
     observation: "proof_additive",
     evidence_capabilities: "proof_additive",
+    expected_authority_ref: "semantic_user_review",
     operator: "proof_additive",
     expected: "proof_additive",
 };

package/dist/lib/long-task-authority-revision-details.js

@@ -58,7 +58,8 @@ export function sourceClaimReductions(beforeClaims, afterClaims) {
         }
         if (claim.statement !== candidate.statement ||
             claim.source_ref !== candidate.source_ref ||
-            claim.disposition.type !== candidate.disposition.type) {
+            claim.disposition.type !== candidate.disposition.type ||
+            !same(claim.judgment_basis, candidate.judgment_basis)) {
             changed.push(`${claim.key}:authority_changed`);
             continue;
         }

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

@@ -2,6 +2,7 @@ import type { DeliveryControlV2, DeliveryOutcomeV2, ProofSurface } from "./long-
 import type { ClaimApplicabilityV2, DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
 import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
+import type { SemanticFactGlobalBindingsV2 } from "./long-task-semantic-fact-binding-types.js";
 import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
 export interface AuthorityHashesV2 {
     source_authority_hash: string;
@@ -76,6 +77,7 @@ export interface ProductSemanticProjectionV2 {
 }
 export interface GlobalSemanticProjectionV2 {
     applicability: ClaimApplicabilityV2[];
+    semantic_fact_bindings: SemanticFactGlobalBindingsV2 | null;
     constraints: Array<{
         key: string;
         statement: string;

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

@@ -26,6 +26,7 @@ export function computeAuthorityHashes(contract) {
             stages: contract.stages,
             global: {
                 applicability: contract.global.applicability,
+                semantic_fact_bindings: contract.global.semantic_fact_bindings ?? null,
                 product: contract.global.product,
             },
             outcomes: contract.outcomes.map((outcome) => ({
@@ -44,6 +45,7 @@ export function computeAuthorityHashes(contract) {
             })),
         }),
         acceptance_authority_hash: hash({
+            global_semantic_fact_bindings: contract.global.semantic_fact_bindings ?? null,
             external_confirmations: contract.global.acceptance.external_confirmations,
             global_checks: contract.global.acceptance.checks.map(acceptanceCheck),
             global_counterfactual_controls: contract.global.acceptance.counterfactual_controls,

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

@@ -89,7 +89,7 @@ function parseRunner(value, label) {
 function parseAssertions(value, label) {
     return array(value, label).map((item, index) => {
         const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "applicability_ref", "expected"]);
+        const row = object(item, itemLabel, ["key", "claims", "observation", "operator", "evidence_capabilities"], ["criterion", "applicability_ref", "expected", "expected_authority_ref"]);
         const operator = literal(row.operator, [
             "equals",
             "not_equals",
@@ -128,6 +128,11 @@ function parseAssertions(value, label) {
                 : {}),
             observation: string(row.observation, `${itemLabel}.observation`),
             evidence_capabilities: array(row.evidence_capabilities, `${itemLabel}.evidence_capabilities`).map((capability, capabilityIndex) => literal(capability, EVIDENCE_CAPABILITIES, `${itemLabel}.evidence_capabilities[${capabilityIndex}]`)),
+            ...(Object.hasOwn(row, "expected_authority_ref")
+                ? {
+                    expected_authority_ref: string(row.expected_authority_ref, `${itemLabel}.expected_authority_ref`),
+                }
+                : {}),
             operator,
         };
         return isBinaryAssertionOperator(operator)

package/dist/lib/long-task-claim-definitions.js

@@ -26,9 +26,7 @@ export function generateClaims(outcome) {
                 .filter((proof) => proof.fact_ref === binding.fact_ref)
                 .map((proof) => proof.proof_surface)),
         ];
-        claims.push(claim(outcome.key, binding.claim_ref, "semantic_fact", requiredSurfaces, [
-            binding.applicability_ref,
-        ]));
+        claims.push(claim(outcome.key, binding.claim_ref, "semantic_fact", requiredSurfaces, [binding.applicability_ref], binding.required_polarity ?? "positive"));
     }
     for (const item of outcome.technical.forbidden_shortcuts)
         claims.push(claim(outcome.key, `forbidden_shortcut.${item.key}`, "forbidden_shortcut", [], item.applicability_refs, "negative"));

package/dist/lib/long-task-claim-semantic-proof-floor.d.ts

@@ -0,0 +1,3 @@
+import type { DeliveryContractV2, EvidenceCapabilityV2, ProductClaimV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function claimSemanticCapabilityFloor(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, outcomeKey: string | null, localClaim: string, applicabilityRef: string | null, claimKind?: ProductClaimV2["kind"] | string, requiredProofSurfaces?: readonly string[]): Set<EvidenceCapabilityV2>;

package/dist/lib/long-task-claim-semantic-proof-floor.js

@@ -0,0 +1,78 @@
+import { semanticFactClosureInvalid } from "./long-task-semantic-fact-closure-primitives.js";
+import { semanticFactProofCapabilityFloor } from "./long-task-semantic-proof-profile.js";
+const FACT_REQUIRED_CLAIM_KINDS = new Set([
+    "result",
+    "requirement",
+    "obligation",
+    "non_completing",
+    "forbidden_shortcut",
+    "global_non_goal",
+    "global_constraint",
+    "global_forbidden_shortcut",
+]);
+export function claimSemanticCapabilityFloor(contract, manifest, outcomeKey, localClaim, applicabilityRef, claimKind, requiredProofSurfaces = []) {
+    const selected = outcomeKey
+        ? selectOutcomeFactRefs(contract, manifest, outcomeKey, localClaim, applicabilityRef)
+        : selectGlobalFactRefs(contract, localClaim, applicabilityRef);
+    const pureStructure = requiredProofSurfaces.length > 0 &&
+        requiredProofSurfaces.every((surface) => surface === "implementation_structure");
+    if (claimKind &&
+        FACT_REQUIRED_CLAIM_KINDS.has(claimKind) &&
+        !pureStructure &&
+        !selected.length)
+        semanticFactClosureInvalid("broad_claim_semantic_fact_required", `${outcomeKey ?? "GLOBAL"}:${localClaim}:${applicabilityRef ?? "none"}`);
+    const facts = new Map(manifest.facts.map((fact) => [fact.key, fact]));
+    const result = new Set();
+    for (const factRef of selected) {
+        const fact = facts.get(factRef);
+        for (const proof of manifest.proof_obligations.filter((row) => row.fact_ref === factRef))
+            for (const capability of semanticFactProofCapabilityFloor(manifest, fact, proof))
+                if (capability !== "semantic_fact")
+                    result.add(capability);
+    }
+    return result;
+}
+function selectGlobalFactRefs(contract, localClaim, applicabilityRef) {
+    return [
+        ...new Set((contract.global.semantic_fact_bindings?.obligations ?? [])
+            .filter((binding) => binding.claim_ref === localClaim &&
+            (!applicabilityRef ||
+                binding.applicability_ref === applicabilityRef))
+            .map((binding) => binding.fact_ref)),
+    ];
+}
+function selectOutcomeFactRefs(contract, manifest, outcomeKey, localClaim, applicabilityRef) {
+    const outcome = contract.outcomes.find((row) => row.key === outcomeKey);
+    if (!outcome)
+        return [];
+    const applicableFactRefs = new Set(outcome.semantic_fact_bindings.facts
+        .filter((binding) => !applicabilityRef || binding.applicability_ref === applicabilityRef)
+        .map((binding) => binding.fact_ref));
+    const directBinding = outcome.semantic_fact_bindings.facts.find((binding) => binding.claim_ref === localClaim);
+    let selected = directBinding ? [directBinding.fact_ref] : [];
+    if (!selected.length) {
+        const fullClaim = `${outcomeKey}.${localClaim}`;
+        const sourceRefs = contract.source_claims
+            .filter((source) => sourceOwnsClaim(source.disposition, fullClaim))
+            .map((source) => source.key);
+        selected = manifest.facts
+            .filter((fact) => fact.outcome_ref === outcomeKey &&
+            applicableFactRefs.has(fact.key) &&
+            sourceRefs.some((sourceRef) => fact.source_item_refs.includes(sourceRef)))
+            .map((fact) => fact.key);
+    }
+    if (!selected.length)
+        selected = manifest.facts
+            .filter((fact) => fact.outcome_ref === outcomeKey && applicableFactRefs.has(fact.key))
+            .map((fact) => fact.key);
+    return selected;
+}
+function sourceOwnsClaim(disposition, fullClaim) {
+    if (disposition.type === "claim")
+        return disposition.refs.includes(fullClaim);
+    if (disposition.type === "global_constraint")
+        return disposition.refs.includes(fullClaim);
+    if (disposition.type === "outcome_result")
+        return disposition.ref === fullClaim;
+    return false;
+}

package/dist/lib/long-task-claims.d.ts

@@ -4,25 +4,7 @@ export interface CompiledClaimsV2 {
     by_outcome: Record<string, ProductClaimV2[]>;
     summary: ClaimCoverageSummaryV2;
 }
-interface ExternalConfirmationProjectionInput {
-    global: {
-        acceptance: {
-            external_confirmations: readonly {
-                blocks_target: boolean;
-                impact_claims: readonly string[];
-            }[];
-        };
-    };
-}
-interface AllOutcomeExternalConfirmationProjectionInput extends ExternalConfirmationProjectionInput {
-    outcomes: readonly {
-        key: string;
-    }[];
-}
-export declare function outcomeResultExternallyBlocked(contract: ExternalConfirmationProjectionInput, outcomeKey: string): boolean;
-export declare function allOutcomeResultsExternallyBlocked(contract: AllOutcomeExternalConfirmationProjectionInput): boolean;
 export declare function compileProductClaimCoverage(contract: DeliveryContractV2, options?: {
     allow_uncovered?: boolean;
 }): CompiledClaimsV2;
 export declare function assertCompiledClaimsCovered(compiled: CompiledClaimsV2): void;
-export {};

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

@@ -2,15 +2,6 @@ import { assertAllClaimsCovered, assertAllGlobalClaimsCovered, generateClaims, g
 import { fail } from "./long-task-delivery-shape.js";
 import { validateClaimAssertionOperator, validateGlobalAssertionOperator, } from "./long-task-claim-proof-policy.js";
 import { matchesRepoPattern } from "./long-task-paths.js";
-export function outcomeResultExternallyBlocked(contract, outcomeKey) {
-    const resultClaim = `${outcomeKey}.result`;
-    return contract.global.acceptance.external_confirmations.some((confirmation) => confirmation.blocks_target &&
-        confirmation.impact_claims.includes(resultClaim));
-}
-export function allOutcomeResultsExternallyBlocked(contract) {
-    return (contract.outcomes.length > 0 &&
-        contract.outcomes.every((outcome) => outcomeResultExternallyBlocked(contract, outcome.key)));
-}
 export function compileProductClaimCoverage(contract, options = {}) {
     const byGlobal = generateGlobalClaims(contract.global);
     const byOutcome = Object.fromEntries(contract.outcomes.map((outcome) => [outcome.key, generateClaims(outcome)]));
@@ -326,13 +317,9 @@ function addBlockingExternalConfirmationProofs(contract, claim, proofs) {
         confirmation.impact_claims.includes(claim.id));
     if (!confirmations.length)
         return;
-    const proofSurfaces = "required_proof_surfaces" in claim &&
-        claim.required_proof_surfaces.length > 0
-        ? claim.required_proof_surfaces
-        : ["runtime_behavior"];
     for (const confirmation of confirmations)
         for (const applicabilityRef of claim.applicability_refs)
-            for (const proofSurface of proofSurfaces)
+            for (const proofSurface of externalClaimProofSurfaces(confirmation, claim, applicabilityRef))
                 addProof(proofs, claim.local_key, {
                     check_key: `EXTERNAL.${confirmation.key}`,
                     assertion_key: null,
@@ -341,6 +328,20 @@ function addBlockingExternalConfirmationProofs(contract, claim, proofs) {
                     applicability_ref: applicabilityRef,
                 });
 }
+function externalClaimProofSurfaces(confirmation, claim, applicabilityRef) {
+    const declared = [
+        ...new Set((confirmation.obligations ?? [])
+            .filter((obligation) => obligation.claim_ref === claim.id &&
+            obligation.applicability_ref === applicabilityRef)
+            .map((obligation) => obligation.proof_surface)),
+    ];
+    if (declared.length)
+        return declared;
+    return "required_proof_surfaces" in claim &&
+        claim.required_proof_surfaces.length
+        ? claim.required_proof_surfaces
+        : ["runtime_behavior"];
+}
 function sameSet(left, right) {
     return (left.length === right.length &&
         new Set(left).size === left.length &&

package/dist/lib/long-task-command-process.js

@@ -1,8 +1,11 @@
 import { spawn } from "node:child_process";
 import { createProcessTreeObserver, } from "./long-task-process-tree.js";
+import { spawnWindowsJobCommandOnce } from "./long-task-windows-job-supervisor.js";
 const OUTPUT_LIMIT = 2 * 1024 * 1024;
 const PROCESS_TREE_GRACE_MS = 1_000;
 export function spawnCommandOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
+    if (containProcessTree && process.platform === "win32")
+        return spawnWindowsJobCommandOnce(executable, argv, cwd, timeoutMs, environment, OUTPUT_LIMIT);
     return new Promise((resolve, reject) => {
         const child = spawn(executable, argv, {
             cwd,

package/dist/lib/long-task-compact-authoring.js

@@ -56,6 +56,9 @@ export function createLongTaskCompactContract(contractInput, factRevisions, obli
                 fact_revision_digest: revision,
                 claim_ref: binding.claim_ref,
                 applicability_ref: binding.applicability_ref,
+                ...(binding.required_polarity
+                    ? { required_polarity: binding.required_polarity }
+                    : {}),
             });
         }
         for (const binding of outcome.semantic_fact_bindings.proofs) {

package/dist/lib/long-task-compact-projections.js

@@ -82,6 +82,11 @@ export function materializeLongTaskCompactFactBindings(facts, obligations, factB
             fact_revision_digest: compactSha256(fact.fact_revision_digest, `${label}.fact_revision_digest`),
             claim_ref: compactStableRef(fact.claim_ref, `${label}.claim_ref`),
             applicability_ref: compactStableRef(fact.applicability_ref, `${label}.applicability_ref`),
+            ...(Object.hasOwn(fact, "required_polarity")
+                ? {
+                    required_polarity: compactPolarity(fact.required_polarity, `${label}.required_polarity`),
+                }
+                : {}),
         });
     }
     for (const [index, obligation] of obligations.entries()) {
@@ -107,6 +112,11 @@ export function materializeLongTaskCompactFactBindings(facts, obligations, factB
         });
     }
 }
+function compactPolarity(value, label) {
+    if (value !== "positive" && value !== "negative")
+        compactFail(label, "must be positive or negative");
+    return value;
+}
 export function materializeLongTaskCompactAssertions(assertions, claims, facts, outcomes) {
     for (const [index, projection] of assertions.entries()) {
         const label = `compact_semantic_carrier.assertion_projections.rows[${index}]`;

package/dist/lib/long-task-complete-delivery-evidence-types.d.ts

@@ -0,0 +1,38 @@
+import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
+interface CompleteDeliveryEvidenceBaseV2 {
+    assertion_key: string;
+    capability: EvidenceCapabilityV2;
+}
+export interface ActualProvenanceEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "actual_provenance";
+    source_kind: "product_runtime" | "observer_runtime" | "durable_store";
+    source_ref: string;
+    actual_sha256: string;
+}
+export interface DistinctIdentityEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "distinct_identity";
+    identities: Array<{
+        identity_ref: string;
+        data_state_sha256: string;
+    }>;
+}
+export interface DataStateEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "data_state";
+    state_ref: string;
+    state_sha256: string;
+    read_session_id: string;
+}
+export interface PopulationCoverageEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "population_coverage";
+    universe_sha256: string;
+    observed_sha256: string;
+    excluded_sha256: string;
+    set_equality: true;
+}
+export interface RecoveryEvidenceV2 extends CompleteDeliveryEvidenceBaseV2 {
+    capability: "recovery";
+    failure_session_id: string;
+    recovery_session_id: string;
+    recovered_state_sha256: string;
+}
+export {};

package/dist/lib/long-task-complete-delivery-evidence-types.js

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

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

@@ -0,0 +1,109 @@
+import type { DeliveryContractV2 } from "./long-task-contract-types.js";
+import type { VerifierIdentityV2 } from "./long-task-authority-types.js";
+import type { CheckExecutionResultV2, LongTaskFindingV2 } from "./long-task-runtime-types.js";
+import type { ExternalConfirmationEvaluationV1 } from "./long-task-external-confirmation-types.js";
+export interface TargetedVerificationResultV2 {
+    schema_version: "long-task-targeted-progress-v2";
+    compiled_identity: string;
+    snapshot_sha256: string;
+    acceptance_authorized: false;
+    selected_outcome: string | null;
+    selected_check: string | null;
+    updated_progress_records: string[];
+    check_results: CheckExecutionResultV2[];
+    findings: LongTaskFindingV2[];
+    repair_frontier?: RepairFrontierV1;
+    completed_at: string;
+}
+export interface RepairFrontierCheckV1 {
+    check_ref: string;
+    outcome_key: string | null;
+    check_key: string;
+    raw_execution_identity: string;
+    obligation_refs: string[];
+    reasons: string[];
+}
+export interface RepairFrontierGroupV1 {
+    root_cause_key: string;
+    finding_codes: string[];
+    source_fragment_refs: string[];
+    affected_fact_refs: string[];
+    affected_proof_obligation_refs: string[];
+    affected_claim_refs: string[];
+    expected_authority_refs: string[];
+    actual_evidence_refs: string[];
+    suggested_implementation_owners: string[];
+    suggested_owner_paths: string[];
+    verification_owners: string[];
+    invalidation_reasons: string[];
+    rerun_obligation_refs: string[];
+    minimum_diagnostic_reverify: string[];
+    still_valid_diagnostic_evidence: string[];
+}
+export interface RepairFrontierSessionV1 {
+    raw_execution_identity: string;
+    check_refs: string[];
+    obligation_refs: string[];
+}
+export interface RepairFrontierV1 {
+    schema_version: "long-task-repair-frontier-v1";
+    authority_scope: "derived_diagnostic_only";
+    acceptance_authorized: false;
+    persisted: false;
+    compiled_identity: string;
+    authority_revision: number;
+    candidate_snapshot_sha256: string;
+    changed_paths: string[];
+    summary: {
+        finding_groups: number;
+        affected_facts: number;
+        affected_proof_obligations: number;
+        minimum_checks: number;
+        still_valid_progress_records: number;
+    };
+    groups: RepairFrontierGroupV1[];
+    minimum_diagnostic_reverify: RepairFrontierCheckV1[];
+    rerun_sessions: RepairFrontierSessionV1[];
+    still_valid_diagnostic_evidence: string[];
+    forbidden_authority_changes_without_revision: {
+        fields: string[];
+        protected_paths: string[];
+    };
+    final_gate_requirement: "complete_one_snapshot_rerun_still_required";
+    generated_at: string;
+}
+export type OutcomeStatusV2 = "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
+export type StageStatusV2 = "locked" | "ready" | "unverified" | "progress_passing" | "progress_failing" | "progress_stale" | "blocked_external";
+export interface FinalReceiptV2 {
+    schema_version: "long-task-final-receipt-v2" | "long-task-final-receipt-v3";
+    receipt_sha256: string;
+    authority_scope: "audit_only";
+    reusable_for_acceptance: false;
+    workflow_status: "machine_accepted" | "delivery_accepted" | "machine_accepted_external_pending" | "needs_work" | "blocked_external";
+    target_profile: DeliveryContractV2["task"]["target_profile"];
+    target_state: DeliveryContractV2["task"]["target_profile"]["required_state"] | "not_accepted" | "blocked_external";
+    stage_results: Record<string, "passed" | "failed" | "blocked_external" | "blocked_dependency">;
+    compiled_identity: string;
+    contract_sha256: string;
+    snapshot_sha256: string;
+    git_head: string;
+    git_tree: string;
+    source_hashes: Record<string, string>;
+    context_hashes: Record<string, string>;
+    verifier_identity: VerifierIdentityV2;
+    check_results: CheckExecutionResultV2[];
+    outcome_results: Record<string, "passed" | "failed" | "blocked_external">;
+    external_confirmations: DeliveryContractV2["global"]["acceptance"]["external_confirmations"];
+    external_confirmation_results?: ExternalConfirmationEvaluationV1[];
+    findings: LongTaskFindingV2[];
+    snapshot_preparation_ms: number;
+    started_at: string;
+    completed_at: string;
+    /** Present on newly finalized v3 Receipts; historical Receipts remain audit-only. */
+    finalization_identity_sha256?: string;
+}
+export type FinalReceiptV3 = Omit<FinalReceiptV2, "schema_version"> & {
+    schema_version: "long-task-final-receipt-v3";
+    external_confirmation_results: ExternalConfirmationEvaluationV1[];
+    finalization_identity_sha256: string;
+};

package/dist/lib/long-task-completion-types.js

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

package/dist/lib/long-task-conformance-policy.d.ts

@@ -1,5 +1,6 @@
 import type { CompiledCheckV2, DeliveryContractV2, EffectiveRiskLevel } from "./long-task-delivery-types.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
 type Reporter = (message: string) => void;
 export declare function semanticConformanceRequired(contract: DeliveryContractV2, _effectiveRisk?: EffectiveRiskLevel): boolean;
-export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter): void;
+export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter, reachability?: AcceptanceReachabilityV1 | null): void;
 export {};

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

@@ -1,4 +1,5 @@
-import { allOutcomeResultsExternallyBlocked } from "./long-task-claims.js";
+import { machineAuthorizedAssertionExists } from "./long-task-acceptance-reachability-helpers.js";
+import { allOutcomeResultsFullyEffectivelyExternallyBlocked } from "./long-task-effective-external-takeover.js";
 export function semanticConformanceRequired(contract, _effectiveRisk) {
     const productFamilies = new Set(contract.task.execution_targets
         .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
@@ -6,18 +7,24 @@ export function semanticConformanceRequired(contract, _effectiveRisk) {
     return (contract.risk.facts.weak_observability.length > 0 &&
         (productFamilies.size > 1 || contract.stages.length > 1));
 }
-export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
+export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report, reachability) {
     const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
     if (semanticConformanceRequired(contract, effectiveRisk) &&
         !declared.length &&
-        !allOutcomeResultsExternallyBlocked(contract)) {
+        !allOutcomeResultsFullyEffectivelyExternallyBlocked(contract, reachability)) {
         issue(report, "semantic_conformance_check_required", contract.task.id);
         return;
     }
     for (const check of declared) {
         if (check.runner.effect !== "read_only")
             issue(report, "conformance_check_must_be_read_only", check.key);
-        if (![...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime")))
+        if (!machineAuthorizedAssertionExists(compiledChecks, {
+            authority_scope: "ordinary_claim",
+            outcome_key: null,
+            check_key: check.key,
+            check_journey_role: "conformance",
+            required_evidence_capability: "target_runtime",
+        }))
             issue(report, "conformance_target_runtime_evidence_required", check.key);
         const compiled = compiledChecks.find((candidate) => candidate.outcome_key === null && candidate.key === check.key);
         if (!compiled)