project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,9 +0,0 @@
-import type { CompiledCheckV2, DeliveryContractV2, EvidenceCapabilityRecordV2, LongTaskFindingV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-import { type PreparedAdmittedObservationSet } from "./long-task-admitted-observation.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>, admittedObservations?: PreparedAdmittedObservationSet, rawExecution?: RawCommandExecutionV2): {
-    complete: Record<string, boolean>;
-    findings: LongTaskFindingV2[];
-};

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

@@ -1,345 +0,0 @@
-import { validateRuntimeEvidenceRecord } from "./long-task-evidence-capability-runtime.js";
-import { validateDistinctSemanticFactEvidence } from "./long-task-semantic-fact-evidence.js";
-import { checkFinding } from "./long-task-evidence-findings.js";
-import { admittedObservationAuthorityKey, } from "./long-task-admitted-observation.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)) {
-        validateCheckEvidenceCapabilityDeclarations(check, outcomeKey, targets, report);
-    }
-    validateJourneySeparation(contract, report);
-}
-function validateCheckEvidenceCapabilityDeclarations(check, outcomeKey, targets, report) {
-    const label = checkLabel(outcomeKey, check.key);
-    unique(check.journey_roles, "journey_role_duplicate", label, report);
-    if (!check.journey_roles.length)
-        issue(report, "journey_role_required", label);
-    validateScenario(check, outcomeKey, report);
-    for (const assertion of [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ])
-        validateAssertionEvidenceCapabilityDeclarations(assertion, check, targets, `${label}:${assertion.key}`, report);
-}
-function validateAssertionEvidenceCapabilityDeclarations(assertion, check, targets, label, report) {
-    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);
-    validateArtifactCapabilityDeclarations(assertion, check, label, report);
-    validateRunnerCapabilityDeclarations(assertion, check, targets, label, report);
-}
-function validateArtifactCapabilityDeclarations(assertion, check, label, report) {
-    if (assertion.evidence_capabilities.includes("visual_render") &&
-        !check.artifact_globs.length)
-        issue(report, "visual_render_artifact_required", label);
-    if (assertion.evidence_capabilities.includes("design_conformance") &&
-        !check.artifact_globs.length)
-        issue(report, "design_conformance_artifact_required", label);
-    if (assertion.evidence_capabilities.includes("design_method") &&
-        !check.artifact_globs.length)
-        issue(report, "design_method_artifact_required", label);
-    if (assertion.evidence_capabilities.includes("design_symbolic_certificate") &&
-        !check.artifact_globs.length)
-        issue(report, "design_symbolic_certificate_artifact_required", label);
-    if (assertion.evidence_capabilities.includes("semantic_fact") &&
-        !check.artifact_globs.length)
-        issue(report, "semantic_fact_artifact_required", label);
-}
-function validateRunnerCapabilityDeclarations(assertion, check, targets, label, report) {
-    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 !== "design_conformance" &&
-            capability !== "design_method" &&
-            capability !== "design_symbolic_certificate" &&
-            capability !== "semantic_fact" &&
-            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);
-}
-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, admittedObservations, rawExecution) {
-    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) {
-            const matches = runtimeRecords.filter((record) => record.assertion_key === assertion.key &&
-                record.capability === capability);
-            const derived = packageDerivedCapability(check, assertion.key, capability, admittedObservations, rawExecution);
-            const submittedReason = matches.length === 1
-                ? validateRuntimeEvidenceRecord(check, matches[0], artifactHashes, admittedObservations, rawExecution?.host_execution_attestation ?? null)
-                : matches.length > 1
-                    ? "record_duplicate"
-                    : null;
-            const reason = submittedReason ??
-                (derived.supported
-                    ? derived.reason
-                    : capability === "presence"
-                        ? null
-                        : matches.length === 0
-                            ? "record_missing"
-                            : null);
-            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,
-            });
-        }
-        const authorityIssues = assertionObservationAuthorityIssues(check, assertion.key, assertion.claims.length > 0, admittedObservations);
-        if (authorityIssues.length) {
-            assertionComplete = false;
-            for (const authorityIssue of authorityIssues) {
-                findings.push({
-                    ...checkFinding(check, "evidence_capability_invalid", `Assertion ${assertion.key} has no complete package-admitted current-Actual chain for ${authorityIssue.obligation_ref ?? "an unplanned machine obligation"}: ${authorityIssue.reason}.`, "Bind every machine-closing or liveness-preserving obligation to its compiled package observation authority, or move unsupported observation to an explicit blocking External Confirmation."),
-                    assertion_key: assertion.key,
-                    claim_keys: assertion.claims,
-                    expected: {
-                        authority: authorityIssue.authority,
-                        obligation_ref: authorityIssue.obligation_ref,
-                    },
-                    actual: authorityIssue.reason,
-                });
-            }
-        }
-        complete[assertion.key] = assertionComplete;
-    }
-    validateDistinctDesignMethodArtifacts(check, runtimeRecords, artifactHashes, findings);
-    const semanticDistinctness = validateDistinctSemanticFactEvidence(runtimeRecords);
-    if (semanticDistinctness)
-        findings.push({
-            ...checkFinding(check, "semantic_fact_evidence_reused", `Semantic Fact evidence is not independently attributable: ${semanticDistinctness}.`, "Emit exactly one independently located current observation and comparison result for every Fact-by-method obligation."),
-            expected: "unique_fact_proof_and_artifact_locator_identity",
-            actual: semanticDistinctness,
-        });
-    for (const entry of admittedObservations?.entries ?? [])
-        if (!entry.authority_key && entry.reason)
-            findings.push({
-                ...checkFinding(check, "evidence_capability_invalid", `A package observation was not bound to the compiled observation plan: ${entry.identity_ref}:${entry.reason}.`, "Emit only the exact identity set selected by the Harness-owned compiled observation plan."),
-                expected: "compiled_observation_identity",
-                actual: entry.identity_ref,
-            });
-    return { complete, findings };
-}
-function packageDerivedCapability(check, assertionKey, capability, admitted, raw) {
-    const authorities = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === assertionKey);
-    const supported = capability === "presence" ||
-        capability === "semantic_fact" ||
-        capability === "design_method" ||
-        capability === "target_runtime";
-    if (!supported || !authorities.length)
-        return { supported: false, reason: null };
-    for (const authority of authorities) {
-        if (authority.authority === "external_confirmation")
-            return {
-                supported: true,
-                reason: "unsupported_observer_requires_external_confirmation",
-            };
-        const prepared = admitted?.by_authority_key.get(admittedObservationAuthorityKey(authority));
-        if (!prepared)
-            return { supported: true, reason: "admitted_observation_missing" };
-        if (prepared.reason)
-            return { supported: true, reason: prepared.reason };
-        if (!prepared.observation || !prepared.comparison)
-            return { supported: true, reason: "admitted_observation_missing" };
-    }
-    const processRequired = capability === "target_runtime" ||
-        authorities.some((authority) => authority.authority === "package_process_json_exact");
-    if (processRequired) {
-        const attestation = raw?.host_execution_attestation;
-        if (!attestation)
-            return { supported: true, reason: "host_attestation_required" };
-        if (!attestation.direct_root_match ||
-            attestation.raw_execution_identity !== check.raw_execution_identity ||
-            !attestation.snapshot_sha256 ||
-            !check.process_runtime_closure ||
-            attestation.process_runtime_closure_identity !==
-                check.process_runtime_closure.closure_identity ||
-            attestation.exit_code !== 0 ||
-            attestation.exit_code !== raw?.exit_code)
-            return { supported: true, reason: "host_attestation_mismatch" };
-    }
-    return { supported: true, reason: null };
-}
-function assertionObservationAuthorityIssues(check, assertionKey, machineClosing, admitted) {
-    const authorities = (check.observation_authorities ?? []).filter((authority) => authority.assertion_ref === assertionKey);
-    if (!authorities.length)
-        return machineClosing
-            ? [
-                {
-                    obligation_ref: null,
-                    authority: null,
-                    reason: "machine_observer_not_admitted",
-                },
-            ]
-            : [];
-    const issues = [];
-    for (const authority of authorities) {
-        let reason = null;
-        if (authority.authority === "external_confirmation")
-            reason = "unsupported_observer_requires_external_confirmation";
-        else if (!admitted)
-            reason = "admitted_observation_runtime_required";
-        else {
-            const authorityKey = admittedObservationAuthorityKey(authority);
-            const prepared = admitted.by_authority_key.get(authorityKey);
-            reason =
-                prepared?.reason ??
-                    (prepared?.observation ? null : "admitted_observation_missing");
-        }
-        if (reason)
-            issues.push({
-                obligation_ref: authority.obligation_ref,
-                authority: authority.authority,
-                reason,
-            });
-    }
-    return issues;
-}
-function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, findings) {
-    const pathOwners = new Map();
-    const digestOwners = new Map();
-    for (const record of records) {
-        if (record.capability === "design_symbolic_certificate") {
-            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-certificate:${record.design_target_ref}`, record.artifact_path, artifactHashes);
-            continue;
-        }
-        if (record.capability !== "design_method")
-            continue;
-        if ("fact_model" in record) {
-            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:observation`, record.observation_artifact_path, artifactHashes);
-            addDistinctArtifact(check, findings, pathOwners, digestOwners, record.assertion_key, `symbolic-method:${record.design_target_ref}:${record.method}:comparison`, record.artifact_path, artifactHashes);
-            continue;
-        }
-        for (const cell of record.cells) {
-            const currentOwner = `${record.method}:${cell.condition_key}`;
-            const pathOwner = pathOwners.get(cell.observation_artifact_path);
-            if (pathOwner)
-                findings.push(reusedDesignMethodArtifactFinding(check, record.assertion_key, currentOwner, pathOwner, "path", cell.observation_artifact_path));
-            else
-                pathOwners.set(cell.observation_artifact_path, currentOwner);
-            const digest = artifactHashes[cell.observation_artifact_path];
-            if (!digest)
-                continue;
-            const digestOwner = digestOwners.get(digest);
-            if (digestOwner)
-                findings.push(reusedDesignMethodArtifactFinding(check, record.assertion_key, currentOwner, digestOwner, "sha256", digest));
-            else
-                digestOwners.set(digest, currentOwner);
-        }
-    }
-}
-function addDistinctArtifact(check, findings, pathOwners, digestOwners, assertionKey, currentOwner, path, artifactHashes) {
-    const pathOwner = pathOwners.get(path);
-    if (pathOwner)
-        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, pathOwner, "path", path));
-    else
-        pathOwners.set(path, currentOwner);
-    const digest = artifactHashes[path];
-    if (!digest)
-        return;
-    const digestOwner = digestOwners.get(digest);
-    if (digestOwner)
-        findings.push(reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, digestOwner, "sha256", digest));
-    else
-        digestOwners.set(digest, currentOwner);
-}
-function reusedDesignMethodArtifactFinding(check, assertionKey, currentOwner, previousOwner, identityKind, identity) {
-    return {
-        ...checkFinding(check, "design_method_evidence_reused", `Design-method evidence ${identityKind} ${identity} is reused by ${previousOwner} and ${currentOwner}.`, "Emit method-and-condition evidence whose path and current content digest are both distinct for every verification-method cell."),
-        assertion_key: assertionKey,
-        expected: "distinct_method_condition_artifact_path_and_content",
-        actual: { identity_kind: identityKind, identity },
-    };
-}
-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

@@ -1,5 +0,0 @@
-import type { CompiledCheckV2, EvidenceCapabilityRecordV2, HostExecutionAttestationV2 } from "./long-task-delivery-types.js";
-import { evaluateExactDigestComparison, exactComparisonResultIdentity } from "./long-task-exact-comparison.js";
-import { type PreparedAdmittedObservationSet } from "./long-task-admitted-observation.js";
-export { evaluateExactDigestComparison, exactComparisonResultIdentity };
-export declare function validateRuntimeEvidenceRecord(check: CompiledCheckV2, record: EvidenceCapabilityRecordV2, artifactHashes: Record<string, string>, admittedObservations?: PreparedAdmittedObservationSet, hostAttestation?: HostExecutionAttestationV2 | null): string | null;