project-tiny-context-harness 0.7.3 → 0.7.4

package/dist/lib/long-task-contract-types.d.ts

@@ -1,5 +1,6 @@
 import type { LongTaskRiskFacts, RequestedRiskLevel } from "./long-task-risk-types.js";
 import type { CounterfactualControlV2, GlobalCounterfactualControlV2 } from "./long-task-counterfactual-types.js";
+import type { CheckExecutionTargetV2, DeliveryJourneyRoleV2, DeliveryScenarioV2, DeliveryStageV2, EvidenceCapabilityV2, ExecutionTargetV2, ExternalConfirmationKindV2, KeyedStatementV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
 export type SourceClaimDispositionV2 = {
     type: "claim";
     refs: string[];
@@ -28,10 +29,6 @@ export interface SourceClaimV2 {
     statement: string;
     disposition: SourceClaimDispositionV2;
 }
-export interface KeyedStatementV2 {
-    key: string;
-    statement: string;
-}
 export interface KeyedPathV2 {
     key: string;
     path: string;
@@ -40,6 +37,9 @@ export interface ExternalConfirmationV2 {
     key: string;
     description: string;
     owner: string;
+    kind: ExternalConfirmationKindV2;
+    impact_claims: string[];
+    blocks_target: boolean;
 }
 export type ProofSurface = "ui_browser" | "runtime_behavior" | "api_contract" | "data_state" | "security_boundary" | "population_coverage" | "implementation_structure";
 export type RunnerType = "package_script" | "project_binary" | "node_oracle" | "playwright_test";
@@ -51,6 +51,7 @@ interface DeliveryAssertionBaseV2 {
     criterion?: string;
     claims: string[];
     observation: string;
+    evidence_capabilities: EvidenceCapabilityV2[];
 }
 export type DeliveryAssertionV2 = (DeliveryAssertionBaseV2 & {
     operator: PresenceOrUnaryAssertionOperator;
@@ -86,6 +87,9 @@ export type EnvironmentRequirementV2 = {
 };
 export interface DeliveryCheckV2 {
     key: string;
+    journey_roles: DeliveryJourneyRoleV2[];
+    execution_target: CheckExecutionTargetV2;
+    scenario: DeliveryScenarioV2;
     proof_surface: ProofSurface;
     runner: DeliveryRunnerV2;
     verification_inputs: string[];
@@ -144,9 +148,12 @@ export interface PopulationRequirementV2 {
 export interface DeliveryOutcomeV2 {
     key: string;
     title: string;
+    stage: string;
     depends_on: string[];
     product: {
         observable_result: string;
+        success_path_required: boolean;
+        degradation_path_required: boolean;
         owner: DeliveryOwnerV2;
         requirements: DeliveryRequirementV2[];
         owner_surfaces: string[];
@@ -174,11 +181,14 @@ export interface DeliveryContractV2 {
         id: string;
         title: string;
         goal: string;
+        target_profile: TargetProfileV2;
+        execution_targets: ExecutionTargetV2[];
         source_paths: string[];
         context_refs: string[];
         context_snapshot_mode: "referenced" | "full";
     };
     source_claims: SourceClaimV2[];
+    stages: DeliveryStageV2[];
     risk: {
         requested_level: RequestedRiskLevel;
         facts: LongTaskRiskFacts;

package/dist/lib/long-task-delivery-compiler.js

@@ -114,6 +114,7 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         task: contract.task,
         risk: contract.risk,
         source_claims: contract.source_claims,
+        stages: contract.stages,
         global: {
             product: contract.global.product,
             technical: contract.global.technical,

package/dist/lib/long-task-delivery-parser.js

@@ -5,8 +5,9 @@ import { validateDeliveryContractStructure } from "./long-task-delivery-validati
 import { parseOutcome, parseOutcomeFragment, safeFragmentPath, } from "./long-task-outcome-parser.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { array, literal, object, parseSourceClaims, strings, } from "./long-task-delivery-shape.js";
-import { parseGlobal, parseRisk, parseTask } from "./long-task-root-shape.js";
+import { parseGlobal, parseRisk, parseStages, parseTask, } from "./long-task-root-shape.js";
 import { repositoryRoot } from "./long-task-workspace.js";
+import { assertNoSemanticDriftMigration, semanticDriftMigrationFields, } from "./long-task-semantic-drift-migration.js";
 export const DELIVERY_CONTRACT_FILE = "delivery-contract.yaml";
 export async function parseDeliveryContract(workdir) {
     return (await parseDeliveryContractBundle(workdir)).contract;
@@ -75,7 +76,8 @@ function parseRoot(raw, bundle) {
         decoded.schema_version ===
             "long-task-delivery-v1")
         throw new Error("long_task_delivery_v1_retired_use_v2");
-    return object(decoded, "$", ["schema_version", "task", "source_claims", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
+    assertNoSemanticDriftMigration(semanticDriftMigrationFields(decoded));
+    return object(decoded, "$", ["schema_version", "task", "source_claims", "stages", "risk", "global"], bundle ? ["outcomes", "outcome_files"] : ["outcomes"]);
 }
 function parseContractRoot(root, outcomes) {
     literal(root.schema_version, ["long-task-delivery-v2"], "schema_version");
@@ -83,6 +85,7 @@ function parseContractRoot(root, outcomes) {
         schema_version: "long-task-delivery-v2",
         task: parseTask(root.task),
         source_claims: parseSourceClaims(root.source_claims, "source_claims"),
+        stages: parseStages(root.stages),
         risk: parseRisk(root.risk),
         global: parseGlobal(root.global),
         outcomes,

package/dist/lib/long-task-delivery-types.d.ts

@@ -2,7 +2,9 @@ export * from "./long-task-contract-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-evidence-capability-types.js";
 export * from "./long-task-risk-types.js";
 export * from "./long-task-runtime-types.js";
+export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";

package/dist/lib/long-task-delivery-types.js

@@ -2,7 +2,9 @@ export * from "./long-task-contract-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";
+export * from "./long-task-evidence-capability-types.js";
 export * from "./long-task-risk-types.js";
 export * from "./long-task-runtime-types.js";
+export * from "./long-task-semantic-contract-types.js";
 export * from "./long-task-source-authority-types.js";
 export * from "./long-task-workspace-runtime-types.js";

package/dist/lib/long-task-delivery-validation.js

@@ -4,6 +4,9 @@ import { proveRepositoryPatternSubset } from "./long-task-paths.js";
 import { validateSourceClaimMappings } from "./long-task-source-claim-validation.js";
 import { validateDeclaredCheckSafety } from "./long-task-claim-proof-policy.js";
 import { validateEvidenceAdapterCompatibility } from "./long-task-evidence-adapter-policy.js";
+import { validateEvidenceCapabilityDeclarations } from "./long-task-evidence-capability-policy.js";
+import { validateDeliveryStages } from "./long-task-stage-policy.js";
+import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "./long-task-target-policy.js";
 export function validateDeliveryContractStructure(contract) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
@@ -15,12 +18,19 @@ export function validateDeliveryContractStructure(contract) {
     });
     validateSourceClaimMappings(contract, claims);
     assertCompiledClaimsCovered(claims);
+    validateDeliveryStages(contract);
+    validateExecutionTargets(contract);
+    validateEvidenceCapabilityDeclarations(contract);
+    validateExternalConfirmationImpacts(contract, claims);
 }
 export function deliveryContractStructureDiagnostics(contract) {
     const diagnostics = [];
     const report = (message) => diagnostics.push(message);
     validateUniqueKeys(contract, report);
     validateDependencies(contract, report);
+    validateDeliveryStages(contract, report);
+    validateExecutionTargets(contract, report);
+    validateEvidenceCapabilityDeclarations(contract, report);
     validateOwnerAndBindings(contract, report);
     validateDeclaredCheckSafety(contract, report);
     validateEvidenceAdapters(contract, report);
@@ -30,6 +40,7 @@ export function deliveryContractStructureDiagnostics(contract) {
     });
     if (claims) {
         validateSourceClaimMappings(contract, claims, report);
+        validateExternalConfirmationImpacts(contract, claims, report);
         capture(diagnostics, () => assertCompiledClaimsCovered(claims));
     }
     return [...new Set(diagnostics)];

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

@@ -0,0 +1,2 @@
+import type { EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+export declare function decodeEvidenceCapabilityRecords(value: unknown): EvidenceCapabilityRecordV2[];

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

@@ -0,0 +1,231 @@
+export function decodeEvidenceCapabilityRecords(value) {
+    if (!Array.isArray(value))
+        throw invalidRecord("must_be_array");
+    return value.map((item, index) => decodeRecord(item, index));
+}
+function decodeRecord(value, index) {
+    const label = `evidence_records[${index}]`;
+    const row = record(value, label);
+    const assertionKey = key(row.assertion_key, `${label}.assertion_key`);
+    const capability = nonEmpty(row.capability, `${label}.capability`);
+    const base = { assertion_key: assertionKey };
+    switch (capability) {
+        case "interaction_trace":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "target_ref",
+                "given_keys",
+                "action_keys",
+            ]);
+            return {
+                ...base,
+                capability,
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                given_keys: keys(row.given_keys, `${label}.given_keys`),
+                action_keys: keys(row.action_keys, `${label}.action_keys`),
+            };
+        case "state_delta":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "before_sha256",
+                "after_sha256",
+                "changed_fields",
+            ]);
+            return {
+                ...base,
+                capability,
+                before_sha256: sha(row.before_sha256, `${label}.before_sha256`),
+                after_sha256: sha(row.after_sha256, `${label}.after_sha256`),
+                changed_fields: strings(row.changed_fields, `${label}.changed_fields`),
+            };
+        case "cross_surface_consistency":
+            exact(row, label, ["assertion_key", "capability", "surfaces"]);
+            return {
+                ...base,
+                capability,
+                surfaces: array(row.surfaces, `${label}.surfaces`).map((item, surfaceIndex) => {
+                    const surfaceLabel = `${label}.surfaces[${surfaceIndex}]`;
+                    const surface = record(item, surfaceLabel);
+                    exact(surface, surfaceLabel, [
+                        "surface_ref",
+                        "target_ref",
+                        "state_sha256",
+                    ]);
+                    return {
+                        surface_ref: key(surface.surface_ref, `${surfaceLabel}.surface_ref`),
+                        target_ref: key(surface.target_ref, `${surfaceLabel}.target_ref`),
+                        state_sha256: sha(surface.state_sha256, `${surfaceLabel}.state_sha256`),
+                    };
+                }),
+            };
+        case "durable_readback":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "write_session_id",
+                "read_session_id",
+                "written_sha256",
+                "read_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                write_session_id: nonEmpty(row.write_session_id, `${label}.write_session_id`),
+                read_session_id: nonEmpty(row.read_session_id, `${label}.read_session_id`),
+                written_sha256: sha(row.written_sha256, `${label}.written_sha256`),
+                read_sha256: sha(row.read_sha256, `${label}.read_sha256`),
+            };
+        case "boundary_invocation":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "boundary",
+                "invocation_id",
+                "request_sha256",
+                "observer_target_ref",
+            ]);
+            return {
+                ...base,
+                capability,
+                boundary: nonEmpty(row.boundary, `${label}.boundary`),
+                invocation_id: nonEmpty(row.invocation_id, `${label}.invocation_id`),
+                request_sha256: sha(row.request_sha256, `${label}.request_sha256`),
+                observer_target_ref: key(row.observer_target_ref, `${label}.observer_target_ref`),
+            };
+        case "external_side_effect":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "boundary",
+                "effect_id",
+                "effect_sha256",
+                "observer_target_ref",
+            ]);
+            return {
+                ...base,
+                capability,
+                boundary: nonEmpty(row.boundary, `${label}.boundary`),
+                effect_id: nonEmpty(row.effect_id, `${label}.effect_id`),
+                effect_sha256: sha(row.effect_sha256, `${label}.effect_sha256`),
+                observer_target_ref: key(row.observer_target_ref, `${label}.observer_target_ref`),
+            };
+        case "failure_injection":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "fault",
+                "failure_observed",
+                "recovery_state_sha256",
+            ]);
+            if (row.failure_observed !== true)
+                throw invalidRecord(`${label}.failure_observed`);
+            return {
+                ...base,
+                capability,
+                fault: nonEmpty(row.fault, `${label}.fault`),
+                failure_observed: true,
+                recovery_state_sha256: sha(row.recovery_state_sha256, `${label}.recovery_state_sha256`),
+            };
+        case "visual_render":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "artifact_path",
+                "artifact_sha256",
+            ]);
+            return {
+                ...base,
+                capability,
+                artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
+                artifact_sha256: sha(row.artifact_sha256, `${label}.artifact_sha256`),
+            };
+        case "target_runtime":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "target_ref",
+                "root_entrypoint",
+                "session_id",
+                "cold_start",
+            ]);
+            if (typeof row.cold_start !== "boolean")
+                throw invalidRecord(`${label}.cold_start`);
+            return {
+                ...base,
+                capability,
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                root_entrypoint: nonEmpty(row.root_entrypoint, `${label}.root_entrypoint`),
+                session_id: nonEmpty(row.session_id, `${label}.session_id`),
+                cold_start: row.cold_start,
+            };
+        case "input_variation":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "cases",
+                "failure_case_observed",
+            ]);
+            if (typeof row.failure_case_observed !== "boolean")
+                throw invalidRecord(`${label}.failure_case_observed`);
+            return {
+                ...base,
+                capability,
+                cases: array(row.cases, `${label}.cases`).map((item, caseIndex) => {
+                    const caseLabel = `${label}.cases[${caseIndex}]`;
+                    const entry = record(item, caseLabel);
+                    exact(entry, caseLabel, ["input_sha256", "output_sha256"]);
+                    return {
+                        input_sha256: sha(entry.input_sha256, `${caseLabel}.input_sha256`),
+                        output_sha256: sha(entry.output_sha256, `${caseLabel}.output_sha256`),
+                    };
+                }),
+                failure_case_observed: row.failure_case_observed,
+            };
+        default:
+            throw invalidRecord(`${label}.capability_unsupported:${capability}`);
+    }
+}
+function invalidRecord(detail) {
+    return new Error(`check_evidence_records_invalid:${detail}`);
+}
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalidRecord(label);
+    return value;
+}
+function exact(row, label, fields) {
+    const allowed = new Set(fields);
+    if (fields.some((field) => !Object.hasOwn(row, field)) ||
+        Object.keys(row).some((field) => !allowed.has(field)))
+        throw invalidRecord(`${label}.shape`);
+}
+function array(value, label) {
+    if (!Array.isArray(value))
+        throw invalidRecord(label);
+    return value;
+}
+function nonEmpty(value, label) {
+    if (typeof value !== "string" || !value.trim())
+        throw invalidRecord(label);
+    return value;
+}
+function key(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}
+function strings(value, label) {
+    return array(value, label).map((item, index) => nonEmpty(item, `${label}[${index}]`));
+}
+function keys(value, label) {
+    return array(value, label).map((item, index) => key(item, `${label}[${index}]`));
+}
+function sha(value, label) {
+    const result = nonEmpty(value, label);
+    if (!/^[a-f0-9]{64}$/u.test(result))
+        throw invalidRecord(label);
+    return result;
+}

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

@@ -0,0 +1,8 @@
+import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityRecordV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
+export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
+type Reporter = (message: string) => void;
+export declare function validateEvidenceCapabilityDeclarations(contract: DeliveryContractV2, report?: Reporter): void;
+export declare function evaluateEvidenceCapabilities(check: CompiledCheckV2, records: EvidenceCapabilityRecordV2[], artifactHashes: Record<string, string>): {
+    complete: Record<string, boolean>;
+    findings: LongTaskFindingV2[];
+};

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

@@ -0,0 +1,147 @@
+import { validateRuntimeEvidenceRecord } from "./long-task-evidence-capability-runtime.js";
+import { checkFinding } from "./long-task-evidence-findings.js";
+export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
+export function validateEvidenceCapabilityDeclarations(contract, report) {
+    const targets = new Map(contract.task.execution_targets.map((target) => [target.key, target]));
+    for (const [outcomeKey, check] of allChecks(contract)) {
+        unique(check.journey_roles, "journey_role_duplicate", checkLabel(outcomeKey, check.key), report);
+        if (!check.journey_roles.length)
+            issue(report, "journey_role_required", checkLabel(outcomeKey, check.key));
+        validateScenario(check, outcomeKey, report);
+        for (const assertion of [
+            ...check.positive_assertions,
+            ...check.negative_assertions,
+        ]) {
+            const label = `${checkLabel(outcomeKey, check.key)}:${assertion.key}`;
+            unique(assertion.evidence_capabilities, "evidence_capability_duplicate", label, report);
+            if (!assertion.evidence_capabilities.length)
+                issue(report, "evidence_capability_required", label);
+            if (assertion.claims.length &&
+                check.proof_surface !== "implementation_structure" &&
+                assertion.evidence_capabilities.every((capability) => capability === "presence"))
+                issue(report, "presence_cannot_prove_behavior", label);
+            if (assertion.operator === "exists" &&
+                !assertion.evidence_capabilities.includes("presence"))
+                issue(report, "exists_requires_presence_capability", label);
+            if (assertion.evidence_capabilities.includes("visual_render") &&
+                !check.artifact_globs.length)
+                issue(report, "visual_render_artifact_required", label);
+            if (assertion.evidence_capabilities.includes("interaction_trace") &&
+                !check.scenario.when.length)
+                issue(report, "interaction_trace_actions_required", label);
+            if (check.runner.type === "playwright_test" &&
+                assertion.evidence_capabilities.some((capability) => capability !== "presence" &&
+                    capability !== "interaction_trace" &&
+                    capability !== "target_runtime"))
+                issue(report, "playwright_evidence_capability_unsupported", label);
+            if (["boundary_invocation", "external_side_effect"].some((capability) => assertion.evidence_capabilities.includes(capability)) &&
+                targets.get(check.execution_target.target_ref)?.role !== "observer")
+                issue(report, "observer_check_target_required", label);
+        }
+    }
+    validateJourneySeparation(contract, report);
+}
+function validateScenario(check, outcomeKey, report) {
+    const label = checkLabel(outcomeKey, check.key);
+    if (!check.scenario.given.length)
+        issue(report, "scenario_given_required", label);
+    if (!check.scenario.when.length)
+        issue(report, "scenario_when_required", label);
+    unique(check.scenario.given.map((step) => step.key), "scenario_given_key_duplicate", label, report);
+    unique(check.scenario.when.map((step) => step.key), "scenario_when_key_duplicate", label, report);
+}
+function validateJourneySeparation(contract, report) {
+    for (const outcome of contract.outcomes) {
+        for (const check of outcome.acceptance.checks)
+            if (check.journey_roles.includes("success") &&
+                check.journey_roles.includes("degradation"))
+                issue(report, "success_degradation_check_must_be_distinct", `${outcome.key}:${check.key}`);
+        if (outcome.product.success_path_required &&
+            !outcome.acceptance.checks.some((check) => check.journey_roles.includes("success")))
+            issue(report, "success_path_check_required", outcome.key);
+        if (outcome.product.degradation_path_required &&
+            !outcome.acceptance.checks.some((check) => check.journey_roles.includes("degradation")))
+            issue(report, "degradation_path_check_required", outcome.key);
+        for (const check of outcome.acceptance.checks) {
+            const provesResult = [
+                ...check.positive_assertions,
+                ...check.negative_assertions,
+            ].some((assertion) => assertion.claims.includes("result"));
+            if (provesResult && !check.journey_roles.includes("success"))
+                issue(report, "result_claim_requires_success_journey", `${outcome.key}:${check.key}`);
+        }
+    }
+}
+export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
+    const runtimeRecords = records ?? [];
+    const complete = {};
+    const findings = [];
+    const assertions = [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ];
+    const assertionsByKey = new Map(assertions.map((assertion) => [assertion.key, assertion]));
+    for (const record of runtimeRecords) {
+        const assertion = assertionsByKey.get(record.assertion_key);
+        const reason = !assertion
+            ? "assertion_unknown"
+            : !assertion.evidence_capabilities.includes(record.capability)
+                ? "capability_undeclared"
+                : null;
+        if (!reason)
+            continue;
+        findings.push({
+            ...checkFinding(check, "evidence_capability_invalid", `Evidence record ${record.assertion_key}:${record.capability} is not bound to a declared Assertion capability: ${reason}.`, "Emit records only for capabilities declared by Assertions in this Check."),
+            assertion_key: record.assertion_key,
+            claim_keys: assertion?.claims ?? [],
+            expected: "declared_assertion_capability",
+            actual: reason,
+        });
+    }
+    for (const assertion of assertions) {
+        let assertionComplete = true;
+        for (const capability of assertion.evidence_capabilities) {
+            if (capability === "presence")
+                continue;
+            const matches = runtimeRecords.filter((record) => record.assertion_key === assertion.key &&
+                record.capability === capability);
+            const reason = matches.length === 1
+                ? validateRuntimeEvidenceRecord(check, matches[0], artifactHashes)
+                : matches.length === 0
+                    ? "record_missing"
+                    : "record_duplicate";
+            if (!reason)
+                continue;
+            assertionComplete = false;
+            findings.push({
+                ...checkFinding(check, "evidence_capability_invalid", `Assertion ${assertion.key} did not provide valid ${capability} evidence: ${reason}.`, "Make the current Check execution emit one valid typed evidence record for the declared capability."),
+                assertion_key: assertion.key,
+                claim_keys: assertion.claims,
+                expected: capability,
+                actual: reason,
+            });
+        }
+        complete[assertion.key] = assertionComplete;
+    }
+    return { complete, findings };
+}
+function allChecks(contract) {
+    return [
+        ...contract.global.acceptance.checks.map((check) => [null, check]),
+        ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [outcome.key, check])),
+    ];
+}
+function checkLabel(outcomeKey, checkKey) {
+    return `${outcomeKey ?? "GLOBAL"}:${checkKey}`;
+}
+function unique(values, code, detail, report) {
+    if (new Set(values).size !== values.length)
+        issue(report, code, detail);
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}

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

@@ -0,0 +1,2 @@
+import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+export declare function validateRuntimeEvidenceRecord(check: CompiledCheckV2, record: EvidenceCapabilityRecordV2, artifactHashes: Record<string, string>): string | null;

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

@@ -0,0 +1,86 @@
+export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
+    switch (record.capability) {
+        case "interaction_trace":
+            return validateInteractionTrace(check, record);
+        case "state_delta":
+            if (record.before_sha256 === record.after_sha256)
+                return "state_unchanged";
+            if (!record.changed_fields.length)
+                return "changed_fields_empty";
+            return null;
+        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;
+        case "boundary_invocation":
+        case "external_side_effect":
+            return validateObserverEvidence(check, record.observer_target_ref);
+        case "failure_injection":
+            return record.failure_observed ? null : "failure_not_observed";
+        case "visual_render":
+            return artifactHashes[record.artifact_path] === record.artifact_sha256
+                ? null
+                : "artifact_hash_mismatch";
+        case "target_runtime":
+            return validateTargetRuntime(check, record);
+        case "input_variation":
+            return validateInputVariation(record);
+    }
+}
+function validateInteractionTrace(check, record) {
+    if (record.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    if (!same(record.given_keys, check.scenario.given.map((step) => step.key)))
+        return "given_trace_mismatch";
+    if (!same(record.action_keys, check.scenario.when.map((step) => step.key)))
+        return "action_trace_mismatch";
+    return null;
+}
+function validateCrossSurfaceConsistency(check, record) {
+    const surfaces = new Set(record.surfaces.map((surface) => surface.surface_ref));
+    const targets = new Set(record.surfaces.map((surface) => surface.target_ref));
+    const states = new Set(record.surfaces.map((surface) => surface.state_sha256));
+    if (surfaces.size < 2)
+        return "two_surfaces_required";
+    if (states.size !== 1)
+        return "state_hash_mismatch";
+    if ([...targets].some((target) => !check.known_execution_targets.some((item) => item.key === target)))
+        return "target_unknown";
+    return null;
+}
+function validateObserverEvidence(check, observerTargetRef) {
+    const observer = check.known_execution_targets.find((target) => target.key === observerTargetRef);
+    if (!observer || observer.role !== "observer")
+        return "observer_target_invalid";
+    if (observer.key !== check.execution_target.target_ref)
+        return "check_must_execute_on_observer";
+    return null;
+}
+function validateTargetRuntime(check, record) {
+    if (record.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    if (record.root_entrypoint !== check.execution_target_definition.root_entrypoint)
+        return "root_entrypoint_mismatch";
+    if (check.execution_target.entrypoint === "root" && !record.cold_start)
+        return "cold_start_required";
+    return null;
+}
+function validateInputVariation(record) {
+    const inputs = new Set(record.cases.map((item) => item.input_sha256));
+    const outputs = new Set(record.cases.map((item) => item.output_sha256));
+    if (inputs.size < 2)
+        return "distinct_inputs_required";
+    if (outputs.size < 2)
+        return "input_must_reach_output";
+    if (!record.failure_case_observed)
+        return "failure_case_required";
+    return null;
+}
+function same(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}