project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -1,14 +1,29 @@
-import { spawn } from "node:child_process";
-import { access } from "node:fs/promises";
+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 { 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 { sha256Hex } from "./strict-codec.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 const OUTPUT_LIMIT = 2 * 1024 * 1024;
-export async function executeCheckRunner(check, snapshotRoot) {
+const PROCESS_TREE_GRACE_MS = 1_000;
+const execFileAsync = promisify(execFile);
+export async function executeCheckRunner(check, snapshotRoot, context) {
     const started = Date.now();
+    let processAuthorities;
+    try {
+        processAuthorities = processObservationAuthorities(check.observation_authorities ?? [], context?.observation_authorities ?? []);
+    }
+    catch (error) {
+        return invalidRawExecution(check, started, message(error));
+    }
+    const processObserverIssue = validateProcessObserverActivation(check, snapshotRoot, processAuthorities, context);
+    if (processObserverIssue)
+        return invalidRawExecution(check, started, processObserverIssue);
     const unavailable = await probeEnvironment(check.environment_requirements, snapshotRoot);
     if (unavailable)
         return {
@@ -31,11 +46,27 @@ export async function executeCheckRunner(check, snapshotRoot) {
     const maximumAttempts = retryAllowed ? 2 : 1;
     for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
         try {
-            const raw = await runOnce(check, snapshotRoot);
+            const raw = await runOnce(check, snapshotRoot, processAuthorities, context?.snapshot_sha256, context?.process_runtime_closure_identity);
             const secrets = declaredEnvironmentValues(check.environment_requirements);
-            const decoded = outputContainsDeclaredEnvironmentValue(raw, secrets)
+            let decoded = outputContainsDeclaredEnvironmentValue(raw, secrets)
                 ? invalidEvidence(raw.exit_code, "check_evidence_contains_declared_environment_value")
-                : decodeCheckEvidence(check, raw.exit_code, raw.stdout, raw.stderr);
+                : raw.process_observation
+                    ? {
+                        execution_status: "completed",
+                        exit_code: raw.exit_code,
+                        observations: {},
+                        evidence_records: [],
+                        error: null,
+                    }
+                    : decodeCheckEvidence(check, raw.exit_code, raw.stdout, raw.stderr);
+            if (raw.process_observation && raw.exit_code !== 0)
+                decoded = invalidEvidence(raw.exit_code, "process_observer_nonzero_exit");
+            else if (raw.process_observation &&
+                decoded.execution_status !== "completed")
+                decoded = invalidEvidence(raw.exit_code, "project_submitted_execution_status_disagrees_with_harness");
+            if (raw.process_observation &&
+                packageObservationContainsDeclaredEnvironmentValue(raw.process_observation, secrets))
+                decoded = invalidEvidence(raw.exit_code, "check_evidence_contains_declared_environment_value");
             return {
                 raw_execution_identity: check.raw_execution_identity,
                 execution_identity: check.raw_execution_identity,
@@ -44,6 +75,8 @@ export async function executeCheckRunner(check, snapshotRoot) {
                 stderr_sha256: sha256Hex(raw.stderr),
                 attempts: attempt,
                 duration_ms: Date.now() - started,
+                package_observations: raw.process_observation?.package_observations ?? [],
+                host_execution_attestation: raw.host_execution_attestation,
             };
         }
         catch (error) {
@@ -53,7 +86,9 @@ export async function executeCheckRunner(check, snapshotRoot) {
             return {
                 raw_execution_identity: check.raw_execution_identity,
                 execution_identity: check.raw_execution_identity,
-                execution_status: "infrastructure_error",
+                execution_status: isProcessObservationError(reason)
+                    ? "invalid_evidence"
+                    : "infrastructure_error",
                 exit_code: -1,
                 observations: {},
                 evidence_records: [],
@@ -62,37 +97,100 @@ export async function executeCheckRunner(check, snapshotRoot) {
                 attempts: attempt,
                 duration_ms: Date.now() - started,
                 error: reason,
+                package_observations: [],
+                host_execution_attestation: null,
             };
         }
     }
     throw new Error("unreachable");
 }
-async function runOnce(check, snapshotRoot) {
+async function runOnce(check, snapshotRoot, processAuthorities, snapshotSha256, processRuntimeClosureIdentity) {
     const runner = check.runner;
     const cwd = resolveInsideRepository(snapshotRoot, runner.resolved_cwd || ".", "runner.resolved_cwd");
     const executable = runner.type === "project_binary"
         ? resolveInsideRepository(snapshotRoot, runner.resolved_target, "runner.resolved_target")
         : 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);
+        return {
+            ...execution,
+            process_observation: null,
+            host_execution_attestation: null,
+        };
+    }
+    const executionNonce = randomBytes(32).toString("hex");
+    const execution = await spawnOnce(executable, argv, cwd, runner.timeout_ms, runnerEnvironment(check.environment_requirements, "product_observation"), true);
+    const processObservation = decodeProductObservationEnvelope({
+        bytes: execution.stdout,
+        authorities: processAuthorities,
+    });
+    const declaredRoot = resolveInsideRepository(snapshotRoot, processAuthorities[0].runtime_requirements.declared_root_entrypoint, "process_observer.declared_root_entrypoint");
+    const [actualExecutable, actualDeclaredRoot] = await Promise.all([
+        realpath(executable),
+        realpath(declaredRoot),
+    ]);
+    const directRootMatch = sameHostPath(actualExecutable, actualDeclaredRoot) &&
+        sameStringArray(argv, processAuthorities[0].runtime_requirements.declared_root_argv ?? []);
+    if (!directRootMatch)
+        throw new Error("process_observer_direct_root_required");
+    return {
+        exit_code: execution.exit_code,
+        stdout: execution.stdout,
+        stderr: execution.stderr,
+        process_observation: processObservation,
+        host_execution_attestation: {
+            raw_execution_identity: check.raw_execution_identity,
+            executable_path: actualExecutable,
+            declared_root_entrypoint: actualDeclaredRoot,
+            actual_argv: [...argv],
+            declared_root_argv: [
+                ...(processAuthorities[0].runtime_requirements.declared_root_argv ??
+                    []),
+            ],
+            direct_root_match: directRootMatch,
+            pid: execution.pid,
+            started_at: execution.started_at,
+            completed_at: execution.completed_at,
+            exit_code: execution.exit_code,
+            snapshot_sha256: snapshotSha256,
+            observation_execution_nonce: executionNonce,
+            observation_artifact_sha256: processObservation.artifact_sha256,
+            process_runtime_closure_identity: processRuntimeClosureIdentity,
+        },
+    };
+}
+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: runnerEnvironment(check.environment_requirements),
+            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) {
-                child.kill();
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("command_output_limit_exceeded"));
-                }
+                terminate("command_output_limit_exceeded");
                 return;
             }
             target.push(Buffer.from(chunk));
@@ -102,29 +200,348 @@ async function runOnce(check, snapshotRoot) {
         child.on("error", (error) => {
             if (!settled) {
                 settled = true;
-                reject(new Error(`command_spawn_error:${message(error)}`));
+                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(() => {
-            child.kill();
-            if (!settled) {
-                settled = true;
-                reject(new Error("command_timeout"));
-            }
-        }, runner.timeout_ms);
-        child.on("close", (code) => {
+            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;
+    if (!context?.snapshot_sha256)
+        return "process_observer_snapshot_identity_required";
+    if (!context.process_runtime_closure_identity ||
+        !check.process_runtime_closure ||
+        context.process_runtime_closure_identity !==
+            check.process_runtime_closure.closure_identity)
+        return "process_runtime_closure_identity_mismatch";
+    if (check.environment_requirements.some((requirement) => requirement.kind === "env_var" &&
+        (requirement.target.toUpperCase() === "TY_CONTEXT_OBSERVATION_OUTPUT" ||
+            requirement.target.toUpperCase() ===
+                "TY_CONTEXT_OBSERVATION_CHALLENGE" ||
+            requirement.target.toUpperCase() === "TY_CONTEXT_CHECK_PROTOCOL")))
+        return "process_observer_reserved_environment_requirement";
+    if (check.runner.type !== "project_binary" ||
+        check.execution_target.entrypoint !== "root")
+        return "process_observer_direct_root_required";
+    const executable = resolveInsideRepository(snapshotRoot, check.runner.resolved_target, "process_observer.runner_target");
+    const actualArgv = [
+        ...check.runner.executable_argv_prefix,
+        ...check.runner.argv,
+    ];
+    for (const authority of authorities) {
+        const requirements = authority.runtime_requirements;
+        if (requirements.runtime_family !== "process" ||
+            requirements.target_role !== "product" ||
+            requirements.entrypoint !== "root" ||
+            requirements.runner_type !== "project_binary" ||
+            requirements.resolved_runner_target !== check.runner.resolved_target ||
+            requirements.declared_root_argv === null ||
+            !sameStringArray(requirements.resolved_runner_argv, check.runner.argv) ||
+            !sameStringArray(requirements.declared_root_argv, actualArgv) ||
+            check.runner.executable_argv_prefix.length !== 0 ||
+            !requirements.direct_root_match)
+            return "process_observer_direct_root_required";
+        const declaredRoot = resolveInsideRepository(snapshotRoot, requirements.declared_root_entrypoint, "process_observer.declared_root_entrypoint");
+        if (!sameHostPath(executable, declaredRoot))
+            return "process_observer_direct_root_required";
+    }
+    return null;
+}
+function processObservationAuthorities(checkAuthorities, groupedAuthorities) {
+    const byIdentity = new Map();
+    for (const authority of [...checkAuthorities, ...groupedAuthorities]) {
+        if (authority.authority !== "package_process_json_exact")
+            continue;
+        const identity = `${authority.assertion_ref}\0${authority.obligation_ref}\0${authority.method}`;
+        const existing = byIdentity.get(identity);
+        if (existing &&
+            canonicalValueJson(existing) !== canonicalValueJson(authority))
+            throw new Error("process_observation_authority_group_mismatch");
+        byIdentity.set(identity, authority);
+    }
+    return [...byIdentity.values()];
+}
+function invalidRawExecution(check, started, reason) {
+    return {
+        raw_execution_identity: check.raw_execution_identity,
+        execution_identity: check.raw_execution_identity,
+        execution_status: "invalid_evidence",
+        exit_code: -1,
+        observations: {},
+        evidence_records: [],
+        stdout_sha256: sha256Hex(""),
+        stderr_sha256: sha256Hex(reason),
+        attempts: 0,
+        duration_ms: Date.now() - started,
+        error: reason,
+        package_observations: [],
+        host_execution_attestation: null,
+    };
+}
+function packageObservationContainsDeclaredEnvironmentValue(observation, values) {
+    if (!values.length)
+        return false;
+    const serialized = JSON.stringify(observation.observations);
+    return values.some((value) => serialized.includes(value));
+}
+function isProcessObservationError(reason) {
+    return (reason.startsWith("process_observation_") ||
+        reason.startsWith("process_observer_"));
+}
+function sameHostPath(left, right) {
+    return process.platform === "win32"
+        ? path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase()
+        : path.resolve(left) === path.resolve(right);
+}
+function sameStringArray(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
 async function probeEnvironment(requirements, snapshotRoot) {
     for (const requirement of requirements) {
         let available = false;

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

@@ -4,7 +4,25 @@ 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,6 +2,15 @@ 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)]));
@@ -69,6 +78,8 @@ function compileGlobalScope(contract, claims, profiles) {
         validateGlobalAssertionOperator(proof.assertion, proof.check.key);
         addProof(proofs, claimKey, claimProof);
     }
+    for (const claim of claims)
+        addBlockingExternalConfirmationProofs(contract, claim, proofs);
     validateProfileUse("GLOBAL", profiles, claims);
     return Object.fromEntries(claims.map((claim) => {
         const claimProofs = proofs.get(claim.local_key) ?? [];
@@ -141,6 +152,9 @@ function compileOutcomeScope(contract, outcomeKey, claims, profiles, outcomeKeys
             applicability_ref: factBinding.applicability_ref,
         });
     }
+    for (const claim of claims)
+        if (claim.kind !== "semantic_fact")
+            addBlockingExternalConfirmationProofs(contract, claim, proofs);
     validatePopulationReferences(outcome, claimMap);
     validateCounterfactualReferences(outcome, claimMap);
     validateProfileUse(outcomeKey, profiles, claims);
@@ -254,6 +268,7 @@ function validateCounterfactualReferences(outcome, claims) {
         for (const assertion of [
             ...control.expected_assertion_failures,
             ...control.preserved_assertions,
+            ...control.allowed_fanout_assertions,
         ])
             if (!assertions.has(assertion))
                 fail("counterfactual_assertion_unknown", `${outcome.key}:${control.key}:${assertion}`);
@@ -306,6 +321,26 @@ function addProof(proofs, claim, proof) {
     rows.push(proof);
     proofs.set(claim, rows);
 }
+function addBlockingExternalConfirmationProofs(contract, claim, proofs) {
+    const confirmations = contract.global.acceptance.external_confirmations.filter((confirmation) => confirmation.blocks_target &&
+        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)
+                addProof(proofs, claim.local_key, {
+                    check_key: `EXTERNAL.${confirmation.key}`,
+                    assertion_key: null,
+                    polarity: claim.required_polarity,
+                    proof_surface: proofSurface,
+                    applicability_ref: applicabilityRef,
+                });
+}
 function sameSet(left, right) {
     return (left.length === right.length &&
         new Set(left).size === left.length &&

package/dist/lib/long-task-compact-structure-targets.js

@@ -11,6 +11,7 @@ const BASE_STRUCTURE_BOUNDARY_BY_FIELD = {
     journey_roles: "contract.check.journey-roles",
     carrier_paths: "contract.binding.carrier-paths",
     preserved_assertions: "contract.counterfactual.preserved-assertions",
+    allowed_fanout_assertions: "contract.counterfactual.allowed-fanout-assertions",
     expected_assertion_failures: "contract.counterfactual.expected-assertion-failures",
 };
 export function longTaskCompactSharedStructureTargets(root, carrier) {

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

@@ -1,3 +1,4 @@
+import { allOutcomeResultsExternallyBlocked } from "./long-task-claims.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))
@@ -8,7 +9,8 @@ export function semanticConformanceRequired(contract, _effectiveRisk) {
 export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
     const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
     if (semanticConformanceRequired(contract, effectiveRisk) &&
-        !declared.length) {
+        !declared.length &&
+        !allOutcomeResultsExternallyBlocked(contract)) {
         issue(report, "semantic_conformance_check_required", contract.task.id);
         return;
     }

package/dist/lib/long-task-counterfactual-claim-policy.d.ts

@@ -1,10 +1,9 @@
 import type { CounterfactualControlV2, DeliveryContractV2, DeliveryBindingV2, DeliveryOutcomeV2, GlobalCounterfactualControlV2 } from "./long-task-delivery-types.js";
+import { type ScopedDeliveryBindingV2 } from "./long-task-scoped-binding.js";
 export declare function validateCounterfactualBindingClaims(outcome: DeliveryOutcomeV2, control: CounterfactualControlV2, binding: DeliveryBindingV2): void;
-export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+export declare function resolveGlobalCounterfactualBinding(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
     outcome: DeliveryOutcomeV2;
-    binding: DeliveryBindingV2;
 };
-export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): {
+export declare function validateGlobalCounterfactualBindingClaims(contract: DeliveryContractV2, control: GlobalCounterfactualControlV2): ScopedDeliveryBindingV2 & {
     outcome: DeliveryOutcomeV2;
-    binding: DeliveryBindingV2;
 };