project-tiny-context-harness 0.8.16 → 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-runner.js

@@ -1,17 +1,13 @@
-import { execFile, spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { access, realpath } from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
-import { promisify } from "node:util";
 import { decodeCheckEvidence, invalidEvidence, } from "./long-task-check-evidence-decoder.js";
+import { spawnCommandOnce } from "./long-task-command-process.js";
 import { declaredEnvironmentValues, outputContainsDeclaredEnvironmentValue, runnerEnvironment, } from "./long-task-runner-environment.js";
 import { decodeProductObservationEnvelope } from "./long-task-process-observation.js";
 import { resolveInsideRepository } from "./long-task-workspace.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-const OUTPUT_LIMIT = 2 * 1024 * 1024;
-const PROCESS_TREE_GRACE_MS = 1_000;
-const execFileAsync = promisify(execFile);
 export async function executeCheckRunner(check, snapshotRoot, context) {
     const started = Date.now();
     let processAuthorities;
@@ -112,7 +108,7 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         : runner.executable;
     const argv = [...runner.executable_argv_prefix, ...runner.argv];
     if (!processAuthorities.length) {
-        const execution = await spawnOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements), false);
+        const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements), false);
         return {
             ...execution,
             process_observation: null,
@@ -120,7 +116,7 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         };
     }
     const executionNonce = randomBytes(32).toString("hex");
-    const execution = await spawnOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
+    const execution = await spawnCommandOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
     const processObservation = decodeProductObservationEnvelope({
         bytes: execution.stdout,
         authorities: processAuthorities,
@@ -160,295 +156,6 @@ async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256,
         },
     };
 }
-async function spawnOnce(executable, argv, cwd, timeoutMs, environment, containProcessTree) {
-    return new Promise((resolve, reject) => {
-        const startedAt = new Date().toISOString();
-        const child = spawn(executable, argv, {
-            cwd,
-            shell: false,
-            windowsHide: true,
-            env: environment,
-            detached: containProcessTree && process.platform !== "win32",
-        });
-        const pid = child.pid ?? -1;
-        let stopTreeMonitor = false;
-        let treeMonitorError = null;
-        const observedDescendants = new Set();
-        const treeMonitor = containProcessTree && pid > 0
-            ? observeDescendantProcesses(pid, observedDescendants, () => stopTreeMonitor).catch((error) => {
-                treeMonitorError = error;
-            })
-            : Promise.resolve();
-        const stdout = [];
-        const stderr = [];
-        let size = 0;
-        let settled = false;
-        let terminationReason = null;
-        let terminationTask = null;
-        let forceTimer = null;
-        let abandonTimer = null;
-        const capture = (target) => (chunk) => {
-            size += chunk.length;
-            if (size > OUTPUT_LIMIT) {
-                terminate("command_output_limit_exceeded");
-                return;
-            }
-            target.push(Buffer.from(chunk));
-        };
-        child.stdout.on("data", capture(stdout));
-        child.stderr.on("data", capture(stderr));
-        child.on("error", (error) => {
-            if (!settled) {
-                settled = true;
-                stopTreeMonitor = true;
-                clearTimeout(timer);
-                if (forceTimer)
-                    clearTimeout(forceTimer);
-                if (abandonTimer)
-                    clearTimeout(abandonTimer);
-                const spawnError = new Error(`command_spawn_error:${message(error)}`);
-                if (containProcessTree && pid > 0)
-                    void terminateProcessTree(pid, true, [...observedDescendants])
-                        .catch(() => undefined)
-                        .finally(() => reject(spawnError));
-                else
-                    reject(spawnError);
-            }
-        });
-        const timer = setTimeout(() => {
-            terminate("command_timeout");
-        }, timeoutMs);
-        if (pid < 0)
-            terminate("command_spawn_pid_unavailable");
-        child.on("close", async (code) => {
-            stopTreeMonitor = true;
-            clearTimeout(timer);
-            if (forceTimer)
-                clearTimeout(forceTimer);
-            if (abandonTimer)
-                clearTimeout(abandonTimer);
-            if (settled)
-                return;
-            settled = true;
-            if (terminationReason) {
-                try {
-                    await terminationTask;
-                    await treeMonitor;
-                    if (containProcessTree)
-                        await forceProcessTreeQuiescence(pid, observedDescendants);
-                }
-                catch {
-                    // The original bounded termination reason remains the public error;
-                    // cleanup is best-effort after the hard process-tree kill attempt.
-                }
-                reject(terminationReason);
-                return;
-            }
-            if (containProcessTree) {
-                try {
-                    await treeMonitor;
-                    if (treeMonitorError)
-                        throw treeMonitorError;
-                    await assertProcessTreeQuiescent(pid, observedDescendants);
-                }
-                catch (error) {
-                    await terminateProcessTree(pid, true, [...observedDescendants]).catch(() => undefined);
-                    reject(error);
-                    return;
-                }
-            }
-            resolve({
-                exit_code: code ?? -1,
-                stdout: Buffer.concat(stdout),
-                stderr: Buffer.concat(stderr),
-                pid,
-                started_at: startedAt,
-                completed_at: new Date().toISOString(),
-            });
-        });
-        function terminate(reason) {
-            if (settled || terminationReason)
-                return;
-            terminationReason = new Error(reason);
-            stopTreeMonitor = true;
-            if (containProcessTree)
-                terminationTask = terminateProcessTree(pid, false).catch((error) => {
-                    treeMonitorError ??= error;
-                });
-            else {
-                child.kill();
-                terminationTask = Promise.resolve();
-            }
-            forceTimer = setTimeout(() => {
-                if (containProcessTree)
-                    terminationTask = terminateProcessTree(pid, true, [
-                        ...observedDescendants,
-                    ]).catch((error) => {
-                        treeMonitorError ??= error;
-                    });
-                else
-                    child.kill("SIGKILL");
-            }, PROCESS_TREE_GRACE_MS);
-            forceTimer.unref();
-            abandonTimer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                child.stdout.destroy();
-                child.stderr.destroy();
-                const cleanup = containProcessTree
-                    ? forceProcessTreeQuiescence(pid, observedDescendants).catch(() => undefined)
-                    : Promise.resolve();
-                void cleanup.finally(() => reject(terminationReason));
-            }, PROCESS_TREE_GRACE_MS * 2);
-            abandonTimer.unref();
-        }
-    });
-}
-async function forceProcessTreeQuiescence(rootPid, observed) {
-    await terminateProcessTree(rootPid, true, [...observed]);
-    const deadline = Date.now() + PROCESS_TREE_GRACE_MS;
-    while (Date.now() < deadline) {
-        const liveObserved = [rootPid, ...observed].some(processIdExists);
-        const groupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-        if (!liveObserved && !groupAlive)
-            return;
-        await new Promise((resolve) => setTimeout(resolve, process.platform === "win32" ? 100 : 25));
-    }
-    throw new Error("process_observer_descendant_process_alive");
-}
-async function observeDescendantProcesses(rootPid, observed, stopped) {
-    do {
-        for (const pid of await descendantProcessIds(rootPid))
-            observed.add(pid);
-        if (stopped())
-            return;
-        await new Promise((resolve) => setTimeout(resolve, process.platform === "win32" ? 100 : 25));
-    } while (!stopped());
-}
-async function assertProcessTreeQuiescent(rootPid, observed) {
-    const finalDescendants = await descendantProcessIds(rootPid);
-    const descendants = [...new Set([...observed, ...finalDescendants])].filter(processIdExists);
-    const processGroupAlive = process.platform !== "win32" && processGroupExists(rootPid);
-    if (!descendants.length && !processGroupAlive)
-        return;
-    await terminateProcessTree(rootPid, true, descendants);
-    throw new Error("process_observer_descendant_process_alive");
-}
-function processIdExists(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-async function terminateProcessTree(rootPid, force, knownDescendants) {
-    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
-        return;
-    if (process.platform === "win32") {
-        const targets = [
-            rootPid,
-            ...[...new Set(knownDescendants ?? [])]
-                .filter((pid) => pid !== rootPid)
-                .reverse(),
-        ];
-        for (const pid of targets)
-            await execFileAsync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
-                windowsHide: true,
-                timeout: PROCESS_TREE_GRACE_MS,
-            }).catch(() => undefined);
-        return;
-    }
-    const signal = force ? "SIGKILL" : "SIGTERM";
-    try {
-        process.kill(-rootPid, signal);
-    }
-    catch (error) {
-        if (nodeErrorCode(error) !== "ESRCH")
-            throw error;
-    }
-    const descendants = knownDescendants ?? (await descendantProcessIds(rootPid));
-    for (const pid of [...descendants].reverse())
-        try {
-            process.kill(pid, signal);
-        }
-        catch (error) {
-            if (nodeErrorCode(error) !== "ESRCH")
-                throw error;
-        }
-}
-async function descendantProcessIds(rootPid) {
-    let stdout;
-    try {
-        const result = process.platform === "win32"
-            ? await execFileAsync("powershell.exe", [
-                "-NoLogo",
-                "-NoProfile",
-                "-NonInteractive",
-                "-Command",
-                'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }',
-            ], {
-                encoding: "utf8",
-                windowsHide: true,
-                timeout: 5_000,
-                maxBuffer: OUTPUT_LIMIT,
-            })
-            : await execFileAsync("ps", ["-A", "-o", "pid=,ppid="], {
-                encoding: "utf8",
-                timeout: 5_000,
-                maxBuffer: OUTPUT_LIMIT,
-            });
-        stdout = result.stdout;
-    }
-    catch (error) {
-        throw new Error(`process_observer_process_tree_inspection_unavailable:${message(error)}`);
-    }
-    const children = new Map();
-    for (const line of stdout.split(/\r?\n/u)) {
-        const [pidText, parentText] = line.trim().split(/\s+/u);
-        const pid = Number.parseInt(pidText ?? "", 10);
-        const parent = Number.parseInt(parentText ?? "", 10);
-        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parent))
-            continue;
-        const row = children.get(parent);
-        if (row)
-            row.push(pid);
-        else
-            children.set(parent, [pid]);
-    }
-    const result = [];
-    const pending = [...(children.get(rootPid) ?? [])];
-    const seen = new Set();
-    while (pending.length) {
-        const pid = pending.shift();
-        if (seen.has(pid))
-            continue;
-        seen.add(pid);
-        result.push(pid);
-        pending.push(...(children.get(pid) ?? []));
-    }
-    return result;
-}
-function processGroupExists(rootPid) {
-    try {
-        process.kill(-rootPid, 0);
-        return true;
-    }
-    catch (error) {
-        if (nodeErrorCode(error) === "ESRCH")
-            return false;
-        throw error;
-    }
-}
-function nodeErrorCode(error) {
-    return error && typeof error === "object" && "code" in error
-        ? String(error.code)
-        : null;
-}
 function validateProcessObserverActivation(check, snapshotRoot, authorities, context) {
     if (!authorities.length)
         return null;

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 {};