project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,93 @@
+import type { CompiledCheckV2, CompiledObservationAuthorityV2, EvidenceCapabilityRecordV2, PackageObservationValueV2 } from "./long-task-delivery-types.js";
+import { type ExactDigestComparisonResult } from "./long-task-exact-comparison.js";
+import { JSON_POINTER_EXACT_CAPABILITY, type JsonPointerExactLocator, type JsonPointerExactObservation } from "./long-task-json-pointer-observation.js";
+export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, createJsonPointerExactBudget, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
+export type { JsonPointerExactBudget, JsonPointerExactLocator, JsonPointerExactObservation, } from "./long-task-json-pointer-observation.js";
+export { extractJsonPointerExactObservation } from "./long-task-observation-artifact.js";
+export interface PreparedAdmittedObservation {
+    assertion_key: string;
+    identity_ref: string;
+    authority_key: string | null;
+    obligation_ref: string | null;
+    method: string;
+    observation_key: string;
+    authority: CompiledObservationAuthorityV2["authority"] | null;
+    raw_value: unknown;
+    observation: JsonPointerExactObservation | null;
+    comparison: ExactDigestComparisonResult | null;
+    reason: string | null;
+}
+export interface PreparedAdmittedObservationSet {
+    readonly by_observation_key: ReadonlyMap<string, PreparedAdmittedObservation>;
+    readonly by_authority_key: ReadonlyMap<string, PreparedAdmittedObservation>;
+    readonly entries: readonly PreparedAdmittedObservation[];
+}
+export declare function prepareAdmittedObservations(input: {
+    check: CompiledCheckV2;
+    records: EvidenceCapabilityRecordV2[];
+    snapshot_root: string;
+    authority_paths?: readonly string[];
+    package_observations?: readonly PackageObservationValueV2[];
+}): Promise<PreparedAdmittedObservationSet>;
+export declare function admittedObservationAuthorityKey(authority: Pick<CompiledObservationAuthorityV2, "assertion_ref" | "obligation_ref" | "method">): string;
+export declare function resolveObservationAuthority(check: CompiledCheckV2, candidate: {
+    assertion_key: string;
+    identity_ref: string;
+    method: string;
+}): {
+    authority: CompiledObservationAuthorityV2;
+    reason: null;
+} | {
+    authority: null;
+    reason: string;
+};
+export declare function admittedObservationKey(artifactPath: string, locator: JsonPointerExactLocator): string;
+export declare function jsonPointerExactLocatorForIdentity(identity: string): {
+    kind: "json_pointer";
+    value: string;
+};
+export type ObservationCarrierRole = "expected_authority_forbidden" | "product_carrier" | "current_observer_artifact" | "unadmitted_evidence";
+export type MachineObservationCarrierRoleConflict = "expected_authority" | "evidence_role";
+export declare function classifyMachineObservationCarrierRoleConflict(input: {
+    carrier_pattern: string;
+    expected_authority_patterns: readonly string[];
+    evidence_role_patterns: readonly string[];
+}): MachineObservationCarrierRoleConflict | null;
+export declare function classifyObservationCarrier(input: {
+    artifact_path: string;
+    source_paths: string[];
+    expected_authority_paths: string[];
+    product_carrier_paths: string[];
+    current_observer_artifact_paths: string[];
+}): ObservationCarrierRole;
+export interface ObservationAdmissionInput {
+    method: string;
+    comparator: string;
+    mode: string;
+    tolerance: unknown;
+    mask: unknown;
+    sensitivity: string;
+    locator: JsonPointerExactLocator;
+    oracle: {
+        trust?: string;
+        identity?: string;
+        version?: string;
+        sha256?: string | null;
+    };
+    target_family: string;
+    observed_target_family?: string;
+    required_method?: string;
+    current_static_artifact: boolean;
+    historical_session?: boolean;
+    snapshot_matches?: boolean;
+}
+export type ObservationAdmissionDecision = {
+    authority: "machine";
+    reason: null;
+    capability: typeof JSON_POINTER_EXACT_CAPABILITY;
+} | {
+    authority: "external_confirmation";
+    reason: string;
+    capability: null;
+};
+export declare function observationAdmissionDecision(input: ObservationAdmissionInput): ObservationAdmissionDecision;

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

@@ -0,0 +1,201 @@
+import { classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { evaluateExactDigestComparison, } from "./long-task-exact-comparison.js";
+import { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_METHODS, isJsonPointerExactOracle, normalizeObservationArtifactPath, validateJsonPointerExactLocator, } from "./long-task-json-pointer-observation.js";
+export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, createJsonPointerExactBudget, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, } from "./long-task-json-pointer-observation.js";
+export { extractJsonPointerExactObservation } from "./long-task-observation-artifact.js";
+export async function prepareAdmittedObservations(input) {
+    const entries = [];
+    const entriesByAuthority = new Map();
+    for (const authority of input.check.observation_authorities ?? []) {
+        const authorityKey = admittedObservationAuthorityKey(authority);
+        const candidates = (input.package_observations ?? []).filter((candidate) => candidate.authority === authority.authority &&
+            candidate.observation_identity === authority.observation_identity &&
+            candidate.assertion_ref === authority.assertion_ref &&
+            candidate.obligation_ref === authority.obligation_ref &&
+            candidate.method === authority.method);
+        const candidate = candidates.length === 1 ? candidates[0] : null;
+        let reason = null;
+        let comparison = null;
+        if (authority.authority === "external_confirmation")
+            reason = "unsupported_observer_requires_external_confirmation";
+        else if (candidates.length > 1)
+            reason = "admitted_observation_duplicate";
+        else if (!candidate)
+            reason =
+                authority.authority === "package_process_json_exact"
+                    ? "admitted_observation_runtime_required"
+                    : "admitted_observation_missing";
+        else if (candidate.reason)
+            reason = candidate.reason;
+        else if (!candidate.observation)
+            reason = "admitted_observation_missing";
+        else if (candidate.observation.locator.kind !== "json_pointer" ||
+            candidate.observation.locator.value !== authority.locator_policy.value)
+            reason = "observation_locator_identity_mismatch";
+        else {
+            try {
+                comparison = evaluateExactDigestComparison({
+                    identity: {
+                        kind: "compiled_observation_authority",
+                        expected_identity: authority.expected_identity,
+                        obligation_ref: authority.obligation_ref,
+                        observation_identity: authority.observation_identity,
+                        target_ref: authority.target_ref,
+                        method: authority.method,
+                    },
+                    actual_value_sha256: projectedActualValueSha256(authority, candidate),
+                    expected_value_sha256: authority.expected_value_sha256,
+                    comparator: authority.comparison.comparator,
+                    mode: authority.comparison.mode,
+                    parameters_sha256: authority.comparison.parameters_sha256 ?? "",
+                    tolerance_sha256: authority.comparison.tolerance_sha256,
+                    mask_sha256: authority.comparison.mask_sha256,
+                });
+            }
+            catch (error) {
+                reason = error instanceof Error ? error.message : String(error);
+            }
+        }
+        const entry = {
+            assertion_key: authority.assertion_ref,
+            identity_ref: authority.observation_identity,
+            authority_key: authorityKey,
+            obligation_ref: authority.obligation_ref,
+            method: authority.method,
+            observation_key: candidate?.observation
+                ? admittedObservationKey(candidate.observation.artifact_path, candidate.observation.locator)
+                : `compiled-authority\0${authorityKey}`,
+            authority: authority.authority,
+            raw_value: candidate?.raw_value,
+            observation: candidate?.observation ?? null,
+            comparison,
+            reason,
+        };
+        entries.push(entry);
+        entriesByAuthority.set(authorityKey, entry);
+    }
+    for (const candidate of input.package_observations ?? []) {
+        const matches = (input.check.observation_authorities ?? []).filter((authority) => authority.authority === candidate.authority &&
+            authority.observation_identity === candidate.observation_identity &&
+            authority.assertion_ref === candidate.assertion_ref &&
+            authority.obligation_ref === candidate.obligation_ref &&
+            authority.method === candidate.method);
+        if (matches.length)
+            continue;
+        entries.push({
+            assertion_key: "",
+            identity_ref: candidate.observation_identity,
+            authority_key: null,
+            obligation_ref: null,
+            method: "exact_value",
+            observation_key: candidate.observation
+                ? admittedObservationKey(candidate.observation.artifact_path, candidate.observation.locator)
+                : `unbound-package-observation\0${candidate.observation_identity}`,
+            authority: null,
+            raw_value: candidate.raw_value,
+            observation: candidate.observation,
+            comparison: null,
+            reason: "machine_observer_not_admitted",
+        });
+    }
+    return {
+        by_observation_key: new Map(entries.map((entry) => [entry.observation_key, entry])),
+        by_authority_key: entriesByAuthority,
+        entries,
+    };
+}
+function projectedActualValueSha256(authority, candidate) {
+    if (!candidate.observation)
+        throw new Error("admitted_observation_missing");
+    if (authority.actual_projection === "raw_exact")
+        return candidate.observation.value_sha256;
+    const projected = authority.actual_projection === "presence_boolean"
+        ? true
+        : Boolean(candidate.raw_value);
+    return sha256Hex(canonicalValueJson(projected));
+}
+export function admittedObservationAuthorityKey(authority) {
+    return `${authority.assertion_ref}\0${authority.obligation_ref}\0${authority.method}`;
+}
+export function resolveObservationAuthority(check, candidate) {
+    const matches = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === candidate.assertion_key &&
+        authority.method === candidate.method &&
+        authority.observation_identity === candidate.identity_ref);
+    if (matches.length === 1)
+        return { authority: matches[0], reason: null };
+    return {
+        authority: null,
+        reason: matches.length === 0
+            ? "machine_observer_not_admitted"
+            : "machine_observer_authority_ambiguous",
+    };
+}
+export function admittedObservationKey(artifactPath, locator) {
+    return `${artifactPath}\0${canonicalValueJson(locator)}`;
+}
+export function jsonPointerExactLocatorForIdentity(identity) {
+    return {
+        kind: "json_pointer",
+        value: `/observations/${identity.replace(/~/gu, "~0").replace(/\//gu, "~1")}`,
+    };
+}
+export function classifyMachineObservationCarrierRoleConflict(input) {
+    if (input.expected_authority_patterns.some((pattern) => classifyRepositoryPatternOverlap(input.carrier_pattern, pattern)
+        .status === "proven_overlap"))
+        return "expected_authority";
+    if (input.evidence_role_patterns.some((pattern) => classifyRepositoryPatternOverlap(input.carrier_pattern, pattern)
+        .status === "proven_overlap"))
+        return "evidence_role";
+    return null;
+}
+export function classifyObservationCarrier(input) {
+    const artifactPath = normalizeObservationArtifactPath(input.artifact_path);
+    if (matchesAny(artifactPath, input.source_paths) ||
+        matchesAny(artifactPath, input.expected_authority_paths))
+        return "expected_authority_forbidden";
+    if (matchesAny(artifactPath, input.product_carrier_paths))
+        return "product_carrier";
+    if (matchesAny(artifactPath, input.current_observer_artifact_paths))
+        return "current_observer_artifact";
+    return "unadmitted_evidence";
+}
+export function observationAdmissionDecision(input) {
+    if (input.observed_target_family !== undefined &&
+        input.observed_target_family !== input.target_family)
+        return external("observation_target_proxy_mismatch");
+    if (input.required_method && input.required_method !== input.method)
+        return external("observation_capability_mismatch");
+    if (input.target_family !== "process" ||
+        input.historical_session === true ||
+        !input.current_static_artifact ||
+        input.snapshot_matches === false)
+        return external("observation_current_static_target_required");
+    if (!isJsonPointerExactOracle(input.oracle))
+        return external("observation_oracle_not_admitted");
+    if (!JSON_POINTER_EXACT_METHODS.some((method) => method === input.method) ||
+        input.comparator !== "exact_value" ||
+        input.mode !== "exact" ||
+        input.tolerance !== null ||
+        input.mask !== null)
+        return external("observation_method_not_admitted");
+    if (input.sensitivity !== "plain")
+        return external("observation_protected_requires_frozen_adapter");
+    try {
+        validateJsonPointerExactLocator(input.locator);
+    }
+    catch {
+        return external("observation_locator_not_admitted");
+    }
+    return {
+        authority: "machine",
+        reason: null,
+        capability: JSON_POINTER_EXACT_CAPABILITY,
+    };
+}
+function external(reason) {
+    return { authority: "external_confirmation", reason, capability: null };
+}
+function matchesAny(candidate, patterns) {
+    return patterns.some((pattern) => matchesRepoPattern(candidate, pattern));
+}

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

@@ -1,4 +1,5 @@
 import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
 export declare function collectCheckArtifacts(check: CompiledCheckV2, snapshotRoot: string): Promise<{
     hashes: Record<string, string>;
     errors: string[];

package/dist/lib/long-task-artifacts.js

@@ -2,6 +2,7 @@ import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { matchesRepoPattern } from "./long-task-paths.js";
 import { sha256Hex } from "./strict-codec.js";
+export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
 export async function collectCheckArtifacts(check, snapshotRoot) {
     if (!check.artifact_globs.length)
         return { hashes: {}, errors: [] };

package/dist/lib/long-task-authority-material-diff.js

@@ -120,6 +120,7 @@ function flattenProductSemantics(projection) {
         fields.set(`${prefix}.role`, target.role);
         fields.set(`${prefix}.runtime_family`, target.runtime_family);
         fields.set(`${prefix}.root_entrypoint`, target.root_entrypoint);
+        fields.set(`${prefix}.root_argv`, target.root_argv ?? null);
     }
     for (const stage of projection.stages) {
         const prefix = `stages.${stage.key}`;

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

@@ -271,6 +271,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
         preserved_assertions: "proof_additive";
+        allowed_fanout_assertions: "semantic_user_review";
     };
     readonly global_counterfactual: {
         key: "identity";
@@ -280,6 +281,7 @@ export declare const AUTHORITY_FIELD_POLICY_REGISTRIES: {
         mutation: "proof_additive";
         expected_assertion_failures: "proof_additive";
         preserved_assertions: "proof_additive";
+        allowed_fanout_assertions: "semantic_user_review";
     };
 };
 export declare function projectFieldsByPolicy<T extends object>(value: T, policy: Record<keyof T, AuthorityFieldPolicy>, included: ReadonlySet<AuthorityFieldPolicy>): Partial<T>;

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

@@ -254,6 +254,7 @@ const COUNTERFACTUAL_AUTHORITY_POLICY = {
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
     preserved_assertions: "proof_additive",
+    allowed_fanout_assertions: "semantic_user_review",
 };
 const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     key: "identity",
@@ -263,6 +264,7 @@ const GLOBAL_COUNTERFACTUAL_AUTHORITY_POLICY = {
     mutation: "proof_additive",
     expected_assertion_failures: "proof_additive",
     preserved_assertions: "proof_additive",
+    allowed_fanout_assertions: "semantic_user_review",
 };
 export const AUTHORITY_FIELD_POLICY_REGISTRIES = {
     task: TASK_AUTHORITY_POLICY,

package/dist/lib/long-task-authority-revision-details.js

@@ -154,7 +154,9 @@ function counterfactualCoveragePreserved(previous, next) {
         candidate.check_key === previous.check_key &&
         same(candidate.mutation, previous.mutation) &&
         includesEvery(candidate.claims, previous.claims) &&
-        includesEvery(candidate.expected_assertion_failures, previous.expected_assertion_failures));
+        includesEvery(candidate.expected_assertion_failures, previous.expected_assertion_failures) &&
+        includesEvery(candidate.preserved_assertions ?? [], previous.preserved_assertions ?? []) &&
+        includesEvery(previous.allowed_fanout_assertions ?? [], candidate.allowed_fanout_assertions ?? []));
 }
 function includesEvery(values, required) {
     const available = new Set(values);

package/dist/lib/long-task-authority.js

@@ -180,7 +180,8 @@ function counterfactualsStrengthened(previous, next) {
         same(candidate.mutation, control.mutation) &&
         subset(control.claims, candidate.claims) &&
         subset(control.expected_assertion_failures, candidate.expected_assertion_failures) &&
-        subset(control.preserved_assertions, candidate.preserved_assertions)));
+        subset(control.preserved_assertions, candidate.preserved_assertions) &&
+        subset(candidate.allowed_fanout_assertions ?? [], control.allowed_fanout_assertions ?? [])));
 }
 function subset(previous, next) {
     const available = new Set(next.map((item) => canonicalValueJson(item)));

package/dist/lib/long-task-check-execution-policy.js

@@ -21,6 +21,11 @@ export function rawExecutionInputProjection(check) {
     projection.known_execution_targets = check.known_execution_targets;
     projection.design_conformance_targets =
         check.design_conformance_targets ?? [];
+    projection.package_observation_protocol = (check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact")
+        ? "ty-context-product-observation-v1"
+        : null;
+    projection.process_runtime_closure_identity =
+        check.process_runtime_closure?.closure_identity ?? null;
     for (const field of Object.keys(CHECK_EXECUTION_INPUT_POLICY)) {
         const policy = CHECK_EXECUTION_INPUT_POLICY[field];
         if (policy === "raw_execution") {

package/dist/lib/long-task-check-runner.d.ts

@@ -1,2 +1,2 @@
-import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-export declare function executeCheckRunner(check: CompiledCheckV2, snapshotRoot: string): Promise<RawCommandExecutionV2>;
+import type { CompiledCheckV2, CheckRunnerExecutionContextV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
+export declare function executeCheckRunner(check: CompiledCheckV2, snapshotRoot: string, context?: CheckRunnerExecutionContextV2): Promise<RawCommandExecutionV2>;