project-tiny-context-harness 0.7.8 → 0.8.0

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

@@ -9,7 +9,8 @@ import { assertRiskNotDowngraded, buildAuthorityRevisionProposal, enforceAuthori
 import { validateActualRiskSurfaces } from "./long-task-risk-surfaces.js";
 import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
 import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
-import { changedWorkspacePaths, currentGitTree, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+import { changedWorkspacePaths, changedWorkspacePathsFromHead, currentGitTree, repoRelative, repositoryRoot, } from "./long-task-workspace.js";
+import { assertWorkspaceScope, classifyWorkspaceScope, firstLockManagedWorkspacePaths, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
 export async function compileDeliveryContract(workdirInput, projectRootInput = process.cwd(), options = {}) {
     const repository = await repositoryRoot(projectRootInput);
     const workdir = path.resolve(workdirInput);
@@ -35,18 +36,38 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
     const current = validation.workspace;
     const globalChecks = validation.global_checks;
     const outcomes = validation.outcomes;
+    const contractFiles = Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
+        repoRelative(repository, path.join(workdir, ...relative.split("/"))),
+        hash,
+    ]));
     const contractHash = sha256Hex(canonicalValueJson(contract));
     const authorityMaterials = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
     const previous = options.live_gate
         ? null
         : (options.previous_authority ?? null);
-    const initialTaskBase = options.initial_task_base ??
-        previous?.initial_task_base ?? {
+    const existingInitialTaskBase = options.initial_task_base ?? previous?.initial_task_base ?? null;
+    const changedPaths = existingInitialTaskBase
+        ? changedWorkspacePaths(existingInitialTaskBase.workspace_manifest, current)
+        : await changedWorkspacePathsFromHead(repository, workdir);
+    const firstLockManagedPaths = existingInitialTaskBase
+        ? []
+        : await firstLockManagedWorkspacePaths(repository, changedPaths);
+    assertWorkspaceScope(classifyWorkspaceScope(contract, changedPaths, protectedWorkspacePaths({
+        contract_files: contractFiles,
+        source_hashes: sourceHashes,
+        context_hashes: context.sha256,
+        checks: [
+            ...globalChecks,
+            ...outcomes.flatMap((outcome) => outcome.acceptance.checks),
+        ],
+        additional_files: firstLockManagedPaths,
+    })));
+    const initialTaskBase = existingInitialTaskBase ?? {
         git_commit: current.git_head,
         git_tree: await currentGitTree(repository),
         workspace_manifest: current,
     };
-    await validateActualRiskSurfaces(repository, changedWorkspacePaths(initialTaskBase.workspace_manifest, current), contract);
+    await validateActualRiskSurfaces(repository, changedPaths, contract);
     const verifier = await captureVerifierIdentity(repository, options.require_completion_gate !== false);
     const allChecks = [
         ...globalChecks,
@@ -95,10 +116,7 @@ export async function compileDeliveryContract(workdirInput, projectRootInput = p
         workdir,
         contract_file: repoRelative(repository, contractFile),
         contract_sha256: contractHash,
-        contract_files: Object.fromEntries(Object.entries(parsed.contract_files).map(([relative, hash]) => [
-            repoRelative(repository, path.join(workdir, ...relative.split("/"))),
-            hash,
-        ])),
+        contract_files: contractFiles,
         source_hashes: sourceHashes,
         source_items: sourceItems,
         context_snapshot: normalizeContextAuthoritySnapshot(context),

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

@@ -6,5 +6,6 @@ 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-ui-surface-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

@@ -6,5 +6,6 @@ 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-ui-surface-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

@@ -7,6 +7,7 @@ import { validateEvidenceAdapterCompatibility } from "./long-task-evidence-adapt
 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";
+import { validateUiSurfaceBindings } from "./long-task-ui-surface-policy.js";
 export function validateDeliveryContractStructure(contract) {
     validateUniqueKeys(contract);
     validateDependencies(contract);
@@ -17,6 +18,7 @@ export function validateDeliveryContractStructure(contract) {
         allow_uncovered: true,
     });
     validateSourceClaimMappings(contract, claims);
+    validateUiSurfaceBindings(contract, claims);
     assertCompiledClaimsCovered(claims);
     validateDeliveryStages(contract);
     validateExecutionTargets(contract);
@@ -40,6 +42,7 @@ export function deliveryContractStructureDiagnostics(contract) {
     });
     if (claims) {
         validateSourceClaimMappings(contract, claims, report);
+        validateUiSurfaceBindings(contract, claims, report);
         validateExternalConfirmationImpacts(contract, claims, report);
         capture(diagnostics, () => assertCompiledClaimsCovered(claims));
     }

package/dist/lib/long-task-design-resource-handoff.d.ts

@@ -0,0 +1,2 @@
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+export declare function validateLongTaskDesignResourceHandoffs(contract: DeliveryContractV2, repository: string): Promise<void>;

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

@@ -0,0 +1,177 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { containsDesignResourceHandoff } from "./design-resource-handoff-parser.js";
+import { preflightDesignResourceHandoff } from "./design-resource-handoff-validation.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+export async function validateLongTaskDesignResourceHandoffs(contract, repository) {
+    const handoffs = await loadHandoffs(contract, repository);
+    const indexed = indexHandoffTargets(handoffs);
+    const contractTargets = contract.outcomes.flatMap((outcome) => outcome.product.surface_bindings.flatMap((binding) => binding.design_targets.map((target) => ({
+        outcome_key: outcome.key,
+        binding,
+        target,
+    }))));
+    const consumed = new Set();
+    for (const contractTarget of contractTargets) {
+        const indexedTarget = indexed.get(contractTarget.target.key);
+        if (!indexedTarget)
+            invalid("target_handoff_missing", contractTarget.target.key);
+        consumed.add(contractTarget.target.key);
+        validateTargetIdentity(contractTarget, indexedTarget);
+        validateCoverageClaims(contract, contractTarget, indexedTarget);
+        validateBlockerBindings(contract, contractTarget, indexedTarget);
+    }
+    for (const key of indexed.keys())
+        if (!consumed.has(key))
+            invalid("handoff_target_unbound", key);
+}
+async function loadHandoffs(contract, repository) {
+    const results = [];
+    for (const sourcePath of contract.task.source_paths) {
+        if (!sourcePath.toLowerCase().endsWith(".md"))
+            continue;
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...sourcePath.split("/")), `design_resource_handoff_source:${sourcePath}`);
+        const content = await readFile(file, "utf8");
+        if (containsDesignResourceHandoff(content))
+            results.push(await preflightDesignResourceHandoff(repository, sourcePath));
+    }
+    return results;
+}
+function indexHandoffTargets(handoffs) {
+    const indexed = new Map();
+    for (const preflight of handoffs)
+        for (const target of preflight.handoff.targets) {
+            if (indexed.has(target.key))
+                invalid("handoff_target_duplicate", target.key);
+            indexed.set(target.key, { preflight, target });
+        }
+    return indexed;
+}
+function validateTargetIdentity(contractTarget, indexed) {
+    const { target } = contractTarget;
+    const handoffTarget = indexed.target;
+    if (target.interpretation !== handoffTarget.interpretation)
+        invalid("target_interpretation_mismatch", `${target.key}:${target.interpretation}:${handoffTarget.interpretation}`);
+    assertSameSet(target.condition_keys, handoffTarget.condition_refs, "target_conditions_mismatch", target.key);
+    const resourcePaths = handoffTarget.resource_refs.map((ref) => indexed.preflight.handoff.resources.find((item) => item.key === ref)
+        .path);
+    assertSameSet(target.source_paths, [indexed.preflight.handoff_path, ...resourcePaths], "target_source_paths_mismatch", target.key);
+}
+function validateCoverageClaims(contract, contractTarget, indexed) {
+    const target = contractTarget.target;
+    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 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);
+}
+function validateBlockerBindings(contract, contractTarget, indexed) {
+    const bound = new Map(contractTarget.binding.acceptance_blockers.map((item) => [item.key, item]));
+    const claims = new Map(contract.source_claims.map((item) => [item.key, item]));
+    const confirmations = new Map(contract.global.acceptance.external_confirmations.map((item) => [
+        item.key,
+        item,
+    ]));
+    const availableMethods = new Set(contractTarget.target.verification_method_bindings.map((item) => item.method));
+    for (const blocker of indexed.preflight.handoff.acceptance_blockers) {
+        if (!blocker.target_refs.includes(contractTarget.target.key))
+            continue;
+        const contractBlocker = bound.get(blocker.key);
+        if (!contractBlocker)
+            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);
+        for (const method of blocker.verification_methods)
+            if (!availableMethods.has(method))
+                invalid("acceptance_blocker_method_unbound", `${blocker.key}:${method}`);
+        const fullClaimRefs = blocker.source_item_refs.flatMap((sourceItemRef) => {
+            const local = designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims);
+            return local.map((claimRef) => `${contractTarget.outcome_key}.${claimRef}`);
+        });
+        if (contractBlocker.status === "machine_claim") {
+            const expectedLocal = fullClaimRefs.map((claimRef) => claimRef.slice(contractTarget.outcome_key.length + 1));
+            for (const claimRef of expectedLocal)
+                if (!contractBlocker.refs.includes(claimRef))
+                    invalid("acceptance_blocker_machine_claim_lineage_missing", `${blocker.key}:${claimRef}`);
+        }
+        else
+            for (const confirmationRef of contractBlocker.refs) {
+                const confirmation = confirmations.get(confirmationRef);
+                if (!confirmation)
+                    invalid("acceptance_blocker_confirmation_unknown", `${blocker.key}:${confirmationRef}`);
+                for (const claimRef of fullClaimRefs)
+                    if (!confirmation.impact_claims.includes(claimRef))
+                        invalid("acceptance_blocker_confirmation_lineage_missing", `${blocker.key}:${confirmationRef}:${claimRef}`);
+            }
+    }
+}
+function designSourceItemClaims(contract, contractTarget, indexed, sourceItemRef, claims = new Map(contract.source_claims.map((item) => [item.key, item]))) {
+    const claim = claims.get(sourceItemRef);
+    if (!claim)
+        invalid("coverage_source_claim_unknown", `${contractTarget.target.key}:${sourceItemRef}`);
+    if (claim.source_ref.split("#")[0] !== indexed.preflight.handoff_path)
+        invalid("coverage_source_claim_file_mismatch", `${contractTarget.target.key}:${sourceItemRef}`);
+    if (claim.disposition.type !== "claim")
+        invalid("coverage_source_claim_disposition_required", `${contractTarget.target.key}:${sourceItemRef}:${claim.disposition.type}`);
+    const prefix = `${contractTarget.outcome_key}.`;
+    return claim.disposition.refs.map((claimRef) => {
+        if (!claimRef.startsWith(prefix))
+            invalid("coverage_claim_outcome_mismatch", `${contractTarget.target.key}:${sourceItemRef}:${claimRef}`);
+        return claimRef.slice(prefix.length);
+    });
+}
+function validateVerificationMethodBindings(target, check, rows, claimsBySourceItem) {
+    const expectedMethods = new Set(rows.flatMap((row) => row.verification_methods));
+    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);
+    if (new Set(assertionRefs).size !== assertionRefs.length)
+        invalid("verification_method_assertion_duplicate", target.key);
+    if (assertionRefs.includes(target.conformance_assertion_ref))
+        invalid("verification_method_assertion_must_be_independent", target.key);
+    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));
+        for (const sourceItemRef of sourceItems)
+            for (const claimRef of claimsBySourceItem.get(sourceItemRef) ?? [])
+                if (!assertion.claims.includes(claimRef))
+                    invalid("verification_method_claim_not_asserted", `${target.key}:${binding.method}:${sourceItemRef}:${claimRef}`);
+        for (const capability of requiredCapabilities(binding.method))
+            if (!assertion.evidence_capabilities.includes(capability))
+                invalid("verification_method_capability_required", `${target.key}:${binding.method}:${capability}`);
+    }
+}
+function requiredCapabilities(method) {
+    if (method === "interaction_trace")
+        return ["interaction_trace", "target_runtime"];
+    if (method === "component_state")
+        return ["design_conformance", "interaction_trace", "target_runtime"];
+    return ["design_conformance", "target_runtime"];
+}
+function assertSameSet(actual, expected, code, detail) {
+    const left = [...new Set(actual)].sort();
+    const right = [...new Set(expected)].sort();
+    if (left.length !== right.length ||
+        left.some((item, index) => item !== right[index]))
+        invalid(code, `${detail}:${left.join(",")}:${right.join(",")}`);
+}
+function invalid(code, detail) {
+    throw new Error(`delivery_contract_invalid:design_resource_${code}:${detail}`);
+}

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

@@ -141,6 +141,25 @@ function decodeRecord(value, index) {
                 artifact_path: nonEmpty(row.artifact_path, `${label}.artifact_path`),
                 artifact_sha256: sha(row.artifact_sha256, `${label}.artifact_sha256`),
             };
+        case "design_conformance":
+            exact(row, label, [
+                "assertion_key",
+                "capability",
+                "design_target_ref",
+                "target_ref",
+                "condition_keys",
+                "actual_artifact_path",
+                "comparison_artifact_path",
+            ]);
+            return {
+                ...base,
+                capability,
+                design_target_ref: key(row.design_target_ref, `${label}.design_target_ref`),
+                target_ref: key(row.target_ref, `${label}.target_ref`),
+                condition_keys: keys(row.condition_keys, `${label}.condition_keys`),
+                actual_artifact_path: nonEmpty(row.actual_artifact_path, `${label}.actual_artifact_path`),
+                comparison_artifact_path: nonEmpty(row.comparison_artifact_path, `${label}.comparison_artifact_path`),
+            };
         case "target_runtime":
             exact(row, label, [
                 "assertion_key",

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

@@ -26,12 +26,16 @@ export function validateEvidenceCapabilityDeclarations(contract, 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("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)) &&

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

@@ -25,12 +25,37 @@ export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
             return artifactHashes[record.artifact_path] === record.artifact_sha256
                 ? null
                 : "artifact_hash_mismatch";
+        case "design_conformance":
+            return validateDesignConformance(check, record, artifactHashes);
         case "target_runtime":
             return validateTargetRuntime(check, record);
         case "input_variation":
             return validateInputVariation(record);
     }
 }
+function validateDesignConformance(check, record, artifactHashes) {
+    const target = (check.design_conformance_targets ?? []).find((item) => item.key === record.design_target_ref &&
+        designTargetUsesAssertion(item, record.assertion_key));
+    if (!target)
+        return "design_target_unknown";
+    if (target.target_ref !== record.target_ref ||
+        target.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    if (!same([...target.condition_keys].sort(), [...record.condition_keys].sort()))
+        return "design_conditions_mismatch";
+    if (target.actual_artifact_path !== record.actual_artifact_path ||
+        target.comparison_artifact_path !== record.comparison_artifact_path)
+        return "design_artifact_path_mismatch";
+    if (!artifactHashes[record.actual_artifact_path])
+        return "actual_artifact_missing";
+    if (!artifactHashes[record.comparison_artifact_path])
+        return "comparison_artifact_missing";
+    return null;
+}
+function designTargetUsesAssertion(target, assertionKey) {
+    return (target.conformance_assertion_ref === assertionKey ||
+        target.verification_method_bindings.some((item) => item.assertion_ref === assertionKey));
+}
 function validateInteractionTrace(check, record) {
     if (record.target_ref !== check.execution_target.target_ref)
         return "target_mismatch";

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

@@ -55,6 +55,14 @@ export interface VisualRenderEvidenceV2 extends EvidenceRecordBaseV2 {
     artifact_path: string;
     artifact_sha256: string;
 }
+export interface DesignConformanceEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "design_conformance";
+    design_target_ref: string;
+    target_ref: string;
+    condition_keys: string[];
+    actual_artifact_path: string;
+    comparison_artifact_path: string;
+}
 export interface TargetRuntimeEvidenceV2 extends EvidenceRecordBaseV2 {
     capability: "target_runtime";
     target_ref: string;
@@ -70,5 +78,5 @@ export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
     }>;
     failure_case_observed: boolean;
 }
-export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | DesignConformanceEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
 export {};

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

@@ -4,6 +4,7 @@ import { parseRequirements } from "./long-task-requirement-shape.js";
 import { array, boolean, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseKeyedStatements, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
 import { parseStrictYaml } from "./strict-codec.js";
 import { assertNoSemanticDriftMigration, semanticDriftOutcomeMigrationFields, } from "./long-task-semantic-drift-migration.js";
+import { parseSurfaceBindings } from "./long-task-ui-surface-shape.js";
 export function parseOutcome(value, label) {
     assertNoSemanticDriftMigration(semanticDriftOutcomeMigrationFields(value, label));
     const row = object(value, label, ["key", "title", "stage", "product", "technical", "acceptance"], ["depends_on"]);
@@ -12,7 +13,13 @@ export function parseOutcome(value, label) {
         "success_path_required",
         "degradation_path_required",
         "owner",
-    ], ["requirements", "owner_surfaces", "controls", "non_completing_outcomes"]);
+    ], [
+        "requirements",
+        "owner_surfaces",
+        "controls",
+        "surface_bindings",
+        "non_completing_outcomes",
+    ]);
     const technical = object(row.technical, `${label}.technical`, ["expected_change_paths"], [
         "obligations",
         "allowed_support_paths",
@@ -43,6 +50,9 @@ export function parseOutcome(value, label) {
             controls: Object.hasOwn(product, "controls")
                 ? parseControls(product.controls, `${label}.product.controls`)
                 : [],
+            surface_bindings: Object.hasOwn(product, "surface_bindings")
+                ? parseSurfaceBindings(product.surface_bindings, `${label}.product.surface_bindings`)
+                : [],
             non_completing_outcomes: Object.hasOwn(product, "non_completing_outcomes")
                 ? parseKeyedStatements(product.non_completing_outcomes, `${label}.product.non_completing_outcomes`)
                 : [],

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

@@ -46,4 +46,3 @@ export declare function matchesRepoPattern(fileInput: string, patternInput: stri
 export declare function proveRepositoryPatternSubset(candidateInput: string, ownerInput: string): PatternContainment;
 export declare function classifyRepositoryPatternOverlap(leftInput: string, rightInput: string): PatternOverlap;
 export declare function repositoryPatternsMayOverlap(left: string, right: string): boolean;
-export declare function findScopeEscapes(changedPaths: string[], allowedPatterns: string[], forbiddenPatterns: string[]): string[];

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

@@ -250,10 +250,6 @@ export function classifyRepositoryPatternOverlap(leftInput, rightInput) {
 export function repositoryPatternsMayOverlap(left, right) {
     return (classifyRepositoryPatternOverlap(left, right).status !== "proven_disjoint");
 }
-export function findScopeEscapes(changedPaths, allowedPatterns, forbiddenPatterns) {
-    return changedPaths.filter((file) => forbiddenPatterns.some((pattern) => matchesRepoPattern(file, pattern)) ||
-        !allowedPatterns.some((pattern) => matchesRepoPattern(file, pattern)));
-}
 function segmentSubset(candidate, owner) {
     if (candidate.raw === owner.raw)
         return { status: "proven_subset" };

package/dist/lib/long-task-playwright-case-evidence.d.ts

@@ -0,0 +1,43 @@
+import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+export interface PlaywrightCaseInstance {
+    id: string;
+    project_id: string;
+    executed: boolean;
+    passed: boolean;
+    skipped: boolean;
+    flaky: boolean;
+    unexpected: boolean;
+    timed_out: boolean;
+    interrupted: boolean;
+    status: string;
+    given_keys: string[];
+    action_keys: string[];
+}
+export interface PlaywrightCase {
+    id: string;
+    executed: boolean;
+    passed: boolean;
+    skipped: boolean;
+    flaky: boolean;
+    unexpected: boolean;
+    status: string;
+    project_ids: string[];
+    executed_instances: number;
+    failed_instances: number;
+    skipped_instances: number;
+    flaky_instances: number;
+    unexpected_instances: number;
+    timed_out_instances: number;
+    interrupted_instances: number;
+    given_keys: string[];
+    action_keys: string[];
+}
+export declare function collectCases(report: Record<string, unknown>, declaredIds: Set<string>): {
+    cases: PlaywrightCaseInstance[];
+    unbound_unexpected_instances: number;
+    error: string | null;
+};
+export declare function declaredCaseIds(check: CompiledCheckV2): Set<string>;
+export declare function duplicateCaseInstance(values: PlaywrightCaseInstance[]): PlaywrightCaseInstance | null;
+export declare function record(value: unknown): Record<string, unknown> | null;
+export declare function same(left: string[], right: string[]): boolean;

package/dist/lib/long-task-playwright-case-evidence.js

@@ -0,0 +1,152 @@
+export function collectCases(report, declaredIds) {
+    const cases = [];
+    const collection = { unbound_unexpected_instances: 0 };
+    const error = visitSuites(report.suites, cases, declaredIds, collection);
+    return { cases, error, ...collection };
+}
+function visitSuites(value, cases, declaredIds, collection) {
+    if (!Array.isArray(value))
+        return null;
+    for (const suiteValue of value) {
+        const suite = record(suiteValue);
+        if (!suite)
+            continue;
+        const nestedError = visitSuites(suite.suites, cases, declaredIds, collection);
+        if (nestedError)
+            return nestedError;
+        if (!Array.isArray(suite.specs))
+            continue;
+        for (const specValue of suite.specs) {
+            const spec = record(specValue);
+            if (!spec || !Array.isArray(spec.tests))
+                continue;
+            for (const testValue of spec.tests) {
+                const test = record(testValue);
+                if (!test)
+                    continue;
+                const title = [spec.title, test.title]
+                    .filter((item) => typeof item === "string")
+                    .join(" ");
+                const ids = declaredIdsInTitle(title, declaredIds);
+                if (ids.length > 1)
+                    return `playwright_test_multiple_ac_ids:${ids.join(",")}`;
+                const instance = playwrightCase(ids[0] ?? "unbound", test);
+                if (ids.length === 1)
+                    cases.push(instance);
+                else if (instance.unexpected)
+                    collection.unbound_unexpected_instances += 1;
+            }
+        }
+    }
+    return null;
+}
+function declaredIdsInTitle(title, declared) {
+    const explicit = [...title.matchAll(/\[ac:([a-z0-9][a-z0-9-]*)\]/gu)].map((match) => match[1]);
+    const legacy = [...title.matchAll(/\[([a-z0-9][a-z0-9-]*)\]/gu)].map((match) => match[1]);
+    return [
+        ...new Set([...explicit, ...legacy].filter((id) => declared.has(id))),
+    ].sort();
+}
+function playwrightCase(id, test) {
+    const status = typeof test.status === "string" ? test.status : "invalid";
+    const projectId = typeof test.projectId === "string"
+        ? test.projectId
+        : typeof test.projectName === "string"
+            ? test.projectName
+            : "default";
+    const results = Array.isArray(test.results)
+        ? test.results.map(record).filter(Boolean)
+        : [];
+    const resultStatuses = results
+        .map((result) => result.status)
+        .filter((value) => typeof value === "string");
+    const skipped = status === "skipped" ||
+        (resultStatuses.length > 0 &&
+            resultStatuses.every((value) => value === "skipped"));
+    const executed = !skipped && resultStatuses.length > 0;
+    const flaky = status === "flaky";
+    const unexpected = status === "unexpected";
+    const timedOut = resultStatuses.includes("timedOut");
+    const interrupted = resultStatuses.includes("interrupted");
+    const passed = executed &&
+        !flaky &&
+        !unexpected &&
+        status === "expected" &&
+        resultStatuses.length > 0 &&
+        resultStatuses.at(-1) === "passed";
+    const traces = results.map((result) => scenarioTrace(result));
+    const givenKeys = traces[0]?.given_keys ?? [];
+    const actionKeys = traces[0]?.action_keys ?? [];
+    const traceConsistent = traces.every((trace) => same(trace.given_keys, givenKeys) && same(trace.action_keys, actionKeys));
+    return {
+        id,
+        project_id: projectId,
+        executed,
+        passed,
+        skipped,
+        flaky,
+        unexpected,
+        timed_out: timedOut,
+        interrupted,
+        status,
+        given_keys: traceConsistent ? givenKeys : [],
+        action_keys: traceConsistent ? actionKeys : [],
+    };
+}
+export function declaredCaseIds(check) {
+    const result = new Set();
+    for (const assertion of [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ]) {
+        if (!assertion.claims.length)
+            continue;
+        const match = /^playwright\.case\.([a-z0-9][a-z0-9-]*)\.passed$/u.exec(assertion.observation);
+        if (match)
+            result.add(assertion.key);
+    }
+    return result;
+}
+export function duplicateCaseInstance(values) {
+    const seen = new Set();
+    for (const value of values) {
+        const identity = `${value.id}\0${value.project_id}`;
+        if (seen.has(identity))
+            return value;
+        seen.add(identity);
+    }
+    return null;
+}
+export function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function scenarioTrace(result) {
+    const givenKeys = [];
+    const actionKeys = [];
+    const visit = (value) => {
+        if (!Array.isArray(value))
+            return;
+        for (const item of value) {
+            const step = record(item);
+            if (!step)
+                continue;
+            if (typeof step.title === "string") {
+                const given = /^\[given:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
+                const action = /^\[action:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
+                if (given)
+                    givenKeys.push(given[1]);
+                if (action)
+                    actionKeys.push(action[1]);
+            }
+            visit(step.steps);
+        }
+    };
+    visit(result.steps);
+    return { given_keys: givenKeys, action_keys: actionKeys };
+}
+export function same(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}