project-tiny-context-harness 0.8.1 → 0.8.3

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

@@ -5,6 +5,16 @@ export type CounterfactualMutationV2 = {
     type: "replace_file";
     path: string;
     fixture_path: string;
+} | {
+    type: "replace_json_value";
+    path: string;
+    pointer: string;
+    value: unknown;
+} | {
+    type: "replace_text";
+    path: string;
+    match: string;
+    replacement: string;
 };
 export interface CounterfactualControlV2 {
     key: string;
@@ -13,6 +23,7 @@ export interface CounterfactualControlV2 {
     check_key: string;
     mutation: CounterfactualMutationV2;
     expected_assertion_failures: string[];
+    preserved_assertions: string[];
 }
 export interface GlobalCounterfactualControlV2 {
     key: string;
@@ -21,4 +32,5 @@ export interface GlobalCounterfactualControlV2 {
     check_key: string;
     mutation: CounterfactualMutationV2;
     expected_assertion_failures: string[];
+    preserved_assertions: string[];
 }

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

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

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

@@ -4,6 +4,7 @@ import { assertRepositoryPattern, matchesRepoPattern, proveRepositoryPatternSubs
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
+import { mutateSemanticText } from "./long-task-semantic-mutation.js";
 export function validateVerificationInputSeparation(contract, checks, workdirRelative) {
     const implementation = contract.outcomes.flatMap((outcome) => [
         ...outcome.technical.expected_change_paths,
@@ -133,12 +134,35 @@ async function validateScopeCounterfactualPaths(options) {
             !(await stat(target).catch(() => null)))
             throw new Error(`counterfactual_path_not_found:${options.scope}:${relative}`);
     }
+    if (options.mutation.type === "replace_json_value" ||
+        options.mutation.type === "replace_text") {
+        const replacementTarget = resolveInsideRepository(options.repository, options.mutation.path, `${options.scope}.counterfactual.path`);
+        if (!(await stat(replacementTarget).catch(() => null)))
+            return;
+        try {
+            mutateSemanticText(await readFile(replacementTarget, "utf8"), options.mutation, false);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`counterfactual_semantic_mutation_invalid:${options.scope}:${options.controlKey}:${message}`);
+        }
+        return;
+    }
     if (options.mutation.type !== "replace_file")
         return;
     const fixtureTarget = resolveInsideRepository(options.repository, options.mutation.fixture_path, `${options.scope}.counterfactual.fixture`);
     const fixture = repoRelative(options.repository, await assertProtectedRepositoryFile(options.repository, fixtureTarget, `${options.scope}.counterfactual.fixture`));
     if (!Object.hasOwn(options.check.verification_input_hashes, fixture))
         throw new Error(`counterfactual_fixture_must_be_verification_input:${options.scope}:${fixture}`);
+    const replacementTarget = resolveInsideRepository(options.repository, options.mutation.path, `${options.scope}.counterfactual.path`);
+    if (await stat(replacementTarget).catch(() => null)) {
+        const [fixtureBytes, targetBytes] = await Promise.all([
+            readFile(fixtureTarget),
+            readFile(replacementTarget),
+        ]);
+        if (fixtureBytes.equals(targetBytes))
+            throw new Error(`counterfactual_replacement_must_change_carrier:${options.scope}:${options.controlKey}`);
+    }
 }
 export async function hashDeclaredFiles(repository, files, label) {
     const result = {};

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

@@ -1,4 +1,5 @@
 export * from "./long-task-acceptance-shape.js";
+export * from "./long-task-applicability-shape.js";
 export * from "./long-task-product-shape.js";
 export * from "./long-task-shape-primitives.js";
 export * from "./long-task-source-shape.js";

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

@@ -1,4 +1,5 @@
 export * from "./long-task-acceptance-shape.js";
+export * from "./long-task-applicability-shape.js";
 export * from "./long-task-product-shape.js";
 export * from "./long-task-shape-primitives.js";
 export * from "./long-task-source-shape.js";

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

@@ -1,4 +1,5 @@
 export * from "./long-task-contract-types.js";
+export * from "./long-task-control-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";

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

@@ -1,4 +1,5 @@
 export * from "./long-task-contract-types.js";
+export * from "./long-task-control-types.js";
 export * from "./long-task-counterfactual-types.js";
 export * from "./long-task-authority-types.js";
 export * from "./long-task-evidence-adapter-types.js";

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

@@ -8,9 +8,12 @@ import { validateEvidenceCapabilityDeclarations } from "./long-task-evidence-cap
 import { validateDeliveryStages } from "./long-task-stage-policy.js";
 import { validateExecutionTargets, validateExternalConfirmationImpacts, } from "./long-task-target-policy.js";
 import { validateUiSurfaceBindings } from "./long-task-ui-surface-policy.js";
+import { controlFieldFacts } from "./long-task-control-fields.js";
+import { validateSemanticAssuranceShape } from "./long-task-semantic-assurance-policy.js";
 export function validateDeliveryContractStructure(contract) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
+    validateControlClosure(contract);
     validateOwnerAndBindings(contract);
     validateDeclaredCheckSafety(contract);
     validateEvidenceAdapters(contract);
@@ -22,6 +25,7 @@ export function validateDeliveryContractStructure(contract) {
     assertCompiledClaimsCovered(claims);
     validateDeliveryStages(contract);
     validateExecutionTargets(contract);
+    validateSemanticAssuranceShape(contract);
     validateEvidenceCapabilityDeclarations(contract);
     validateExternalConfirmationImpacts(contract, claims);
 }
@@ -30,8 +34,10 @@ export function deliveryContractStructureDiagnostics(contract) {
     const report = (message) => diagnostics.push(message);
     validateUniqueKeys(contract, report);
     validateDependencies(contract, report);
+    validateControlClosure(contract, report);
     validateDeliveryStages(contract, report);
     validateExecutionTargets(contract, report);
+    validateSemanticAssuranceShape(contract, report);
     validateEvidenceCapabilityDeclarations(contract, report);
     validateOwnerAndBindings(contract, report);
     validateDeclaredCheckSafety(contract, report);
@@ -73,6 +79,7 @@ function validateUniqueKeys(contract, report) {
         unique(outcome.acceptance.checks.map((check) => check.key), `check_key_duplicate:${outcome.key}`, report);
         unique(outcome.product.requirements.map((item) => item.key), `requirement_key_duplicate:${outcome.key}`, report);
         unique(outcome.product.controls.map((control) => control.key), `control_key_duplicate:${outcome.key}`, report);
+        unique(outcome.product.control_relations.map((relation) => relation.key), `control_relation_key_duplicate:${outcome.key}`, report);
         unique(outcome.product.non_completing_outcomes.map((item) => item.key), `non_completing_key_duplicate:${outcome.key}`, report);
         unique(outcome.technical.obligations.map((item) => item.key), `obligation_key_duplicate:${outcome.key}`, report);
         unique(outcome.technical.forbidden_shortcuts.map((item) => item.key), `forbidden_shortcut_key_duplicate:${outcome.key}`, report);
@@ -87,6 +94,45 @@ function validateUniqueKeys(contract, report) {
     for (const check of contract.global.acceptance.checks)
         unique([...check.positive_assertions, ...check.negative_assertions].map((assertion) => assertion.observation), `assertion_observation_duplicate:GLOBAL:${check.key}`, report);
 }
+function validateControlClosure(contract, report) {
+    for (const outcome of contract.outcomes) {
+        const controls = new Set(outcome.product.controls.map((control) => control.key));
+        const closure = outcome.product.control_relation_closure;
+        const relations = outcome.product.control_relations;
+        if (closure.state === "unresolved")
+            issue(report, "control_relation_closure_unresolved", outcome.key);
+        if (closure.state === "specified" && !relations.length)
+            issue(report, "control_relation_required", outcome.key);
+        if (closure.state === "not_applicable" && relations.length)
+            issue(report, "control_relation_forbidden_when_not_applicable", outcome.key);
+        if (!controls.size && closure.state !== "not_applicable")
+            issue(report, "control_relation_closure_without_controls", outcome.key);
+        for (const control of outcome.product.controls) {
+            const facts = controlFieldFacts(control);
+            const unresolved = facts
+                .filter((fact) => fact.state === "unresolved")
+                .map((fact) => fact.contract_field);
+            if (unresolved.length)
+                issue(report, "control_field_unresolved", `${outcome.key}:${control.key}:${unresolved.join(",")}`);
+            if (!facts.some((fact) => [
+                "navigation_result",
+                "interaction",
+                "trigger",
+                "location",
+            ].includes(fact.contract_field) && fact.state === "specified"))
+                issue(report, "control_root_behavior_required", `${outcome.key}:${control.key}`);
+        }
+        for (const relation of relations) {
+            if (relation.control_refs.length < 2)
+                issue(report, "control_relation_control_refs_required", `${outcome.key}:${relation.key}`);
+            if (new Set(relation.control_refs).size !== relation.control_refs.length)
+                issue(report, "control_relation_control_ref_duplicate", `${outcome.key}:${relation.key}`);
+            for (const reference of relation.control_refs)
+                if (!controls.has(reference))
+                    issue(report, "control_relation_control_ref_unknown", `${outcome.key}:${relation.key}:${reference}`);
+        }
+    }
+}
 function validateOwnerAndBindings(contract, report) {
     const contextRefs = new Set(contract.task.context_refs);
     for (const outcome of contract.outcomes) {

package/dist/lib/long-task-design-resource-handoff.js

@@ -18,6 +18,7 @@ export async function validateLongTaskDesignResourceHandoffs(contract, repositor
             invalid("target_handoff_missing", contractTarget.target.key);
         consumed.add(contractTarget.target.key);
         validateTargetIdentity(contractTarget, indexedTarget);
+        validateTargetCapabilities(contract, contractTarget, indexedTarget);
         validateCoverageClaims(contract, contractTarget, indexedTarget);
         validateBlockerBindings(contract, contractTarget, indexedTarget);
     }
@@ -62,21 +63,20 @@ function validateCoverageClaims(contract, contractTarget, indexed) {
     const check = contract.outcomes
         .find((item) => item.key === contractTarget.outcome_key)
         .acceptance.checks.find((item) => item.key === target.conformance_check_ref);
-    const assertion = check.positive_assertions.find((item) => item.key === target.conformance_assertion_ref);
     const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
     const rows = indexed.preflight.handoff.coverage.filter((row) => row.disposition === "covered" && row.target_refs.includes(target.key));
     if (!rows.length)
         invalid("target_covered_claims_required", target.key);
+    const facts = indexed.preflight.handoff.facts.filter((fact) => fact.target_ref === target.key);
+    if (!facts.length)
+        invalid("target_facts_required", target.key);
     const claimsBySourceItem = new Map();
     for (const row of rows)
         for (const sourceItemRef of row.source_item_refs) {
             const localClaims = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
             claimsBySourceItem.set(sourceItemRef, localClaims);
-            for (const localClaimRef of localClaims)
-                if (!assertion.claims.includes(localClaimRef))
-                    invalid("coverage_claim_not_in_conformance_assertion", `${target.key}:${sourceItemRef}:${localClaimRef}`);
         }
-    validateVerificationMethodBindings(target, check, rows, claimsBySourceItem);
+    validateVerificationMethodBindings(target, check, facts, claimsBySourceItem);
 }
 function validateBlockerBindings(contract, contractTarget, indexed) {
     const bound = new Map(contractTarget.binding.acceptance_blockers.map((item) => [item.key, item]));
@@ -94,6 +94,7 @@ function validateBlockerBindings(contract, contractTarget, indexed) {
             invalid("acceptance_blocker_unbound", `${contractTarget.target.key}:${blocker.key}`);
         assertSameSet(contractBlocker.source_item_refs, blocker.source_item_refs, "acceptance_blocker_source_items_mismatch", blocker.key);
         assertSameSet(contractBlocker.verification_methods, blocker.verification_methods, "acceptance_blocker_methods_mismatch", blocker.key);
+        assertSameSet(contractBlocker.required_capabilities, blocker.required_capabilities, "acceptance_blocker_capabilities_mismatch", blocker.key);
         for (const method of blocker.verification_methods)
             if (!availableMethods.has(method))
                 invalid("acceptance_blocker_method_unbound", `${blocker.key}:${method}`);
@@ -102,6 +103,12 @@ function validateBlockerBindings(contract, contractTarget, indexed) {
             return local.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`);
         });
         if (contractBlocker.status === "machine_claim") {
+            const executionTarget = contract.task.execution_targets.find((item) => item.key === contractTarget.binding.target_ref);
+            if (!executionTarget)
+                invalid("execution_target_unknown", `${contractTarget.target.key}:${contractTarget.binding.target_ref}`);
+            for (const capability of blocker.required_capabilities)
+                if (!executionTarget.capabilities.includes(capability))
+                    invalid("acceptance_blocker_target_capability_missing", `${blocker.key}:${executionTarget.key}:${capability}`);
             const expectedLocal = fullClaimRefs.map((claimRef) => claimRef.slice(contractTarget.outcome_key.length + 1));
             for (const claimRef of expectedLocal)
                 if (!contractBlocker.refs.includes(claimRef))
@@ -133,8 +140,8 @@ function designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef
         return claimRef.slice(prefix.length);
     });
 }
-function validateVerificationMethodBindings(target, check, rows, claimsBySourceItem) {
-    const expectedMethods = new Set(rows.flatMap((row) => row.verification_methods));
+function validateVerificationMethodBindings(target, check, facts, claimsBySourceItem) {
+    const expectedMethods = new Set(facts.map((fact) => fact.verification_method));
     const bindings = target.verification_method_bindings;
     assertSameSet(bindings.map((item) => item.method), [...expectedMethods], "verification_methods_mismatch", target.key);
     const assertionRefs = bindings.map((item) => item.assertion_ref);
@@ -142,13 +149,14 @@ function validateVerificationMethodBindings(target, check, rows, claimsBySourceI
         invalid("verification_method_assertion_duplicate", target.key);
     if (assertionRefs.includes(target.conformance_assertion_ref))
         invalid("verification_method_assertion_must_be_independent", target.key);
+    const boundFactRefs = [];
     for (const binding of bindings) {
         const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
         if (!assertion)
             invalid("verification_method_assertion_unknown", `${target.key}:${binding.method}:${binding.assertion_ref}`);
-        const sourceItems = new Set(rows
-            .filter((row) => row.verification_methods.includes(binding.method))
-            .flatMap((row) => row.source_item_refs));
+        const sourceItems = new Set(facts
+            .filter((fact) => fact.verification_method === binding.method)
+            .flatMap((fact) => fact.source_item_refs));
         for (const sourceItemRef of sourceItems)
             for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
                 if (!assertion.claims.includes(claimRef))
@@ -156,14 +164,60 @@ function validateVerificationMethodBindings(target, check, rows, claimsBySourceI
         for (const capability of requiredCapabilities(binding.method))
             if (!assertion.evidence_capabilities.includes(capability))
                 invalid("verification_method_capability_required", `${target.key}:${binding.method}:${capability}`);
+        assertSameSet(binding.evidence_artifacts.map((item) => item.condition_key), target.condition_keys, "verification_method_evidence_conditions_mismatch", `${target.key}:${binding.method}`);
+        for (const artifact of binding.evidence_artifacts) {
+            const expectedFactRefs = facts
+                .filter((fact) => fact.verification_method === binding.method &&
+                fact.condition_ref === artifact.condition_key)
+                .map((fact) => fact.key);
+            assertSameSet(artifact.fact_refs, expectedFactRefs, "design_method_fact_refs_mismatch", `${target.key}:${binding.method}:${artifact.condition_key}`);
+            boundFactRefs.push(...artifact.fact_refs);
+        }
     }
+    assertSameSet(boundFactRefs, facts.map((fact) => fact.key), "design_method_fact_refs_mismatch", target.key);
 }
 function requiredCapabilities(method) {
     if (method === "interaction_trace")
-        return ["interaction_trace", "target_runtime"];
+        return ["design_method", "interaction_trace", "target_runtime"];
     if (method === "component_state")
-        return ["design_conformance", "interaction_trace", "target_runtime"];
-    return ["design_conformance", "target_runtime"];
+        return [
+            "design_method",
+            "design_conformance",
+            "interaction_trace",
+            "target_runtime",
+        ];
+    return ["design_method", "design_conformance", "target_runtime"];
+}
+function validateTargetCapabilities(contract, contractTarget, indexed) {
+    const executionTarget = contract.task.execution_targets.find((item) => item.key === contractTarget.binding.target_ref);
+    if (!executionTarget)
+        invalid("execution_target_unknown", `${contractTarget.target.key}:${contractTarget.binding.target_ref}`);
+    const required = new Set();
+    for (const method of contractTarget.target.verification_method_bindings.map((item) => item.method)) {
+        if (method === "responsive_reflow")
+            required.add("viewport-control");
+        if (method === "motion_timeline")
+            required.add("motion-observation");
+        if (method === "accessibility_semantics")
+            required.add("assistive-technology");
+    }
+    for (const conditionRef of indexed.target.condition_refs) {
+        const condition = indexed.preflight.handoff.conditions.find((item) => item.key === conditionRef);
+        const input = condition.input_methods[0].toLowerCase();
+        if (["mouse", "pointer", "trackpad"].includes(input))
+            required.add("pointer-input");
+        if (input === "keyboard")
+            required.add("keyboard-input");
+        if (["touch", "pen", "stylus"].includes(input))
+            required.add("touch-input");
+        if (["screen-reader", "voice-control", "switch-control"].includes(input))
+            required.add("assistive-technology");
+        if (condition.motion === "reduced")
+            required.add("reduced-motion");
+    }
+    for (const capability of required)
+        if (!executionTarget.capabilities.includes(capability))
+            invalid("execution_target_capability_missing", `${contractTarget.target.key}:${executionTarget.key}:${capability}`);
 }
 function assertSameSet(actual, expected, code, detail) {
     const left = [...new Set(actual)].sort();

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

@@ -1,3 +1,4 @@
+import { DESIGN_RESOURCE_VERIFICATION_METHODS } from "./design-resource-handoff-types.js";
 export function decodeEvidenceCapabilityRecords(value) {
     if (!Array.isArray(value))
         throw invalidRecord("must_be_array");
@@ -179,6 +180,38 @@ function decodeRecord(value, index) {
                 session_id: nonEmpty(row.session_id, `${label}.session_id`),
                 cold_start: row.cold_start,
             };
+        case "design_method":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "design_target_ref",
+                "target_ref",
+                "method",
+                "cells",
+            ]);
+            return {
+                ...base,
+                capability,
+                design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                method: literal(row.method, DESIGN_RESOURCE_VERIFICATION_METHODS, `${label}.method`),
+                cells: array(row.cells, `${label}.cells`).map((item, cellIndex) => {
+                    const cellLabel = `${label}.cells[${cellIndex}]`;
+                    const cell = record(item, cellLabel);
+                    exact(cell, cellLabel, [
+                        "condition_key",
+                        "artifact_path",
+                        "observation_artifact_path",
+                        "fact_refs",
+                    ]);
+                    return {
+                        condition_key: key(cell.condition_key, `${cellLabel}.condition_key`),
+                        artifact_path: nonEmpty(cell.artifact_path, `${cellLabel}.artifact_path`),
+                        observation_artifact_path: nonEmpty(cell.observation_artifact_path, `${cellLabel}.observation_artifact_path`),
+                        fact_refs: designFactRefs(cell.fact_refs, `${cellLabel}.fact_refs`),
+                    };
+                }),
+            };
         case "input_variation":
             exact(row, label, [
                 "assertion_key",
@@ -242,9 +275,23 @@ function strings(value, label) {
 function keys(value, label) {
     return array(value, label).map((item, index) => key(item, `${label}[${index}]`));
 }
+function designFactRefs(value, label) {
+    return array(value, label).map((item, index) => {
+        const result = nonEmpty(item, `${label}[${index}]`);
+        if (!/^[a-z0-9][a-z0-9._-]*$/u.test(result))
+            throw invalidRecord(`${label}[${index}]`);
+        return result;
+    });
+}
 function sha(value, label) {
     const result = nonEmpty(value, label);
     if (!/^[a-f0-9]{64}$/u.test(result))
         throw invalidRecord(label);
     return result;
 }
+function literal(value, allowed, label) {
+    const result = nonEmpty(value, label);
+    if (!allowed.includes(result))
+        throw invalidRecord(label);
+    return result;
+}

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

@@ -4,47 +4,56 @@ export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability
 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("design_conformance") &&
-                !check.artifact_globs.length)
-                issue(report, "design_conformance_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 !== "design_conformance" &&
-                    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);
-        }
+        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);
+    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("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 !== "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)
@@ -127,8 +136,41 @@ export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
         }
         complete[assertion.key] = assertionComplete;
     }
+    validateDistinctDesignMethodArtifacts(check, runtimeRecords, artifactHashes, findings);
     return { complete, findings };
 }
+function validateDistinctDesignMethodArtifacts(check, records, artifactHashes, findings) {
+    const pathOwners = new Map();
+    const digestOwners = new Map();
+    for (const record of records) {
+        if (record.capability !== "design_method")
+            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 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]),

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

@@ -27,12 +27,51 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
                 : "artifact_hash_mismatch";
         case "design_conformance":
             return validateDesignConformance(check, record, artifactHashes);
+        case "design_method":
+            return validateDesignMethod(check, record, artifactHashes);
         case "target_runtime":
             return validateTargetRuntime(check, record);
         case "input_variation":
             return validateInputVariation(record);
     }
 }
+function validateDesignMethod(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));
+    if (!target)
+        return "design_method_binding_unknown";
+    if (target.target_ref !== record.target_ref ||
+        target.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    const binding = target.verification_method_bindings.find((item) => item.assertion_ref === record.assertion_key &&
+        item.method === record.method);
+    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) => [
+        item.condition_key,
+        {
+            artifact_path: item.path,
+            observation_artifact_path: item.observation_path,
+            fact_refs: item.fact_refs,
+        },
+    ]));
+    if (record.cells.length !== expected.size)
+        return "design_method_cell_count_mismatch";
+    for (const cell of record.cells) {
+        const expectedCell = expected.get(cell.condition_key);
+        if (expectedCell?.artifact_path !== cell.artifact_path ||
+            expectedCell?.observation_artifact_path !== cell.observation_artifact_path)
+            return "design_method_artifact_path_mismatch";
+        if (!same([...cell.fact_refs].sort(), [...(expectedCell?.fact_refs ?? [])].sort()))
+            return "design_method_fact_refs_mismatch";
+        if (!artifactHashes[cell.artifact_path])
+            return "design_method_artifact_missing";
+        if (!artifactHashes[cell.observation_artifact_path])
+            return "design_method_observation_artifact_missing";
+    }
+    return null;
+}
 function validateDesignConformance(check, record, artifactHashes) {
     const target = (check.design_conformance_targets ?? []).find((item) => item.key === record.design_target_ref &&
         designTargetUsesAssertion(item, record.assertion_key));

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

@@ -1,4 +1,5 @@
 import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
+import type { DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 interface EvidenceRecordBaseV2 {
     assertion_key: string;
     capability: EvidenceCapabilityV2;
@@ -70,6 +71,18 @@ export interface TargetRuntimeEvidenceV2 extends EvidenceRecordBaseV2 {
     session_id: string;
     cold_start: boolean;
 }
+export interface DesignMethodEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "design_method";
+    design_target_ref: string;
+    target_ref: string;
+    method: DesignResourceVerificationMethod;
+    cells: Array<{
+        condition_key: string;
+        artifact_path: string;
+        observation_artifact_path: string;
+        fact_refs: string[];
+    }>;
+}
 export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     capability: "input_variation";
     cases: Array<{
@@ -78,5 +91,5 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | DesignMethodEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
 export {};

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

@@ -18,6 +18,9 @@ export function evaluateAssertionResults(check, observations) {
             polarity,
             passed: evaluation.passed,
             claims: assertion.claims,
+            ...(assertion.applicability_ref
+                ? { applicability_ref: assertion.applicability_ref }
+                : {}),
             observation: assertion.observation,
             evidence_capabilities: assertion.evidence_capabilities,
             evidence_complete: false,