project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/long-task-evidence-capability-runtime.js

@@ -30,6 +30,8 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
             return validateDesignConformance(check, record, artifactHashes);
         case "design_method":
             return validateDesignMethod(check, record, artifactHashes);
+        case "design_symbolic_certificate":
+            return validateDesignSymbolicCertificate(check, record, artifactHashes);
         case "semantic_fact":
             return validateSemanticFactEvidence(check, record, artifactHashes);
         case "target_runtime":
@@ -39,6 +41,11 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
     }
 }
 function validateDesignMethod(check, record, artifactHashes) {
+    return "fact_model" in record
+        ? validateSymbolicDesignMethod(check, record, artifactHashes)
+        : validateGroundDesignMethod(check, record, artifactHashes);
+}
+function validateGroundDesignMethod(check, record, artifactHashes) {
     const target = (check.design_conformance_targets ?? []).find((item) => item.key === record.design_target_ref &&
         item.verification_method_bindings.some((binding) => binding.assertion_ref === record.assertion_key &&
             binding.method === record.method));
@@ -49,6 +56,9 @@ function validateDesignMethod(check, record, artifactHashes) {
         return "target_mismatch";
     const binding = target.verification_method_bindings.find((item) => item.assertion_ref === record.assertion_key &&
         item.method === record.method);
+    return validateGroundDesignCells(target, binding, record, artifactHashes);
+}
+function validateGroundDesignCells(target, binding, record, artifactHashes) {
     if (!same([...record.cells.map((item) => item.condition_key)].sort(), [...target.condition_keys].sort()))
         return "design_method_conditions_mismatch";
     const expected = new Map(binding.evidence_artifacts.map((item) => [
@@ -62,6 +72,9 @@ function validateDesignMethod(check, record, artifactHashes) {
     ]));
     if (record.cells.length !== expected.size)
         return "design_method_cell_count_mismatch";
+    return validateGroundCellSet(record, expected, artifactHashes);
+}
+function validateGroundCellSet(record, expected, artifactHashes) {
     for (const cell of record.cells) {
         const expectedCell = expected.get(cell.condition_key);
         if (expectedCell?.artifact_path !== cell.artifact_path ||
@@ -75,68 +88,262 @@ function validateDesignMethod(check, record, artifactHashes) {
             return "design_method_artifact_missing";
         if (!artifactHashes[cell.observation_artifact_path])
             return "design_method_observation_artifact_missing";
-        const expectations = new Map((expectedCell?.fact_expectations ?? []).map((item) => [
-            item.fact_ref,
-            item,
-        ]));
-        const actualIdentities = new Set();
-        const comparisonIdentities = new Set();
-        for (const result of cell.fact_results) {
-            const expectation = expectations.get(result.fact_ref);
-            if (!expectation)
-                return "design_method_fact_expectation_missing";
-            if (result.subject_ref !== expectation.subject_ref ||
-                result.variation_ref !== expectation.variation_ref ||
-                result.property_ref !== expectation.property_ref ||
-                result.actual_observation.sensitivity !==
-                    expectation.observation_sensitivity)
-                return "design_method_fact_identity_mismatch";
-            if ((result.actual_observation.sensitivity === "plain" &&
-                result.actual_observation.redaction !== null) ||
-                (result.actual_observation.sensitivity === "protected" &&
-                    result.actual_observation.redaction === null))
-                return "design_method_observation_protection_mismatch";
-            if (canonicalJson(result.expected) !== canonicalJson(expectation.expected))
-                return "design_method_expected_value_mismatch";
-            if (result.comparison.comparator !== expectation.comparison.comparator ||
-                result.comparison.mode !== expectation.comparison.mode ||
-                canonicalJson(result.comparison.parameters) !==
-                    canonicalJson(expectation.comparison.parameters) ||
-                canonicalJson(result.comparison.tolerance) !==
-                    canonicalJson(expectation.comparison.tolerance) ||
-                canonicalJson(result.comparison.mask) !==
-                    canonicalJson(expectation.comparison.mask))
-                return "design_method_comparison_authority_mismatch";
-            if (canonicalJson(result.oracle) !== canonicalJson(expectation.oracle) ||
-                canonicalJson(result.environment) !==
-                    canonicalJson(expectation.environment))
-                return "design_method_oracle_environment_mismatch";
-            if (result.actual_observation.artifact_path !==
-                cell.observation_artifact_path ||
-                result.actual_observation.artifact_sha256 !==
-                    artifactHashes[cell.observation_artifact_path])
-                return "design_method_actual_observation_mismatch";
-            if (result.actual_environment.artifact_path !==
-                cell.observation_artifact_path ||
-                result.actual_environment.artifact_sha256 !==
-                    artifactHashes[cell.observation_artifact_path] ||
-                result.actual_environment.value_sha256 !==
-                    expectation.environment.definition.sha256)
-                return "design_method_actual_environment_mismatch";
-            if (result.comparison.artifact_path !== cell.artifact_path ||
-                result.comparison.artifact_sha256 !== artifactHashes[cell.artifact_path])
-                return "design_method_comparison_artifact_mismatch";
-            const actualIdentity = `${result.actual_observation.artifact_path}\0${canonicalJson(result.actual_observation.locator)}`;
-            if (actualIdentities.has(actualIdentity))
-                return "design_method_actual_observation_reused";
-            actualIdentities.add(actualIdentity);
-            const comparisonIdentity = `${result.comparison.artifact_path}\0${canonicalJson(result.comparison.locator)}`;
-            if (comparisonIdentities.has(comparisonIdentity))
-                return "design_method_comparison_result_reused";
-            comparisonIdentities.add(comparisonIdentity);
-            if (result.verdict !== "passed" || result.comparison.passed !== true)
-                return "design_method_fact_failed";
-        }
+        const resultIssue = validateGroundCellResults(cell, expectedCell, artifactHashes);
+        if (resultIssue)
+            return resultIssue;
+    }
+    return null;
+}
+function validateGroundCellResults(cell, expectedCell, artifactHashes) {
+    const expectations = new Map(expectedCell.fact_expectations.map((item) => [item.fact_ref, item]));
+    const actualIdentities = new Set();
+    const comparisonIdentities = new Set();
+    for (const result of cell.fact_results) {
+        const expectation = expectations.get(result.fact_ref);
+        if (!expectation)
+            return "design_method_fact_expectation_missing";
+        const identityIssue = validateGroundFactIdentity(result, expectation);
+        if (identityIssue)
+            return identityIssue;
+        const authorityIssue = validateGroundFactAuthority(result, expectation);
+        if (authorityIssue)
+            return authorityIssue;
+        const artifactIssue = validateGroundFactArtifacts(result, expectation, cell, artifactHashes);
+        if (artifactIssue)
+            return artifactIssue;
+        const actualIdentity = `${result.actual_observation.artifact_path}\0${canonicalJson(result.actual_observation.locator)}`;
+        if (actualIdentities.has(actualIdentity))
+            return "design_method_actual_observation_reused";
+        actualIdentities.add(actualIdentity);
+        const comparisonIdentity = `${result.comparison.artifact_path}\0${canonicalJson(result.comparison.locator)}`;
+        if (comparisonIdentities.has(comparisonIdentity))
+            return "design_method_comparison_result_reused";
+        comparisonIdentities.add(comparisonIdentity);
+        if (result.verdict !== "passed" || result.comparison.passed !== true)
+            return "design_method_fact_failed";
+    }
+    return null;
+}
+function validateGroundFactIdentity(result, expectation) {
+    if (result.subject_ref !== expectation.subject_ref ||
+        result.variation_ref !== expectation.variation_ref ||
+        result.property_ref !== expectation.property_ref ||
+        result.actual_observation.sensitivity !==
+            expectation.observation_sensitivity)
+        return "design_method_fact_identity_mismatch";
+    if ((result.actual_observation.sensitivity === "plain" &&
+        result.actual_observation.redaction !== null) ||
+        (result.actual_observation.sensitivity === "protected" &&
+            result.actual_observation.redaction === null))
+        return "design_method_observation_protection_mismatch";
+    return canonicalJson(result.expected) === canonicalJson(expectation.expected)
+        ? null
+        : "design_method_expected_value_mismatch";
+}
+function validateGroundFactAuthority(result, expectation) {
+    if (result.comparison.comparator !== expectation.comparison.comparator ||
+        result.comparison.mode !== expectation.comparison.mode ||
+        canonicalJson(result.comparison.parameters) !==
+            canonicalJson(expectation.comparison.parameters) ||
+        canonicalJson(result.comparison.tolerance) !==
+            canonicalJson(expectation.comparison.tolerance) ||
+        canonicalJson(result.comparison.mask) !==
+            canonicalJson(expectation.comparison.mask))
+        return "design_method_comparison_authority_mismatch";
+    return canonicalJson(result.oracle) === canonicalJson(expectation.oracle) &&
+        canonicalJson(result.environment) === canonicalJson(expectation.environment)
+        ? null
+        : "design_method_oracle_environment_mismatch";
+}
+function validateGroundFactArtifacts(result, expectation, cell, artifactHashes) {
+    if (result.actual_observation.artifact_path !==
+        cell.observation_artifact_path ||
+        result.actual_observation.artifact_sha256 !==
+            artifactHashes[cell.observation_artifact_path])
+        return "design_method_actual_observation_mismatch";
+    if (result.actual_environment.artifact_path !==
+        cell.observation_artifact_path ||
+        result.actual_environment.artifact_sha256 !==
+            artifactHashes[cell.observation_artifact_path] ||
+        result.actual_environment.value_sha256 !==
+            expectation.environment.definition.sha256)
+        return "design_method_actual_environment_mismatch";
+    return result.comparison.artifact_path === cell.artifact_path &&
+        result.comparison.artifact_sha256 === artifactHashes[cell.artifact_path]
+        ? null
+        : "design_method_comparison_artifact_mismatch";
+}
+function validateSymbolicDesignMethod(check, record, artifactHashes) {
+    const target = (check.design_conformance_targets ?? []).find((item) => item.key === record.design_target_ref &&
+        item.fact_model === "symbolic_rules_v2" &&
+        (item.symbolic_method_bindings ?? []).some((binding) => binding.assertion_ref === record.assertion_key &&
+            binding.method === record.method));
+    if (!target)
+        return "design_symbolic_method_binding_unknown";
+    if (target.target_ref !== record.target_ref ||
+        target.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    const binding = target.symbolic_method_bindings.find((item) => item.assertion_ref === record.assertion_key &&
+        item.method === record.method);
+    if (binding.artifact_path !== record.artifact_path ||
+        binding.observation_path !== record.observation_artifact_path)
+        return "design_symbolic_method_artifact_path_mismatch";
+    if (!artifactHashes[record.artifact_path])
+        return "design_symbolic_method_artifact_missing";
+    if (!artifactHashes[record.observation_artifact_path])
+        return "design_symbolic_method_observation_artifact_missing";
+    const expectedRefs = binding.rule_expectations
+        .map((item) => item.obligation_ref)
+        .sort();
+    const actualRefs = record.rule_results
+        .map((item) => item.obligation_ref)
+        .sort();
+    if (new Set(actualRefs).size !== actualRefs.length ||
+        !same(actualRefs, expectedRefs))
+        return "design_symbolic_method_obligations_mismatch";
+    return validateSymbolicRuleResults(binding, record, artifactHashes);
+}
+function validateSymbolicRuleResults(binding, record, artifactHashes) {
+    const expectations = new Map(binding.rule_expectations.map((item) => [item.obligation_ref, item]));
+    const actualIdentities = new Set();
+    const comparisonIdentities = new Set();
+    for (const result of record.rule_results) {
+        const expectation = expectations.get(result.obligation_ref);
+        if (!expectation)
+            return "design_symbolic_method_expectation_missing";
+        const identityIssue = validateSymbolicResultIdentity(result, expectation);
+        if (identityIssue)
+            return identityIssue;
+        const authorityIssue = validateSymbolicResultAuthority(result, expectation);
+        if (authorityIssue)
+            return authorityIssue;
+        const artifactIssue = validateSymbolicResultArtifacts(result, expectation, record, artifactHashes);
+        if (artifactIssue)
+            return artifactIssue;
+        const actualIdentity = `${result.actual_observation.artifact_path}\0${canonicalJson(result.actual_observation.locator)}`;
+        if (actualIdentities.has(actualIdentity))
+            return "design_symbolic_method_actual_observation_reused";
+        actualIdentities.add(actualIdentity);
+        const comparisonIdentity = `${result.comparison.artifact_path}\0${canonicalJson(result.comparison.locator)}`;
+        if (comparisonIdentities.has(comparisonIdentity))
+            return "design_symbolic_method_comparison_result_reused";
+        comparisonIdentities.add(comparisonIdentity);
+        if (result.verdict !== "passed" || result.comparison.passed !== true)
+            return "design_symbolic_method_obligation_failed";
+    }
+    return null;
+}
+function validateSymbolicResultIdentity(result, expectation) {
+    if (result.fact_rule_ref !== expectation.fact_rule_ref ||
+        result.region_sha256 !== expectation.region_sha256 ||
+        result.subject_or_relation_ref !== expectation.subject_or_relation_ref ||
+        result.property_ref !== expectation.property_ref ||
+        result.population_ref !== expectation.population_ref ||
+        canonicalJson(result.quantifier) !==
+            canonicalJson(expectation.quantifier) ||
+        result.observation_sensitivity !== expectation.observation_sensitivity)
+        return "design_symbolic_method_identity_mismatch";
+    if (result.actual_observation.sensitivity !==
+        expectation.observation_sensitivity ||
+        (result.actual_observation.sensitivity === "plain" &&
+            result.actual_observation.redaction !== null) ||
+        (result.actual_observation.sensitivity === "protected" &&
+            result.actual_observation.redaction === null))
+        return "design_symbolic_method_observation_protection_mismatch";
+    return canonicalJson(result.expected) === canonicalJson(expectation.expected)
+        ? null
+        : "design_symbolic_method_expected_value_mismatch";
+}
+function validateSymbolicResultAuthority(result, expectation) {
+    if (result.proof_surface !== expectation.proof_surface ||
+        result.observation_boundary !== expectation.observation_boundary ||
+        result.protected_value_policy !== expectation.protected_value_policy ||
+        result.completion_effect !== expectation.completion_effect)
+        return "design_symbolic_method_proof_denotation_mismatch";
+    if (result.comparison.comparator !== expectation.comparison.comparator ||
+        result.comparison.mode !== expectation.comparison.mode ||
+        canonicalJson(result.comparison.parameters) !==
+            canonicalJson(expectation.comparison.parameters) ||
+        canonicalJson(result.comparison.tolerance) !==
+            canonicalJson(expectation.comparison.tolerance) ||
+        canonicalJson(result.comparison.mask) !==
+            canonicalJson(expectation.comparison.mask))
+        return "design_symbolic_method_comparison_authority_mismatch";
+    return canonicalJson(result.oracle) === canonicalJson(expectation.oracle) &&
+        canonicalJson(result.environment) === canonicalJson(expectation.environment)
+        ? null
+        : "design_symbolic_method_oracle_environment_mismatch";
+}
+function validateSymbolicResultArtifacts(result, expectation, record, artifactHashes) {
+    if (result.actual_observation.artifact_path !==
+        record.observation_artifact_path ||
+        result.actual_observation.artifact_sha256 !==
+            artifactHashes[record.observation_artifact_path])
+        return "design_symbolic_method_actual_observation_mismatch";
+    if (result.actual_environment.artifact_path !==
+        record.observation_artifact_path ||
+        result.actual_environment.artifact_sha256 !==
+            artifactHashes[record.observation_artifact_path] ||
+        result.actual_environment.value_sha256 !==
+            expectation.environment.definition.sha256)
+        return "design_symbolic_method_actual_environment_mismatch";
+    return result.comparison.artifact_path === record.artifact_path &&
+        result.comparison.artifact_sha256 === artifactHashes[record.artifact_path]
+        ? null
+        : "design_symbolic_method_comparison_artifact_mismatch";
+}
+function validateDesignSymbolicCertificate(check, record, artifactHashes) {
+    const target = (check.design_conformance_targets ?? []).find((item) => item.key === record.design_target_ref &&
+        item.fact_model === "symbolic_rules_v2" &&
+        item.symbolic_certificate_binding?.assertion_ref === record.assertion_key);
+    if (!target)
+        return "design_symbolic_certificate_binding_unknown";
+    if (target.target_ref !== record.target_ref ||
+        target.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    const binding = target.symbolic_certificate_binding;
+    if (record.artifact_path !== binding.artifact_path)
+        return "design_symbolic_certificate_artifact_path_mismatch";
+    if (artifactHashes[record.artifact_path] !== record.artifact_sha256)
+        return "design_symbolic_certificate_artifact_hash_mismatch";
+    if (canonicalJson(record.metrics) !== canonicalJson(binding.metrics))
+        return "design_symbolic_certificate_metrics_mismatch";
+    const expectedRefs = binding.expectations
+        .map((item) => item.certificate_ref)
+        .sort();
+    const actualRefs = record.certificate_results
+        .map((item) => item.certificate_ref)
+        .sort();
+    if (new Set(actualRefs).size !== actualRefs.length ||
+        !same(actualRefs, expectedRefs))
+        return "design_symbolic_certificate_results_mismatch";
+    const expectations = new Map(binding.expectations.map((item) => [item.certificate_ref, item]));
+    for (const result of record.certificate_results) {
+        const expectation = expectations.get(result.certificate_ref);
+        if (!expectation)
+            return "design_symbolic_certificate_expectation_missing";
+        if (canonicalJson({
+            certificate_ref: result.certificate_ref,
+            fact_rule_refs: result.fact_rule_refs,
+            omitted_axis_refs: result.omitted_axis_refs,
+            dependency_edge_refs: result.dependency_edge_refs,
+            canonical_rule_dag_sha256: result.canonical_rule_dag_sha256,
+            ...(result.source_noninterference_proof_sha256 === undefined
+                ? {}
+                : {
+                    source_noninterference_proof_sha256: result.source_noninterference_proof_sha256,
+                }),
+            ...(result.production_noninterference_proof_sha256 === undefined
+                ? {}
+                : {
+                    production_noninterference_proof_sha256: result.production_noninterference_proof_sha256,
+                }),
+        }) !== canonicalJson(expectation))
+            return "design_symbolic_certificate_denotation_mismatch";
+        if (result.recomputed !== true)
+            return "design_symbolic_certificate_not_recomputed";
+        if (result.verdict !== "passed")
+            return "design_symbolic_certificate_failed";
     }
     return null;
 }
@@ -171,7 +378,8 @@ function validateDesignConformance(check, record, artifactHashes) {
 }
 function designTargetUsesAssertion(target, assertionKey) {
     return (target.conformance_assertion_ref === assertionKey ||
-        target.verification_method_bindings.some((item) => item.assertion_ref === assertionKey));
+        target.verification_method_bindings.some((item) => item.assertion_ref === assertionKey) ||
+        (target.symbolic_method_bindings ?? []).some((item) => item.assertion_ref === assertionKey));
 }
 function validateInteractionTrace(check, record) {
     if (record.target_ref !== check.execution_target.target_ref)

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

@@ -77,7 +77,7 @@ export interface TargetRuntimeEvidenceV2 extends EvidenceRecordBaseV2 {
     session_id: string;
     cold_start: boolean;
 }
-export interface DesignMethodEvidenceV2 extends EvidenceRecordBaseV2 {
+export interface DesignGroundMethodEvidenceV2 extends EvidenceRecordBaseV2 {
     capability: "design_method";
     design_target_ref: string;
     target_ref: string;
@@ -140,12 +140,80 @@ export interface DesignFactResultV2 {
         definition: DesignResourceLocatedDigestV1;
     };
 }
+export interface DesignSymbolicMethodEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "design_method";
+    fact_model: "symbolic_rules_v2";
+    design_target_ref: string;
+    target_ref: string;
+    method: DesignResourceVerificationMethod;
+    artifact_path: string;
+    observation_artifact_path: string;
+    rule_results: DesignSymbolicRuleResultV2[];
+}
+export interface DesignSymbolicRuleResultV2 {
+    obligation_ref: string;
+    fact_rule_ref: string;
+    region_sha256: string;
+    subject_or_relation_ref: string;
+    property_ref: string;
+    population_ref: string | null;
+    quantifier: {
+        kind: "one" | "all" | "any" | "none" | "exactly" | "at_least" | "at_most" | "range";
+        minimum: number | null;
+        maximum: number | null;
+    };
+    actual_observation: DesignFactResultV2["actual_observation"];
+    actual_environment: DesignFactResultV2["actual_environment"];
+    observation_sensitivity: "plain" | "protected";
+    expected: DesignResourceLocatedDigestV1;
+    proof_surface: string;
+    observation_boundary: string;
+    comparison: DesignFactResultV2["comparison"];
+    verdict: "passed" | "failed";
+    oracle: DesignFactResultV2["oracle"];
+    environment: DesignFactResultV2["environment"];
+    protected_value_policy: string;
+    completion_effect: string;
+}
+export type DesignMethodEvidenceV2 = DesignGroundMethodEvidenceV2 | DesignSymbolicMethodEvidenceV2;
+export interface DesignSymbolicCertificateEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "design_symbolic_certificate";
+    design_target_ref: string;
+    target_ref: string;
+    artifact_path: string;
+    artifact_sha256: string;
+    metrics: {
+        semantic_obligations: number;
+        certificate_obligations: number;
+        certificate_covered_omitted_axes: number;
+        certificate_covered_dependency_edges: number;
+        canonical_dag_nodes: number;
+        canonical_partition_edges: number;
+        canonical_bytes: number;
+        theoretical_ground_cardinality: string;
+    };
+    certificate_results: Array<{
+        certificate_ref: string;
+        fact_rule_refs: string[];
+        omitted_axis_refs: string[];
+        dependency_edge_refs: string[];
+        canonical_rule_dag_sha256: string;
+        source_noninterference_proof_sha256?: string;
+        production_noninterference_proof_sha256?: string;
+        recomputed: true;
+        verdict: "passed" | "failed";
+    }>;
+}
 export interface SemanticFactEvidenceV2 extends EvidenceRecordBaseV2 {
     capability: "semantic_fact";
     manifest_ref: string;
     manifest_sha256: string;
     outcome_ref: string;
     target_ref: string;
+    fact_key?: string;
+    fact_revision_digest?: string;
+    obligation_key?: string;
+    obligation_revision_digest?: string;
     fact_ref: string;
     proof_ref: string;
     method: string;
@@ -204,5 +272,5 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
 export {};

package/dist/lib/long-task-evidence-v2.d.ts

@@ -1,5 +1,5 @@
 import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, CompiledOutcomeV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 export declare function evaluateCheckEvidence(check: CompiledCheckV2, raw: RawCommandExecutionV2, snapshotRoot: string, outcome?: CompiledOutcomeV2): Promise<CheckExecutionResultV2>;
-export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2): Promise<LongTaskFindingV2[]>;
+export declare function evaluateOutcomeCounterfactuals(outcome: CompiledOutcomeV2, snapshotRoot: string, manifest?: WorkspaceManifestV2, protectedAuthorityPaths?: readonly string[]): Promise<LongTaskFindingV2[]>;
 export declare function evaluateGlobalCounterfactuals(compiled: CompiledDeliveryContractV2, snapshotRoot: string, selectedCheckKeys?: ReadonlySet<string>, manifest?: WorkspaceManifestV2): Promise<LongTaskFindingV2[]>;
 export declare function isValidCounterfactualCheckResult(result: CheckExecutionResultV2, expectedAssertionFailures: string[]): boolean;

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

@@ -93,7 +93,7 @@ function collectExecutionFindings(check, raw, outcome, artifacts, assertionResul
             result.passed && capabilityEvaluation.complete[result.key] === true;
     return findings;
 }
-export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest) {
+export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest, protectedAuthorityPaths = []) {
     return evaluateCounterfactualSet(outcome.acceptance.counterfactual_controls.map((control) => ({
         control,
         check: outcome.acceptance.checks.find((item) => item.key === control.check_key),
@@ -101,7 +101,7 @@ export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, mani
         findingOutcomeKey: outcome.key,
         owningOutcome: outcome,
         bindingRef: `${outcome.key}.${control.binding_key}`,
-    })), snapshotRoot, manifest);
+    })), snapshotRoot, manifest, protectedAuthorityPaths);
 }
 export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, selectedCheckKeys, manifest) {
     return evaluateCounterfactualSet((compiled.global.acceptance.counterfactual_controls ?? [])
@@ -115,14 +115,14 @@ export async function evaluateGlobalCounterfactuals(compiled, snapshotRoot, sele
             owningOutcome: compiled.outcomes.find((outcome) => outcome.key === outcomeKey),
             bindingRef: control.binding_ref,
         };
-    }), snapshotRoot, manifest);
+    }), snapshotRoot, manifest, compiled.context_snapshot.files);
 }
-async function evaluateCounterfactualSet(entries, snapshotRoot, manifest) {
+async function evaluateCounterfactualSet(entries, snapshotRoot, manifest, protectedAuthorityPaths = []) {
     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);
+        const sandbox = await createCounterfactualSandbox(snapshotRoot, check, control, owningBinding?.carrier_paths ?? [], manifest, protectedAuthorityPaths);
         const root = sandbox.root;
         try {
             const mutationTargets = control.mutation.type === "remove_paths"

package/dist/lib/long-task-hook-install.d.ts

@@ -1,6 +1,23 @@
+import { type Stats } from "node:fs";
 import type { SyncReport } from "./sync-engine.js";
-export declare function installLongTaskHooks(projectRoot: string, report: SyncReport): Promise<void>;
-export declare function uninstallLongTaskHooks(projectRoot: string, report: SyncReport): Promise<void>;
+export declare const LONG_TASK_HOOK_TRUST_REVIEW_NOTICE = "Codex Hook review required: open /hooks and trust the current Tiny Context project Hook before relying on PreToolUse, SubagentStart, SessionStart or Stop behavior. Tiny Context cannot observe or persist Codex Hook trust.";
+export interface LongTaskHookFileOperations {
+    lstat(target: string): Promise<Stats>;
+    readFile(target: string, encoding: "utf8"): Promise<string>;
+    mkdir(target: string, options: {
+        recursive: true;
+    }): Promise<unknown>;
+    writeFile(target: string, content: string, options: {
+        flag: "wx";
+    }): Promise<void>;
+    rename(source: string, destination: string): Promise<void>;
+    rm(target: string, options: {
+        force: true;
+    }): Promise<void>;
+    randomId(): string;
+}
+export declare function installLongTaskHooks(projectRoot: string, report: SyncReport, fileOperations?: Partial<LongTaskHookFileOperations>): Promise<void>;
+export declare function uninstallLongTaskHooks(projectRoot: string, report: SyncReport, fileOperations?: Partial<LongTaskHookFileOperations>): Promise<void>;
 export declare function packageOwnedCommand(entry: string): string;
 export declare function removeManagedHookEntries(groups: unknown, currentPackageCommand?: string): {
     groups: unknown[];