project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/long-task-status-v2.js

@@ -2,9 +2,13 @@ import path from "node:path";
 import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
 import { authorityRevisionDecisionNextAction } from "./long-task-authority-revision-brief.js";
 import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
-import { runDeliveryFinalGate } from "./long-task-final-v2.js";
+import { externalConfirmationFindings, runDeliveryFinalGate, } from "./long-task-final-v2.js";
+import { evaluateExternalConfirmations } from "./long-task-external-confirmation-plan.js";
+import { captureFinalizationIdentity, finalizationIdentityDigest, } from "./long-task-finalization-identity.js";
+import { enrichFinding } from "./long-task-finding-context.js";
+import { deriveRepairFrontier } from "./long-task-repair-frontier.js";
 import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { activeAuthorityLockExists, clearActiveBindingCas, inspectCompiledCache, loadActiveLongTaskAuthority, readActiveLongTaskBinding, readFinalReceipt, readPendingAuthorityRevision, readProgressRecords, } from "./long-task-state.js";
+import { activeAuthorityLockExists, inspectCompiledCache, loadActiveLongTaskAuthority, readActiveLongTaskBinding, readFinalReceipt, readPendingAuthorityRevision, readProgressRecords, } from "./long-task-state.js";
 import { projectDeliveryStatus, } from "./long-task-status-projection.js";
 import { captureWorkspaceManifest, currentGitState, repositoryRoot, } from "./long-task-workspace.js";
 export async function readDeliveryStatus(workdir) {
@@ -34,6 +38,28 @@ async function readDeliveryStatusForAuthority(active) {
     catch (error) {
         receiptError = message(error);
     }
+    const externalConfirmationResults = await evaluateExternalConfirmations(compiled, compiled.repository_root, compiled.workdir, current, {
+        git_head: current.git_head,
+        git_tree: current.fingerprint.head_tree,
+        snapshot_sha256: current.snapshot_sha256,
+    });
+    let finalizationIdentitySha256 = null;
+    try {
+        finalizationIdentitySha256 = finalizationIdentityDigest(await captureFinalizationIdentity({
+            repository: compiled.repository_root,
+            active,
+            compiled,
+            candidate: {
+                git_head: current.git_head,
+                git_tree: current.fingerprint.head_tree,
+                snapshot_sha256: current.snapshot_sha256,
+            },
+            workspace_fingerprint: current.fingerprint,
+        }));
+    }
+    catch (error) {
+        receiptError ??= `finalization_identity_invalid:${message(error)}`;
+    }
     const projection = projectDeliveryStatus({
         compiled,
         manifest: current,
@@ -41,6 +67,21 @@ async function readDeliveryStatusForAuthority(active) {
         progress,
         receipt,
         receiptError,
+        finalizationIdentitySha256,
+        externalConfirmations: externalConfirmationResults,
+    });
+    const findings = [
+        ...projection.findings,
+        ...externalConfirmationFindings(compiled, externalConfirmationResults),
+        ...(cacheStatus === "compiled_cache_matching"
+            ? []
+            : [cacheDiagnostic(cacheStatus)]),
+    ].map((finding) => enrichFinding(compiled, finding));
+    const repairFrontier = deriveRepairFrontier({
+        compiled,
+        manifest: current,
+        progress,
+        findings,
     });
     return {
         schema_version: "long-task-status-v2",
@@ -49,11 +90,12 @@ async function readDeliveryStatusForAuthority(active) {
         effective_risk: compiled.effective_risk,
         workspace_snapshot_sha256: current.snapshot_sha256,
         acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_machine_authority",
+        acceptance_scope: "declared_delivery_authority",
         native_goal_effect: "none",
         final_result: projection.finalResult,
         final_workflow_status: projection.finalWorkflowStatus,
         external_confirmations: compiled.global.acceptance.external_confirmations,
+        external_confirmation_results: externalConfirmationResults,
         target_profile: compiled.task.target_profile,
         target_state: projection.targetState,
         outcomes: projection.outcomes,
@@ -67,12 +109,8 @@ async function readDeliveryStatusForAuthority(active) {
         pending_authority_revision: pending
             ? projectAuthorityRevisionDecision(pending)
             : null,
-        findings: [
-            ...projection.findings,
-            ...(cacheStatus === "compiled_cache_matching"
-                ? []
-                : [cacheDiagnostic(cacheStatus)]),
-        ],
+        findings,
+        repair_frontier: repairFrontier,
     };
 }
 export async function resumeDeliveryTask(workdir) {
@@ -103,11 +141,12 @@ export async function resumeDeliveryTask(workdir) {
         context_refs: compiled.task.context_refs,
         git,
         acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_machine_authority",
+        acceptance_scope: "declared_delivery_authority",
         native_goal_effect: "none",
         last_gate: status.final_result,
         final_workflow_status: status.final_workflow_status,
         external_confirmations: status.external_confirmations,
+        external_confirmation_results: status.external_confirmation_results,
         target_profile: status.target_profile,
         target_state: status.target_state,
         outcomes: status.outcomes,
@@ -120,6 +159,7 @@ export async function resumeDeliveryTask(workdir) {
         progress_failing: status.progress_failing,
         pending_authority_revision: status.pending_authority_revision,
         recent_findings: status.findings,
+        repair_frontier: status.repair_frontier,
         next_safe_action: nextAction(status),
     };
 }
@@ -207,44 +247,23 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
     if (active.workdir !== path.resolve(workdirInput))
         return { continue: false, reason: "active_task_workdir_mismatch" };
     try {
-        const result = await runDeliveryFinalGate(active.workdir);
+        const result = await runDeliveryFinalGate(active.workdir, {
+            close_on_accept: true,
+        });
         if (result.workflow_status === "machine_accepted" ||
-            result.workflow_status === "machine_accepted_external_pending") {
-            try {
-                await clearActiveBindingCas({
-                    repository_root: root,
-                    workdir: active.workdir,
-                    task_id: active.task_id,
-                    authority_revision: active.authority_revision,
-                    compiled_identity: active.active_authority_identity,
-                    worktree_identity: active.worktree_identity,
-                });
-            }
-            catch (error) {
-                if (message(error).includes("active_authority_clear_compare_and_swap_failed"))
-                    return {
-                        continue: false,
-                        reason: "active_authority_changed_after_final_gate",
-                        workflow_status: result.workflow_status,
-                        external_confirmations: result.external_confirmations,
-                        target_profile: result.target_profile,
-                        target_state: result.target_state,
-                        stage_results: result.stage_results,
-                        message: "Active Authority changed after the Live Final Gate; the accepted identity was not cleared.",
-                    };
-                throw error;
-            }
+            result.workflow_status === "delivery_accepted") {
             return {
                 continue: true,
                 reason: result.workflow_status,
                 workflow_status: result.workflow_status,
                 external_confirmations: result.external_confirmations,
+                external_confirmation_results: result.external_confirmation_results,
                 target_profile: result.target_profile,
                 target_state: result.target_state,
                 stage_results: result.stage_results,
-                acceptance_scope: "declared_machine_authority",
+                acceptance_scope: "declared_delivery_authority",
                 native_goal_effect: "none",
-                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations, result.target_profile),
+                message: acceptedScopeMessage(result.workflow_status, result.target_profile),
             };
         }
         return {
@@ -252,6 +271,7 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
             reason: `live_final_gate_${result.workflow_status}`,
             workflow_status: result.workflow_status,
             external_confirmations: result.external_confirmations,
+            external_confirmation_results: result.external_confirmation_results,
             target_profile: result.target_profile,
             target_state: result.target_state,
             stage_results: result.stage_results,
@@ -278,38 +298,30 @@ export async function closeDeliveryTask(workdir) {
     const active = await readActiveLongTaskBinding(root);
     if (!active || active.workdir !== path.resolve(workdir))
         throw new Error("active_task_missing_or_mismatched");
-    const result = await runDeliveryFinalGate(active.workdir);
+    const result = await runDeliveryFinalGate(active.workdir, {
+        close_on_accept: true,
+    });
     if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "machine_accepted_external_pending")
+        result.workflow_status !== "delivery_accepted")
         throw new Error(`close_live_final_gate_failed:${result.workflow_status}`);
-    await clearActiveBindingCas({
-        repository_root: root,
-        workdir: active.workdir,
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        compiled_identity: active.active_authority_identity,
-        worktree_identity: active.worktree_identity,
-    });
     return {
         status: "closed",
         workflow_status: result.workflow_status,
         external_confirmations: result.external_confirmations,
+        external_confirmation_results: result.external_confirmation_results,
         target_profile: result.target_profile,
         target_state: result.target_state,
         stage_results: result.stage_results,
-        acceptance_scope: "declared_machine_authority",
-        closed_scope: "machine_authority",
+        acceptance_scope: "declared_delivery_authority",
+        closed_scope: "complete_long_task_authority",
         native_goal_effect: "none",
     };
 }
-function acceptedScopeMessage(workflowStatus, confirmations, targetProfile) {
-    const scope = `Declared machine Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
-    if (workflowStatus === "machine_accepted")
-        return scope;
-    const pending = confirmations
-        .map((confirmation) => `${confirmation.key} (${confirmation.owner})`)
-        .join(", ");
-    return `${scope} Complete external delivery remains pending: ${pending}. Do not report complete external delivery.`;
+function acceptedScopeMessage(workflowStatus, targetProfile) {
+    const route = workflowStatus === "machine_accepted"
+        ? "package-admitted machine evidence"
+        : "package-admitted machine evidence plus fresh exact external fulfillment records";
+    return `Declared complete-delivery Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} through ${route} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
 }
 function nextAction(status) {
     if (status.pending_authority_revision)

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

@@ -1,6 +1,11 @@
-import { type CompiledClaimsV2 } from "./long-task-claims.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import type { CompiledClaimsV2 } from "./long-task-claims.js";
+import type { AcceptanceReachabilityV1 } from "./long-task-acceptance-reachability-types.js";
+import type { CompiledOutcomeV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
 type Reporter = (message: string) => void;
-export declare function validateExecutionTargets(contract: DeliveryContractV2, report?: Reporter): void;
+export declare function validateExecutionTargets(contract: DeliveryContractV2, report?: Reporter, options?: {
+    defer_completion_authority_closure?: boolean;
+    acceptance_reachability?: AcceptanceReachabilityV1 | null;
+    compiled_outcomes?: readonly CompiledOutcomeV2[];
+}): void;
 export declare function validateExternalConfirmationImpacts(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter): void;
 export {};

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

@@ -1,4 +1,5 @@
-import { outcomeResultExternallyBlocked, } from "./long-task-claims.js";
+import { machineAuthorizedAssertions } from "./long-task-acceptance-reachability-helpers.js";
+import { resultApplicabilityEffectivelyExternallyBlocked, resultApplicabilityProfiles, } from "./long-task-effective-external-takeover.js";
 const FAMILY_CAPABILITY = {
     browser: "browser-runtime",
     native: "native-runtime",
@@ -7,13 +8,14 @@ const FAMILY_CAPABILITY = {
     process: "process-runtime",
     external: "external-runtime",
 };
-export function validateExecutionTargets(contract, report) {
+export function validateExecutionTargets(contract, report, options = {}) {
     const targets = indexExecutionTargets(contract, report);
     const requiredTargetRefs = contract.task.target_profile.required_target_refs;
     validateRequiredTargetRefs(contract, targets, report);
     for (const [outcomeKey, check] of allChecks(contract))
         validateCheckTarget(outcomeKey, check, targets, report);
-    validateCriticalPathTargets(contract, requiredTargetRefs, report);
+    if (!options.defer_completion_authority_closure)
+        validateCriticalPathTargets(contract, requiredTargetRefs, report, options.acceptance_reachability, options.compiled_outcomes);
 }
 function indexExecutionTargets(contract, report) {
     const targets = new Map();
@@ -90,23 +92,52 @@ function validateConformanceTarget(outcomeKey, check, target, report) {
     if (target.role !== "product" || check.execution_target.entrypoint !== "root")
         issue(report, "conformance_root_product_target_required", check.key);
 }
-function validateCriticalPathTargets(contract, requiredTargetRefs, report) {
+function validateCriticalPathTargets(contract, requiredTargetRefs, report, reachability, compiledOutcomes) {
     for (const outcomeKey of contract.risk.facts.critical_user_path) {
         const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
         if (!outcome)
             continue;
-        if (outcomeResultExternallyBlocked(contract, outcome.key))
-            continue;
+        const compiledOutcome = compiledOutcomes?.find((candidate) => candidate.key === outcome.key);
         for (const targetRef of requiredTargetRefs)
-            if (!outcome.acceptance.checks.some((check) => provesSuccess(check, targetRef)))
+            if (!provesEverySuccessApplicability({
+                outcome,
+                compiledOutcome,
+                targetRef,
+                reachability,
+                useCompiledAuthority: compiledOutcomes !== undefined,
+            }))
                 issue(report, "critical_path_required_target_proof_missing", `${outcome.key}:${targetRef}`);
     }
 }
-function provesSuccess(check, targetRef) {
+function provesEverySuccessApplicability(options) {
+    const profiles = resultApplicabilityProfiles(options.outcome, {
+        target_ref: options.targetRef,
+        journey_role: "success",
+    });
+    if (!profiles.length)
+        return false;
+    return profiles.every((profile) => resultApplicabilityEffectivelyExternallyBlocked(options.reachability, options.outcome.key, profile.key, profile.target_ref) ||
+        (options.useCompiledAuthority
+            ? provesCompiledSuccess(options.compiledOutcome?.acceptance.checks ?? [], options.targetRef, profile.key)
+            : options.outcome.acceptance.checks.some((check) => provesDeclaredSuccess(check, options.targetRef, profile.key))));
+}
+function provesCompiledSuccess(checks, targetRef, applicabilityRef) {
+    return machineAuthorizedAssertions(checks, {
+        authority_scope: "ordinary_claim",
+        local_claim_ref: "result",
+        applicability_ref: applicabilityRef,
+        target_ref: targetRef,
+        check_journey_role: "success",
+        required_evidence_capability: "target_runtime",
+    }).some((match) => match.check.execution_target.entrypoint === "root");
+}
+function provesDeclaredSuccess(check, targetRef, applicabilityRef) {
     return (check.execution_target.target_ref === targetRef &&
         check.journey_roles.includes("success") &&
         check.execution_target.entrypoint === "root" &&
-        provesTargetRuntime(check));
+        [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.claims.includes("result") &&
+            assertion.applicability_ref === applicabilityRef &&
+            assertion.evidence_capabilities.includes("target_runtime")));
 }
 function provesTargetRuntime(check) {
     return [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime"));

package/dist/lib/long-task-terminal-finalization.d.ts

@@ -0,0 +1,12 @@
+import type { FinalReceiptV3, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import { type FinalizationIdentityV1 } from "./long-task-finalization-identity.js";
+import { type ActiveAuthorityIdentityExpectation } from "./long-task-state.js";
+export declare function finalizeDeliveryGateCas(input: {
+    provisional_result: Omit<FinalReceiptV3, "receipt_sha256" | "finalization_identity_sha256">;
+    expected_authority: ActiveAuthorityIdentityExpectation;
+    expected_finalization_identity: FinalizationIdentityV1;
+    repository: string;
+    workdir: string;
+    provisional_manifest: WorkspaceManifestV2;
+    close_on_accept: boolean;
+}): Promise<FinalReceiptV3>;

package/dist/lib/long-task-terminal-finalization.js

@@ -0,0 +1,190 @@
+import { access, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { evaluateExternalConfirmations } from "./long-task-external-confirmation-plan.js";
+import { captureFinalizationIdentity, finalizationIdentityDigest, } from "./long-task-finalization-identity.js";
+import { assertVerifierAuthorityCurrent, deliveryCompileFreshness, } from "./long-task-freshness.js";
+import { activeAuthorityIdentityMatches, assertMatchingActiveBinding, commitFinalReceiptTransaction, loadActiveLongTaskAuthority, sealFinalReceipt, withActiveAuthorityLock, } from "./long-task-state.js";
+import { canonicalValueJson } from "./strict-codec.js";
+import { captureWorkspaceFingerprint, currentGitState, } from "./long-task-workspace.js";
+import { workspaceFingerprintExcludedPrefixes } from "./long-task-workspace-manifest.js";
+export async function finalizeDeliveryGateCas(input) {
+    const expectedDigest = finalizationIdentityDigest(input.expected_finalization_identity);
+    return withActiveAuthorityLock(input.repository, "finalize", async (lockToken) => {
+        let currentActive = null;
+        let currentIdentity = null;
+        let currentExternal = null;
+        try {
+            currentActive = (await loadActiveLongTaskAuthority(input.repository, {
+                migrate_legacy: false,
+            })).authority;
+            if (!currentActive ||
+                currentActive.workdir !== input.workdir ||
+                !activeAuthorityIdentityMatches(currentActive, input.expected_authority))
+                throw new FinalizationCasError("finalization_authority_compare_and_swap_failed");
+            await assertVerifierAuthorityCurrent(input.repository, currentActive.verifier_identity);
+            const stale = await deliveryCompileFreshness(currentActive.authority_snapshot);
+            if (stale.length)
+                throw new FinalizationCasError(`finalization_compiled_inputs_stale:${stale.join(",")}`);
+            const compiled = await compileDeliveryContract(input.workdir, input.repository, {
+                live_gate: true,
+                initial_task_base: currentActive.initial_task_base,
+                authority_revision: currentActive.authority_revision,
+                require_completion_gate: true,
+            });
+            await assertMatchingActiveBinding(compiled);
+            const current = await captureCurrentFinalizationState(input.repository, input.workdir, currentActive, compiled, input.provisional_manifest);
+            currentIdentity = current.identity;
+            assertExpectedFinalizationIdentity(currentIdentity, input.expected_finalization_identity);
+            currentExternal = await evaluateExternalConfirmations(compiled, input.repository, input.workdir, input.provisional_manifest, current.candidate);
+            if (canonicalValueJson(currentExternal) !==
+                canonicalValueJson(input.provisional_result.external_confirmation_results))
+                throw new FinalizationCasError("finalization_external_evaluation_changed");
+            await finalizationPhaseSignal("after_finalization_evaluation");
+            const unsigned = {
+                ...input.provisional_result,
+                external_confirmation_results: currentExternal,
+                finalization_identity_sha256: expectedDigest,
+                completed_at: new Date().toISOString(),
+            };
+            const accepted = acceptedWorkflowStatus(unsigned.workflow_status);
+            return await commitFinalReceiptTransaction({
+                lock_token: lockToken,
+                repository_root: input.repository,
+                workdir: input.workdir,
+                unsigned,
+                expected_authority: input.expected_authority,
+                close_on_accept: input.close_on_accept && accepted,
+                validate_current: async (phase) => {
+                    await finalizationPhaseSignal(phase);
+                    const refreshed = await captureCurrentFinalizationState(input.repository, input.workdir, currentActive, compiled, input.provisional_manifest);
+                    assertExpectedFinalizationIdentity(refreshed.identity, input.expected_finalization_identity);
+                },
+            });
+        }
+        catch (error) {
+            const currentDigest = currentIdentity
+                ? finalizationIdentityDigest(currentIdentity)
+                : expectedDigest;
+            const failure = rejectedReceipt(input.provisional_result, currentExternal, currentDigest, error);
+            const activeNow = (await loadActiveLongTaskAuthority(input.repository, {
+                migrate_legacy: false,
+            }).catch(() => ({ authority: null }))).authority;
+            if (activeNow && activeNow.workdir === input.workdir) {
+                const currentExpectation = authorityExpectation(activeNow);
+                try {
+                    return await commitFinalReceiptTransaction({
+                        lock_token: lockToken,
+                        repository_root: input.repository,
+                        workdir: input.workdir,
+                        unsigned: failure,
+                        expected_authority: currentExpectation,
+                        close_on_accept: false,
+                        validate_current: async () => undefined,
+                    });
+                }
+                catch {
+                    // A failure Receipt is audit-only. If even its persistence CAS races,
+                    // return a sealed non-accepted result without overwriting newer state.
+                }
+            }
+            return sealFinalReceipt(failure);
+        }
+    });
+}
+async function captureCurrentFinalizationState(repository, workdir, active, compiled, provisionalManifest) {
+    // Fingerprint capture runs git write-tree. The finalization lock excludes
+    // Harness mutations, while this ordering also prevents a same-process
+    // currentGitState status refresh from competing for the repository index.
+    const fingerprint = await captureWorkspaceFingerprint(repository, workspaceFingerprintExcludedPrefixes(repository, [workdir]));
+    const git = await currentGitState(repository);
+    if (git.dirty.length ||
+        fingerprint.head !== git.head ||
+        fingerprint.head_tree !== git.tree ||
+        provisionalManifest.git_head !== git.head ||
+        provisionalManifest.fingerprint.head_tree !== git.tree ||
+        provisionalManifest.fingerprint.identity !== fingerprint.identity ||
+        provisionalManifest.snapshot_sha256 !== fingerprint.identity)
+        throw new FinalizationCasError(`finalization_candidate_not_clean_or_stable:${git.dirty.join(",")}`);
+    const candidate = {
+        git_head: git.head,
+        git_tree: git.tree,
+        snapshot_sha256: fingerprint.identity,
+    };
+    return {
+        candidate,
+        identity: await captureFinalizationIdentity({
+            repository,
+            active,
+            compiled,
+            candidate,
+            workspace_fingerprint: fingerprint,
+        }),
+    };
+}
+function assertExpectedFinalizationIdentity(current, expected) {
+    if (finalizationIdentityDigest(current) !== finalizationIdentityDigest(expected))
+        throw new FinalizationCasError("finalization_identity_compare_and_swap_failed");
+}
+function rejectedReceipt(provisional, currentExternal, finalizationIdentitySha256, error) {
+    const reason = message(error);
+    const finding = {
+        code: reason.split(":", 1)[0] || "finalization_compare_and_swap_failed",
+        outcome_key: null,
+        check_key: null,
+        message: "Finalization identity or persistence changed during the Live Final Gate; no accepted terminal was published and Active Authority was not cleared.",
+        actual: { reason },
+        invalidation_reasons: [reason],
+        next_action: "Stop concurrent mutation, inspect the current Authority/candidate/external state, and rerun the complete Live Final Gate.",
+    };
+    return {
+        ...provisional,
+        workflow_status: "needs_work",
+        target_state: "not_accepted",
+        stage_results: Object.fromEntries(Object.keys(provisional.stage_results).map((key) => [key, "failed"])),
+        outcome_results: Object.fromEntries(Object.keys(provisional.outcome_results).map((key) => [key, "failed"])),
+        external_confirmation_results: currentExternal ?? provisional.external_confirmation_results,
+        findings: [...provisional.findings, finding],
+        finalization_identity_sha256: finalizationIdentitySha256,
+        completed_at: new Date().toISOString(),
+    };
+}
+function authorityExpectation(active) {
+    return {
+        task_id: active.task_id,
+        authority_revision: active.authority_revision,
+        compiled_identity: active.active_authority_identity,
+        worktree_identity: active.worktree_identity,
+    };
+}
+function acceptedWorkflowStatus(status) {
+    return status === "machine_accepted" || status === "delivery_accepted";
+}
+class FinalizationCasError extends Error {
+}
+async function finalizationPhaseSignal(phase) {
+    if (process.env.NODE_ENV !== "test")
+        return false;
+    const configured = process.env.TY_CONTEXT_TEST_FINALIZATION_SIGNAL_DIR;
+    if (!configured)
+        return false;
+    if (!path.isAbsolute(configured))
+        throw new FinalizationCasError("finalization_test_signal_directory_must_be_absolute");
+    const folder = path.resolve(configured);
+    await mkdir(folder, { recursive: true });
+    const started = path.join(folder, `${phase}.started`);
+    const release = path.join(folder, `${phase}.release`);
+    await writeFile(started, `${phase}\n`, { flag: "a" });
+    const deadline = Date.now() + 45_000;
+    while (Date.now() < deadline) {
+        if (await access(release)
+            .then(() => true)
+            .catch(() => false))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new FinalizationCasError(`finalization_test_signal_timeout:${phase}`);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-ui-design-policy.js

@@ -70,8 +70,11 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
             const methodAssertion = check.positive_assertions.find((item) => item.key === methodBinding.assertion_ref);
             if (!methodAssertion)
                 issue(report, "ui_design_target_verification_assertion_unknown", `${label}:${methodBinding.method}:${methodBinding.assertion_ref}`);
-            else if (!methodAssertion.evidence_capabilities.includes("design_method"))
-                issue(report, "ui_design_target_verification_capability_required", `${label}:${methodBinding.method}:design_method`);
+            else {
+                validateDesignMethodAssertionClaims(target, methodAssertion, label, methodBinding.method, report);
+                if (!methodAssertion.evidence_capabilities.includes("design_method"))
+                    issue(report, "ui_design_target_verification_capability_required", `${label}:${methodBinding.method}:design_method`);
+            }
             const conditionKeys = methodBinding.evidence_artifacts.map((item) => item.condition_key);
             unique(conditionKeys, "ui_design_method_evidence_condition_duplicate", `${label}:${methodBinding.method}`, report);
             if (!sameSet(conditionKeys, target.condition_keys))
@@ -108,8 +111,11 @@ function validateSymbolicDesignBindings(target, check, label, artifactPaths, rep
         const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
         if (!assertion)
             issue(report, "ui_design_symbolic_method_assertion_unknown", `${label}:${binding.method}:${binding.assertion_ref}`);
-        else if (!assertion.evidence_capabilities.includes("design_method"))
-            issue(report, "ui_design_symbolic_method_capability_required", `${label}:${binding.method}`);
+        else {
+            validateDesignMethodAssertionClaims(target, assertion, label, binding.method, report);
+            if (!assertion.evidence_capabilities.includes("design_method"))
+                issue(report, "ui_design_symbolic_method_capability_required", `${label}:${binding.method}`);
+        }
         if (!binding.rule_expectations.length)
             issue(report, "ui_design_symbolic_rule_expectations_required", `${label}:${binding.method}`);
         unique(binding.rule_expectations.map((item) => item.obligation_ref), "ui_design_symbolic_obligation_duplicate", `${label}:${binding.method}`, report);
@@ -139,6 +145,11 @@ function validateSymbolicDesignBindings(target, check, label, artifactPaths, rep
     unique(certificate.expectations.map((item) => item.certificate_ref), "ui_design_symbolic_certificate_duplicate", label, report);
     validateSymbolicArtifactPath(certificate.artifact_path, target, check, label, artifactPaths, report);
 }
+function validateDesignMethodAssertionClaims(target, assertion, label, method, report) {
+    for (const claimRef of assertion.claims)
+        if (claimRef === "result")
+            issue(report, "ui_design_target_verification_claim_not_owned", `${label}:${method}:${target.conformance_check_ref}:${assertion.key}:${claimRef}`);
+}
 function validateSymbolicArtifactPath(artifactPath, _target, check, label, artifactPaths, report) {
     if (artifactPaths.has(artifactPath))
         issue(report, "ui_design_symbolic_evidence_artifact_reused", `${label}:${artifactPath}`);

package/dist/lib/long-task-verifier-counterfactuals.d.ts

@@ -0,0 +1,11 @@
+import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function evaluateSelectedCounterfactuals(input: {
+    compiled: CompiledDeliveryContractV2;
+    selected_checks: readonly CompiledCheckV2[];
+    complete_checks: readonly CompiledCheckV2[];
+    snapshot_root: string;
+    snapshot_manifest: WorkspaceManifestV2;
+    observation_authority_paths: readonly string[];
+    baseline_results: readonly CheckExecutionResultV2[];
+    baseline_executions: ReadonlyMap<string, RawCommandExecutionV2>;
+}): Promise<LongTaskFindingV2[]>;