project-tiny-context-harness 0.8.17 → 0.11.0

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

@@ -12,6 +12,9 @@ function decodeRecord(value, index) {
     const assertionKey = key(row.assertion_key, `${label}.assertion_key`);
     const capability = nonEmpty(row.capability, `${label}.capability`);
     const base = { assertion_key: assertionKey };
+    const completeDelivery = decodeCompleteDeliveryEvidenceRecord(row, label, base, capability);
+    if (completeDelivery)
+        return completeDelivery;
     switch (capability) {
         case "interaction_trace":
             exact(row, label, [
@@ -196,6 +199,94 @@ function decodeRecord(value, index) {
             throw invalidRecord(`${label}.capability_unsupported:${capability}`);
     }
 }
+function decodeCompleteDeliveryEvidenceRecord(row, label, base, capability) {
+    switch (capability) {
+        case "actual_provenance":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "source_kind",
+                "source_ref",
+                "actual_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                source_kind: literal(row.source_kind, ["product_runtime", "observer_runtime", "durable_store"], `${label}.source_kind`),
+                source_ref: nonEmpty(row.source_ref, `${label}.source_ref`),
+                actual_sha256: sha(row.actual_sha256, `${label}.actual_sha256`),
+            };
+        case "distinct_identity":
+            return decodeDistinctIdentityEvidence(row, label, base);
+        case "data_state":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "state_ref",
+                "state_sha256",
+                "read_session_id",
+            ]);
+            return {
+                ...base,
+                capability,
+                state_ref: nonEmpty(row.state_ref, `${label}.state_ref`),
+                state_sha256: sha(row.state_sha256, `${label}.state_sha256`),
+                read_session_id: nonEmpty(row.read_session_id, `${label}.read_session_id`),
+            };
+        case "population_coverage":
+            return decodePopulationCoverageEvidence(row, label, base);
+        case "recovery":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "failure_session_id",
+                "recovery_session_id",
+                "recovered_state_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                failure_session_id: nonEmpty(row.failure_session_id, `${label}.failure_session_id`),
+                recovery_session_id: nonEmpty(row.recovery_session_id, `${label}.recovery_session_id`),
+                recovered_state_sha256: sha(row.recovered_state_sha256, `${label}.recovered_state_sha256`),
+            };
+        default:
+            return null;
+    }
+}
+function decodeDistinctIdentityEvidence(row, label, base) {
+    exact(row, label, ["assertion_key", "capability", "identities"]);
+    const identities = array(row.identities, `${label}.identities`).map((item, identityIndex) => {
+        const identityLabel = `${label}.identities[${identityIndex}]`;
+        const identity = record(item, identityLabel);
+        exact(identity, identityLabel, ["identity_ref", "data_state_sha256"]);
+        return {
+            identity_ref: nonEmpty(identity.identity_ref, `${identityLabel}.identity_ref`),
+            data_state_sha256: sha(identity.data_state_sha256, `${identityLabel}.data_state_sha256`),
+        };
+    });
+    return { ...base, capability: "distinct_identity", identities };
+}
+function decodePopulationCoverageEvidence(row, label, base) {
+    exact(row, label, [
+        "assertion_key",
+        "capability",
+        "universe_sha256",
+        "observed_sha256",
+        "excluded_sha256",
+        "set_equality",
+    ]);
+    if (row.set_equality !== true)
+        throw invalidRecord(`${label}.set_equality`);
+    return {
+        ...base,
+        capability: "population_coverage",
+        universe_sha256: sha(row.universe_sha256, `${label}.universe_sha256`),
+        observed_sha256: sha(row.observed_sha256, `${label}.observed_sha256`),
+        excluded_sha256: sha(row.excluded_sha256, `${label}.excluded_sha256`),
+        set_equality: true,
+    };
+}
 function decodeGroundDesignMethodEvidence(row, label, base) {
     exact(row, label, [
         "assertion_key",

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

@@ -10,28 +10,28 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes, adm
         case "interaction_trace":
             return validateInteractionTrace(check, record, hostAttestation);
         case "state_delta":
-            if (record.before_sha256 === record.after_sha256)
-                return "state_unchanged";
-            if (!record.changed_fields.length)
-                return "changed_fields_empty";
-            return null;
+            return validateStateDelta(record);
         case "cross_surface_consistency":
             return validateCrossSurfaceConsistency(check, record);
         case "durable_readback":
-            if (record.write_session_id === record.read_session_id)
-                return "independent_session_required";
-            if (record.written_sha256 !== record.read_sha256)
-                return "readback_mismatch";
-            return null;
+            return validateDurableReadback(record);
         case "boundary_invocation":
         case "external_side_effect":
             return validateObserverEvidence(check, record.observer_target_ref);
+        case "actual_provenance":
+            return validateActualProvenance(check, record);
+        case "distinct_identity":
+            return validateDistinctIdentity(record);
+        case "data_state":
+            return validateDataState(record);
+        case "population_coverage":
+            return validatePopulationCoverage(record);
         case "failure_injection":
-            return record.failure_observed ? null : "failure_not_observed";
+            return validateFailureInjection(record);
+        case "recovery":
+            return validateRecovery(record);
         case "visual_render":
-            return artifactHashes[record.artifact_path] === record.artifact_sha256
-                ? null
-                : "artifact_hash_mismatch";
+            return validateVisualRender(record, artifactHashes);
         case "design_conformance":
             return validateDesignConformance(check, record, artifactHashes);
         case "design_method":
@@ -46,6 +46,54 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes, adm
             return validateInputVariation(record);
     }
 }
+function validateStateDelta(record) {
+    if (record.before_sha256 === record.after_sha256)
+        return "state_unchanged";
+    return record.changed_fields.length ? null : "changed_fields_empty";
+}
+function validateDurableReadback(record) {
+    if (record.write_session_id === record.read_session_id)
+        return "independent_session_required";
+    return record.written_sha256 === record.read_sha256
+        ? null
+        : "readback_mismatch";
+}
+function validateActualProvenance(check, record) {
+    return record.source_kind === "observer_runtime" &&
+        check.execution_target_definition.role !== "observer"
+        ? "observer_provenance_target_required"
+        : null;
+}
+function validateDistinctIdentity(record) {
+    if (record.identities.length < 2)
+        return "two_identities_required";
+    if (new Set(record.identities.map((item) => item.identity_ref)).size !==
+        record.identities.length)
+        return "identity_duplicate";
+    return new Set(record.identities.map((item) => item.data_state_sha256)).size <
+        2
+        ? "independent_data_states_required"
+        : null;
+}
+function validateDataState(record) {
+    return record.read_session_id.trim() ? null : "read_session_required";
+}
+function validatePopulationCoverage(record) {
+    return record.set_equality ? null : "set_equality_required";
+}
+function validateFailureInjection(record) {
+    return record.failure_observed ? null : "failure_not_observed";
+}
+function validateRecovery(record) {
+    return record.failure_session_id === record.recovery_session_id
+        ? "independent_recovery_session_required"
+        : null;
+}
+function validateVisualRender(record, artifactHashes) {
+    return artifactHashes[record.artifact_path] === record.artifact_sha256
+        ? null
+        : "artifact_hash_mismatch";
+}
 function validateAdmittedObservationRecord(check, record, admitted) {
     if (record.capability === "semantic_fact" &&
         record.observer_results.length > 0)

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

@@ -2,6 +2,8 @@ import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.j
 import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 import type { DesignResourceComparator, DesignResourceLocatedDigestV1 } from "./design-resource-fact-manifest-types.js";
 import type { SemanticFactEnvironmentV1, SemanticFactLocatedValueV1, SemanticFactOracleV1 } from "./semantic-fact-types.js";
+import type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2 } from "./long-task-complete-delivery-evidence-types.js";
+export type { ActualProvenanceEvidenceV2, DataStateEvidenceV2, DistinctIdentityEvidenceV2, PopulationCoverageEvidenceV2, RecoveryEvidenceV2, } from "./long-task-complete-delivery-evidence-types.js";
 interface EvidenceRecordBaseV2 {
     assertion_key: string;
     capability: EvidenceCapabilityV2;
@@ -272,5 +274,4 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
-export {};
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ActualProvenanceEvidenceV2 | ExternalSideEffectEvidenceV2 | DistinctIdentityEvidenceV2 | DataStateEvidenceV2 | PopulationCoverageEvidenceV2 | FailureInjectionEvidenceV2 | RecoveryEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | DesignSymbolicCertificateEvidenceV2 | SemanticFactEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;

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

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