project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -2,8 +2,8 @@ import { copyFile, rm, stat } from "node:fs/promises";
 import { evaluatePopulation } from "./long-task-assertions-v2.js";
 import { collectCheckArtifacts, prepareAdmittedObservations, } from "./long-task-artifacts.js";
 import { executeCheckRunner } from "./long-task-check-runner.js";
-import { prepareExecutionObservationGroup } from "./long-task-execution-observation.js";
-import { createCounterfactualSandbox } from "./long-task-counterfactual-sandbox.js";
+import { prepareCounterfactualExecutionObservationGroup } from "./long-task-execution-observation.js";
+import { counterfactualSandboxProcessExecution, createCounterfactualSandbox, } from "./long-task-counterfactual-sandbox.js";
 import { assertionFinding, checkFinding, classifyCheckStatus, evaluateAssertionResults, } from "./long-task-evidence-findings.js";
 import { classifyPlaywrightCounterfactual } from "./long-task-playwright-counterfactual-policy.js";
 import { admittedObservationAuthorityKey, classifyMachineObservationCarrierRoleConflict, } from "./long-task-admitted-observation.js";
@@ -181,68 +181,88 @@ export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, sele
 }
 async function evaluateCounterfactualSet(entries, snapshotRoot, manifest, protectedAuthorityPaths = [], baselineResults = [], baselineExecutions = new Map(), executionUniverse = []) {
     const findings = [];
-    for (const entry of entries) {
-        const { control, check } = entry;
-        const owningBinding = entry.owningOutcome.technical.bindings.find((binding) => `${entry.owningOutcome.key}.${binding.key}` === entry.bindingRef);
-        const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest, protectedAuthorityPaths);
-        const root = sandbox.root;
-        try {
-            const mutationTargets = counterfactualMutationTargets(control);
-            const missingTargets = await missingCounterfactualMutationTargets(root, mutationTargets);
-            if (missingTargets.length) {
-                findings.push(counterfactualIntegrityFinding(entry, {
-                    execution_status: "not_run",
-                    finding_codes: ["counterfactual_mutation_target_missing"],
-                    missing_targets: missingTargets,
-                }));
-                continue;
-            }
-            await applyCounterfactualMutation(root, control);
-            const raw = await executeCounterfactualCheck(check, root, manifest, protectedAuthorityPaths, executionUniverse);
-            const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome, protectedAuthorityPaths);
-            const observationImpactIssue = await counterfactualObservationImpactIssue(entry, baselineResults, baselineExecutions.get(check.raw_execution_identity), result, raw, snapshotRoot, root, mutationTargets, owningBinding?.carrier_paths ?? [], protectedAuthorityPaths, executionUniverse);
-            const playwrightClassification = result.evidence_adapter === "playwright_json_v1"
-                ? classifyPlaywrightCounterfactual(raw, result, control)
-                : null;
-            const sensitivityResult = playwrightClassification?.normalized_result ?? result;
-            const failedAssertions = result.assertion_results
-                .filter((assertion) => !assertion.passed)
-                .map((assertion) => assertion.key)
-                .sort();
-            const expected = [...control.expected_assertion_failures].sort();
-            const allowedFanout = [
-                ...(control.allowed_fanout_assertions ?? []),
-            ].sort();
-            const acceptedExit = playwrightClassification
-                ? playwrightClassification.accepted_test_failure_exit
-                : raw.exit_code === 0;
-            const valid = raw.execution_status === "completed" &&
-                acceptedExit &&
-                observationImpactIssue === null &&
-                isValidCounterfactualCheckResult(sensitivityResult, expected, allowedFanout);
-            if (!valid)
-                findings.push(counterfactualIntegrityFinding(entry, playwrightClassification
-                    ? playwrightCounterfactualDiagnostic(raw, result, expected, playwrightClassification.rejection_reasons)
-                    : {
-                        execution_status: raw.execution_status,
-                        exit_code: raw.exit_code,
-                        execution_error: raw.error,
-                        result_status: result.status,
-                        failed_assertions: failedAssertions,
-                        finding_codes: result.findings.map((finding) => finding.code),
-                        observation_impact_issue: observationImpactIssue,
-                    }));
-        }
-        finally {
-            await sandbox.dispose();
+    for (const entry of entries)
+        findings.push(...(await evaluateCounterfactualEntry(entry, snapshotRoot, manifest, protectedAuthorityPaths, baselineResults, baselineExecutions, executionUniverse)));
+    return findings;
+}
+async function evaluateCounterfactualEntry(entry, snapshotRoot, manifest, protectedAuthorityPaths, baselineResults, baselineExecutions, executionUniverse) {
+    const findings = [];
+    const { control, check } = entry;
+    const owningBinding = entry.owningOutcome.technical.bindings.find((binding) => `${entry.owningOutcome.key}.${binding.key}` === entry.bindingRef);
+    const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest, protectedAuthorityPaths, executionUniverse);
+    const root = sandbox.root;
+    try {
+        const mutationTargets = counterfactualMutationTargets(control);
+        const missingTargets = await missingCounterfactualMutationTargets(root, mutationTargets);
+        if (missingTargets.length) {
+            findings.push(counterfactualIntegrityFinding(entry, {
+                execution_status: "not_run",
+                finding_codes: ["counterfactual_mutation_target_missing"],
+                missing_targets: missingTargets,
+            }));
+            return findings;
         }
+        await applyCounterfactualMutation(root, control, sandbox.mutation_source_root);
+        const processExecution = counterfactualSandboxProcessExecution(sandbox);
+        if (processExecution)
+            await applyCounterfactualMutation(processExecution.root, control, processExecution.mutation_source_root);
+        const raw = await executeCounterfactualCheck(check, sandbox, manifest, protectedAuthorityPaths, executionUniverse);
+        const result = await evaluateCheckEvidence(check, raw, root, entry.evidenceOutcome, protectedAuthorityPaths);
+        const observationImpactIssue = await counterfactualObservationImpactIssue(entry, baselineResults, baselineExecutions.get(check.raw_execution_identity), result, raw, snapshotRoot, root, mutationTargets, owningBinding?.carrier_paths ?? [], protectedAuthorityPaths, executionUniverse);
+        const playwrightClassification = result.evidence_adapter === "playwright_json_v1"
+            ? classifyPlaywrightCounterfactual(raw, result, control)
+            : null;
+        const sensitivityResult = playwrightClassification?.normalized_result ?? result;
+        const failedAssertions = result.assertion_results
+            .filter((assertion) => !assertion.passed)
+            .map((assertion) => assertion.key)
+            .sort();
+        const expected = [...control.expected_assertion_failures].sort();
+        const allowedFanout = [...(control.allowed_fanout_assertions ?? [])].sort();
+        const acceptedExit = playwrightClassification
+            ? playwrightClassification.accepted_test_failure_exit
+            : raw.exit_code === 0;
+        const valid = raw.execution_status === "completed" &&
+            acceptedExit &&
+            observationImpactIssue === null &&
+            isValidCounterfactualCheckResult(sensitivityResult, expected, allowedFanout);
+        if (!valid)
+            findings.push(counterfactualIntegrityFinding(entry, playwrightClassification
+                ? playwrightCounterfactualDiagnostic(raw, result, expected, playwrightClassification.rejection_reasons)
+                : {
+                    execution_status: raw.execution_status,
+                    exit_code: raw.exit_code,
+                    execution_error: raw.error,
+                    result_status: result.status,
+                    failed_assertions: failedAssertions,
+                    finding_codes: result.findings.map((finding) => finding.code),
+                    observation_impact_issue: observationImpactIssue,
+                }));
+        return findings;
     }
-    return findings;
+    finally {
+        await sandbox.dispose();
+    }
+}
+export function counterfactualExecutionMayOverlap(input) {
+    const check = input.check;
+    const closure = check.process_runtime_closure;
+    const protectedPaths = input.protected_authority_paths ?? [];
+    if (check.runner.effect !== "read_only" ||
+        !check.runner.idempotent ||
+        check.runner.retry_policy !== "none" ||
+        check.environment_requirements.some((requirement) => requirement.kind === "loopback_tcp") ||
+        input.control.mutation.type === "replace_file" ||
+        !closure ||
+        !(check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"))
+        return false;
+    return counterfactualMutationTargets(input.control).every((target) => closure.production_carrier_files.includes(target) &&
+        !protectedPaths.some((pattern) => matchesRepoPattern(target, pattern)));
 }
-async function executeCounterfactualCheck(check, root, manifest, protectedAuthorityPaths, executionUniverse) {
+async function executeCounterfactualCheck(check, sandbox, manifest, protectedAuthorityPaths, executionUniverse) {
     const packageAuthorities = (check.observation_authorities ?? []).filter((authority) => authority.authority !== "external_confirmation");
     if (!packageAuthorities.length)
-        return executeCheckRunner(check, root);
+        return executeCheckRunner(check, sandbox.root);
     if (!manifest)
         return {
             raw_execution_identity: check.raw_execution_identity,
@@ -260,9 +280,9 @@ async function executeCounterfactualCheck(check, root, manifest, protectedAuthor
             host_execution_attestation: null,
         };
     const group = executionUniverse.filter((candidate) => candidate.raw_execution_identity === check.raw_execution_identity);
-    const prepared = await prepareExecutionObservationGroup({
+    const prepared = await prepareCounterfactualExecutionObservationGroup({
         checks: group.length ? group : [check],
-        snapshot_root: root,
+        sandbox,
         workspace_manifest: manifest,
         protected_authority_paths: protectedAuthorityPaths,
     });
@@ -285,153 +305,216 @@ async function missingCounterfactualMutationTargets(root, targets) {
             missing.push(target);
     return missing;
 }
-async function applyCounterfactualMutation(root, control) {
+async function applyCounterfactualMutation(root, control, mutationSourceRoot) {
     if (control.mutation.type === "remove_paths") {
         for (const target of control.mutation.paths)
             await rm(resolveInsideRepository(root, target, "counterfactual.remove_paths"), { recursive: true, force: true });
         return;
     }
     if (control.mutation.type === "replace_file") {
-        await copyFile(resolveInsideRepository(root, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
+        await copyFile(resolveInsideRepository(mutationSourceRoot, control.mutation.fixture_path, "counterfactual.fixture"), resolveInsideRepository(root, control.mutation.path, "counterfactual.path"));
         return;
     }
     await applyNarrowSemanticMutation(root, control.mutation);
 }
 async function counterfactualObservationImpactIssue(entry, baselineResults, baselineRaw, mutatedResult, mutatedRaw, baselineRoot, mutatedRoot, mutationTargets, bindingCarrierPaths, protectedAuthorityPaths, executionUniverse) {
     const baselineResult = baselineResults.find((candidate) => candidate.internal_id === entry.check.internal_id);
-    const machineClosing = [
-        ...entry.check.positive_assertions,
-        ...entry.check.negative_assertions,
-    ].some((assertion) => assertion.claims.length > 0);
+    const machineClosing = counterfactualMachineClosing(entry);
     if (!baselineResult || !baselineRaw)
         return machineClosing
             ? "counterfactual_admitted_observation_required"
             : null;
+    const process = counterfactualProcessContext(entry, baselineRaw, mutatedRaw, mutationTargets);
+    if (process.issue)
+        return process.issue;
+    const observationChecks = counterfactualObservationChecks(entry.check, executionUniverse, process.processObserved);
+    const { baselineEntries, mutatedEntries } = await prepareCounterfactualObservationEntries({
+        entry,
+        observationChecks,
+        baselineResults,
+        baselineRaw,
+        mutatedResult,
+        mutatedRaw,
+        baselineRoot,
+        mutatedRoot,
+        protectedAuthorityPaths,
+    });
+    const observationIssue = counterfactualObservationEntryIssue(baselineEntries, mutatedEntries, machineClosing);
+    if (observationIssue)
+        return observationIssue;
+    const closureIssue = counterfactualProcessClosureIdentityIssue(process);
+    if (closureIssue)
+        return closureIssue;
+    const baselineKeys = baselineEntries.map(({ identity }) => identity).sort();
+    const mutatedKeys = mutatedEntries.map(({ identity }) => identity).sort();
+    if (canonicalValueJson(baselineKeys) !== canonicalValueJson(mutatedKeys))
+        return "counterfactual_obligation_universe_changed";
+    const baselineByFact = Object.fromEntries(baselineEntries.map(({ candidate, identity }) => [
+        identity,
+        candidate.observation.value_sha256,
+    ]));
+    const mutatedByFact = Object.fromEntries(mutatedEntries.map(({ candidate, identity }) => [
+        identity,
+        candidate.observation.value_sha256,
+    ]));
+    const factRefs = counterfactualFactRefs(entry, baselineEntries);
+    const expectedFactRefs = factRefs.expected;
+    if (!expectedFactRefs.length)
+        return "counterfactual_expected_fact_observation_missing";
+    const targetLive = entry.control.preserved_assertions.every((key) => mutatedResult.assertion_results.some((assertion) => assertion.key === key && assertion.passed));
+    const carrier = counterfactualCarrierRole(entry, mutationTargets, bindingCarrierPaths, protectedAuthorityPaths, process.processObserved);
+    if (carrier.issue)
+        return carrier.issue;
+    return validateCounterfactualObservationImpact({
+        baseline_by_fact: baselineByFact,
+        mutated_by_fact: mutatedByFact,
+        expected_affected_fact_refs: expectedFactRefs,
+        preserved_fact_refs: factRefs.preserved,
+        allowed_fanout_fact_refs: factRefs.allowedFanout,
+        target_live: targetLive,
+        carrier_role: carrier.role,
+    });
+}
+function counterfactualMachineClosing(entry) {
+    return [
+        ...entry.check.positive_assertions,
+        ...entry.check.negative_assertions,
+    ].some((assertion) => assertion.claims.length > 0);
+}
+function counterfactualProcessContext(entry, baselineRaw, mutatedRaw, mutationTargets) {
     const processObserved = (entry.check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact");
     const processClosure = processObserved
         ? entry.check.process_runtime_closure
         : null;
-    if (processObserved) {
-        if (!processClosure)
-            return "process_runtime_closure_identity_mismatch";
-        const normalizedMutationTargets = mutationTargets.map((target, index) => normalizeRepositoryFile(target, `counterfactual.mutation_targets[${index}]`));
-        if (normalizedMutationTargets.some((target) => !processClosure.production_carrier_files.includes(target)))
-            return "counterfactual_runtime_reachability_unproven";
+    const baselineClosureIdentity = processObserved
+        ? (baselineRaw.host_execution_attestation
+            ?.process_runtime_closure_identity ?? null)
+        : null;
+    const mutatedClosureIdentity = processObserved
+        ? (mutatedRaw.host_execution_attestation
+            ?.process_runtime_closure_identity ?? null)
+        : null;
+    let issue = null;
+    if (processObserved && !processClosure)
+        issue = "process_runtime_closure_identity_mismatch";
+    if (processClosure) {
+        const normalizedTargets = mutationTargets.map((target, index) => normalizeRepositoryFile(target, `counterfactual.mutation_targets[${index}]`));
+        if (normalizedTargets.some((target) => !processClosure.production_carrier_files.includes(target)))
+            issue = "counterfactual_runtime_reachability_unproven";
+        if (baselineClosureIdentity !== null &&
+            mutatedClosureIdentity !== null &&
+            (baselineClosureIdentity !== processClosure.closure_identity ||
+                mutatedClosureIdentity !== processClosure.closure_identity ||
+                baselineClosureIdentity !== mutatedClosureIdentity))
+            issue = "process_runtime_closure_identity_mismatch";
     }
-    const observationChecks = counterfactualObservationChecks(entry.check, executionUniverse, processObserved);
-    const observationSets = await Promise.all(observationChecks.map(async (check) => {
-        const baselineCheckResult = baselineResults.find((candidate) => candidate.internal_id === check.internal_id);
+    return {
+        processObserved,
+        processClosure,
+        baselineClosureIdentity,
+        mutatedClosureIdentity,
+        issue,
+    };
+}
+async function prepareCounterfactualObservationEntries(input) {
+    const observationSets = await Promise.all(input.observationChecks.map(async (check) => {
+        const machineObservationCheck = {
+            ...check,
+            observation_authorities: (check.observation_authorities ?? []).filter((authority) => authority.authority !== "external_confirmation"),
+        };
+        const baselineCheckResult = input.baselineResults.find((candidate) => candidate.internal_id === check.internal_id);
         const [baseline, mutated] = await Promise.all([
             prepareAdmittedObservations({
-                check,
+                check: machineObservationCheck,
                 records: baselineCheckResult?.evidence_records ?? [],
-                snapshot_root: baselineRoot,
-                authority_paths: protectedAuthorityPaths,
-                package_observations: packageObservationsForCheck(check, baselineRaw.package_observations ?? []),
+                snapshot_root: input.baselineRoot,
+                authority_paths: input.protectedAuthorityPaths,
+                package_observations: packageObservationsForCheck(machineObservationCheck, input.baselineRaw.package_observations ?? []),
             }),
             prepareAdmittedObservations({
-                check,
-                records: check.internal_id === entry.check.internal_id
-                    ? mutatedResult.evidence_records
+                check: machineObservationCheck,
+                records: check.internal_id === input.entry.check.internal_id
+                    ? input.mutatedResult.evidence_records
                     : [],
-                snapshot_root: mutatedRoot,
-                authority_paths: protectedAuthorityPaths,
-                package_observations: packageObservationsForCheck(check, mutatedRaw.package_observations ?? []),
+                snapshot_root: input.mutatedRoot,
+                authority_paths: input.protectedAuthorityPaths,
+                package_observations: packageObservationsForCheck(machineObservationCheck, input.mutatedRaw.package_observations ?? []),
             }),
         ]);
         return { check, baseline, mutated };
     }));
-    const baselineEntries = observationSets.flatMap(({ check, baseline }) => baseline.entries.map((candidate) => ({
-        candidate,
-        check,
-        identity: scopedObservationImpactIdentity(check, candidate),
-    })));
-    const mutatedEntries = observationSets.flatMap(({ check, mutated }) => mutated.entries.map((candidate) => ({
-        candidate,
-        check,
-        identity: scopedObservationImpactIdentity(check, candidate),
-    })));
-    if (!baselineEntries.length || !mutatedEntries.length)
+    return {
+        baselineEntries: observationSets.flatMap(({ check, baseline }) => baseline.entries.map((candidate) => ({
+            candidate,
+            check,
+            identity: scopedObservationImpactIdentity(check, candidate),
+        }))),
+        mutatedEntries: observationSets.flatMap(({ check, mutated }) => mutated.entries.map((candidate) => ({
+            candidate,
+            check,
+            identity: scopedObservationImpactIdentity(check, candidate),
+        }))),
+    };
+}
+function counterfactualObservationEntryIssue(baseline, mutated, machineClosing) {
+    if (!baseline.length || !mutated.length)
         return machineClosing
             ? "counterfactual_admitted_observation_required"
             : null;
-    const baselineIssue = baselineEntries.find(({ candidate }) => candidate.reason || !candidate.observation);
+    const baselineIssue = baseline.find(({ candidate }) => candidate.reason || !candidate.observation);
     if (baselineIssue)
         return `counterfactual_baseline_observation_invalid:${baselineIssue.candidate.reason ?? "missing"}`;
-    const mutatedIssue = mutatedEntries.find(({ candidate }) => candidate.reason || !candidate.observation);
-    if (mutatedIssue)
-        return `counterfactual_mutated_observation_invalid:${mutatedIssue.candidate.reason ?? "missing"}`;
-    if (processClosure) {
-        const baselineClosureIdentity = baselineRaw.host_execution_attestation
-            ?.process_runtime_closure_identity ?? null;
-        const mutatedClosureIdentity = mutatedRaw.host_execution_attestation?.process_runtime_closure_identity ??
-            null;
-        if (baselineClosureIdentity !== processClosure.closure_identity ||
-            mutatedClosureIdentity !== processClosure.closure_identity ||
-            baselineClosureIdentity !== mutatedClosureIdentity)
-            return "process_runtime_closure_identity_mismatch";
-    }
-    const baselineKeys = baselineEntries.map(({ identity }) => identity).sort();
-    const mutatedKeys = mutatedEntries.map(({ identity }) => identity).sort();
-    if (canonicalValueJson(baselineKeys) !== canonicalValueJson(mutatedKeys))
-        return "counterfactual_obligation_universe_changed";
-    const baselineByFact = Object.fromEntries(baselineEntries.map(({ candidate, identity }) => [
-        identity,
-        candidate.observation.value_sha256,
-    ]));
-    const mutatedByFact = Object.fromEntries(mutatedEntries.map(({ candidate, identity }) => [
-        identity,
-        candidate.observation.value_sha256,
-    ]));
-    const expectedAssertions = new Set(entry.control.expected_assertion_failures);
-    const preservedAssertions = new Set(entry.control.preserved_assertions);
-    const allowedFanoutAssertions = new Set(entry.control.allowed_fanout_assertions ?? []);
-    const expectedFactRefs = baselineEntries
-        .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
-        expectedAssertions.has(candidate.assertion_key))
-        .map(({ identity }) => identity);
-    if (!expectedFactRefs.length)
-        return "counterfactual_expected_fact_observation_missing";
-    const preservedFactRefs = baselineEntries
-        .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
-        preservedAssertions.has(candidate.assertion_key))
-        .map(({ identity }) => identity);
-    const allowedFanoutFactRefs = baselineEntries
+    const mutatedIssue = mutated.find(({ candidate }) => candidate.reason || !candidate.observation);
+    return mutatedIssue
+        ? `counterfactual_mutated_observation_invalid:${mutatedIssue.candidate.reason ?? "missing"}`
+        : null;
+}
+function counterfactualProcessClosureIdentityIssue(process) {
+    if (!process.processClosure)
+        return null;
+    return process.baselineClosureIdentity !==
+        process.processClosure.closure_identity ||
+        process.mutatedClosureIdentity !==
+            process.processClosure.closure_identity ||
+        process.baselineClosureIdentity !== process.mutatedClosureIdentity
+        ? "process_runtime_closure_identity_mismatch"
+        : null;
+}
+function counterfactualFactRefs(entry, baseline) {
+    const refsFor = (assertions) => baseline
         .filter(({ candidate, check }) => check.internal_id === entry.check.internal_id &&
-        allowedFanoutAssertions.has(candidate.assertion_key))
+        assertions.has(candidate.assertion_key))
         .map(({ identity }) => identity);
-    const targetLive = entry.control.preserved_assertions.every((key) => mutatedResult.assertion_results.some((assertion) => assertion.key === key && assertion.passed));
-    let carrierRole = "product";
-    if (!processObserved) {
-        const carrierRoleConflict = mutationTargets
-            .map((target) => classifyMachineObservationCarrierRoleConflict({
-            carrier_pattern: target,
-            expected_authority_patterns: [
-                ...entry.check.verification_inputs,
-                ...protectedAuthorityPaths,
-            ],
-            evidence_role_patterns: [
-                ...entry.check.expected_output_paths,
-                ...entry.check.artifact_globs,
-            ],
-        }))
-            .find((candidate) => candidate !== null);
-        if (carrierRoleConflict)
-            return `counterfactual_static_carrier_${carrierRoleConflict}_forbidden`;
-        carrierRole = mutationTargets.every((target) => bindingCarrierPaths.some((pattern) => matchesRepoPattern(target, pattern)) &&
-            entry.check.input_paths.some((pattern) => matchesRepoPattern(target, pattern)))
-            ? "product"
-            : "evidence";
-    }
-    return validateCounterfactualObservationImpact({
-        baseline_by_fact: baselineByFact,
-        mutated_by_fact: mutatedByFact,
-        expected_affected_fact_refs: expectedFactRefs,
-        preserved_fact_refs: preservedFactRefs,
-        allowed_fanout_fact_refs: allowedFanoutFactRefs,
-        target_live: targetLive,
-        carrier_role: carrierRole,
-    });
+    return {
+        expected: refsFor(new Set(entry.control.expected_assertion_failures)),
+        preserved: refsFor(new Set(entry.control.preserved_assertions)),
+        allowedFanout: refsFor(new Set(entry.control.allowed_fanout_assertions ?? [])),
+    };
+}
+function counterfactualCarrierRole(entry, mutationTargets, bindingCarrierPaths, protectedAuthorityPaths, processObserved) {
+    if (processObserved)
+        return { role: "product", issue: null };
+    const conflict = mutationTargets
+        .map((target) => classifyMachineObservationCarrierRoleConflict({
+        carrier_pattern: target,
+        expected_authority_patterns: [
+            ...entry.check.verification_inputs,
+            ...protectedAuthorityPaths,
+        ],
+        evidence_role_patterns: [
+            ...entry.check.expected_output_paths,
+            ...entry.check.artifact_globs,
+        ],
+    }))
+        .find((candidate) => candidate !== null);
+    if (conflict)
+        return {
+            role: "evidence",
+            issue: `counterfactual_static_carrier_${conflict}_forbidden`,
+        };
+    const product = mutationTargets.every((target) => bindingCarrierPaths.some((pattern) => matchesRepoPattern(target, pattern)) &&
+        entry.check.input_paths.some((pattern) => matchesRepoPattern(target, pattern)));
+    return { role: product ? "product" : "evidence", issue: null };
 }
 function counterfactualObservationChecks(check, executionUniverse, processObserved) {
     if (!processObserved)

package/dist/lib/long-task-execution-observation.d.ts

@@ -1,4 +1,5 @@
 import type { CheckRunnerExecutionContextV2, CompiledCheckV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import { type CounterfactualSandboxV2 } from "./long-task-counterfactual-sandbox.js";
 export interface PreparedExecutionObservationGroupV2 {
     readonly execution_root: string;
     readonly runner_context: CheckRunnerExecutionContextV2;
@@ -22,3 +23,9 @@ export declare function prepareExecutionObservationGroup(input: {
     workspace_manifest: WorkspaceManifestV2;
     protected_authority_paths?: readonly string[];
 }): Promise<PreparedExecutionObservationGroupV2>;
+export declare function prepareCounterfactualExecutionObservationGroup(input: {
+    checks: readonly CompiledCheckV2[];
+    sandbox: CounterfactualSandboxV2;
+    workspace_manifest: WorkspaceManifestV2;
+    protected_authority_paths?: readonly string[];
+}): Promise<PreparedExecutionObservationGroupV2>;

package/dist/lib/long-task-execution-observation.js

@@ -2,6 +2,7 @@ import { chmod, copyFile, mkdir, mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createJsonPointerExactBudget } from "./long-task-json-pointer-observation.js";
+import { counterfactualSandboxProcessExecution, } from "./long-task-counterfactual-sandbox.js";
 import { matchesRepoPattern } from "./long-task-paths.js";
 import { StaticObservationFreezeError, createObservationInputFreezeBudget, freezeObservationInputFile, freezeStaticObservationCarrier, } from "./long-task-static-observation-freeze.js";
 const PROCESS_INPUT_FREEZE_LIMITS = Object.freeze({
@@ -39,6 +40,17 @@ export async function prepareExecutionObservationGroup(input) {
         process_input_budget: createProcessInputFreezeBudget(),
     });
 }
+export async function prepareCounterfactualExecutionObservationGroup(input) {
+    const processExecution = counterfactualSandboxProcessExecution(input.sandbox);
+    return prepareExecutionObservationGroupWithBudget({
+        checks: input.checks,
+        snapshot_root: processExecution?.root ?? input.sandbox.root,
+        workspace_manifest: input.workspace_manifest,
+        protected_authority_paths: input.protected_authority_paths,
+        process_input_budget: createProcessInputFreezeBudget(),
+        direct_process_execution_root: processExecution !== null,
+    });
+}
 async function prepareExecutionObservationGroupWithBudget(input) {
     if (!input.checks.length)
         throw new Error("execution_observation_check_group_required");
@@ -50,13 +62,16 @@ async function prepareExecutionObservationGroupWithBudget(input) {
     const exactBudget = createJsonPointerExactBudget();
     const processInputBudget = input.process_input_budget;
     const processExecution = states.some((state) => state.authority.authority === "package_process_json_exact");
-    const executionRoot = processExecution
+    const directProcessExecution = processExecution && input.direct_process_execution_root === true;
+    const executionRoot = processExecution && !directProcessExecution
         ? await mkdtemp(path.join(os.tmpdir(), "ty-context-process-snapshot-"))
         : input.snapshot_root;
-    if (processExecution)
+    if (processExecution && !directProcessExecution)
         await mkdir(path.resolve(executionRoot, input.checks[0].runner.resolved_cwd), { recursive: true });
     for (const group of groups) {
         if ((input.protected_authority_paths ?? []).some((pattern) => matchesRepoPattern(group.artifact_path, pattern))) {
+            if (directProcessExecution)
+                await rm(path.resolve(executionRoot, ...group.artifact_path.split("/")), { recursive: true, force: true });
             for (const state of group.authority_states)
                 recordAuthorityFailure(state, "observation_expected_authority_forbidden");
             continue;
@@ -65,7 +80,7 @@ async function prepareExecutionObservationGroupWithBudget(input) {
             const includesStaticAuthority = group.authority_states.some((state) => state.authority.authority === "package_static_json_exact");
             const includesProcessAuthority = group.authority_states.some((state) => state.authority.authority === "package_process_json_exact");
             let sourceIdentity = null;
-            if (processExecution) {
+            if (processExecution && !directProcessExecution) {
                 const sourceFrozen = await freezeObservationInputFile({
                     snapshot_root: input.snapshot_root,
                     workspace_manifest: input.workspace_manifest,
@@ -109,6 +124,8 @@ async function prepareExecutionObservationGroupWithBudget(input) {
                 throw new Error("process_observation_input_snapshot_copy_mismatch");
         }
         catch (error) {
+            if (directProcessExecution)
+                await rm(path.resolve(executionRoot, ...group.artifact_path.split("/")), { recursive: true, force: true });
             const reason = observationFailureReason(error);
             for (const state of group.authority_states)
                 recordAuthorityFailure(state, reason);
@@ -133,7 +150,7 @@ async function prepareExecutionObservationGroupWithBudget(input) {
         disposed = true;
         for (const group of groups)
             group.frozen?.dispose();
-        if (processExecution)
+        if (processExecution && !directProcessExecution)
             await rm(executionRoot, { recursive: true, force: true });
     };
     return {

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

@@ -0,0 +1,4 @@
+import type { DeliveryAssertionV2, DeliveryContractV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
+import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
+export declare function resolveExpectedAuthority(contract: DeliveryContractV2, outcomeKey: string | null, assertion: DeliveryAssertionV2, manifest: SemanticFactManifestV1, expectations: SemanticFactExpectationV2[]): string;
+export declare function claimAuthorityStatement(contract: DeliveryContractV2, outcomeKey: string | null, localClaim: string): string;