project-tiny-context-harness 0.7.8 → 0.8.0

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

@@ -1,3 +1,4 @@
+import { collectCases, declaredCaseIds, duplicateCaseInstance, record, same, } from "./long-task-playwright-case-evidence.js";
 export function extractPlaywrightEvidence(check, report, exitCode) {
     const stats = record(report.stats);
     if (!stats)
@@ -61,6 +62,10 @@ export function extractPlaywrightEvidence(check, report, exitCode) {
         }
     }
     observations["playwright.case_ids"] = cases.map((item) => item.id).sort();
+    const evidenceRecords = evidenceRecordsForCases(check, cases);
+    return { observations, evidence_records: evidenceRecords, error: null };
+}
+function evidenceRecordsForCases(check, cases) {
     const evidenceRecords = [];
     for (const item of cases) {
         const assertion = [
@@ -86,127 +91,22 @@ export function extractPlaywrightEvidence(check, report, exitCode) {
                 session_id: `playwright:${item.id}:${item.project_ids.join(",")}`,
                 cold_start: check.execution_target.entrypoint === "root",
             });
-    }
-    return { observations, evidence_records: evidenceRecords, error: null };
-}
-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;
-            }
+        if (assertion?.evidence_capabilities.includes("design_conformance") &&
+            item.executed) {
+            for (const target of (check.design_conformance_targets ?? []).filter((candidate) => candidate.conformance_assertion_ref === assertion.key ||
+                candidate.verification_method_bindings.some((binding) => binding.assertion_ref === assertion.key)))
+                evidenceRecords.push({
+                    assertion_key: assertion.key,
+                    capability: "design_conformance",
+                    design_target_ref: target.key,
+                    target_ref: target.target_ref,
+                    condition_keys: target.condition_keys,
+                    actual_artifact_path: target.actual_artifact_path,
+                    comparison_artifact_path: target.comparison_artifact_path,
+                });
         }
     }
-    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 : [],
-    };
-}
-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;
-}
-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;
+    return evidenceRecords;
 }
 function aggregateCases(instances) {
     const grouped = new Map();
@@ -271,42 +171,9 @@ function aggregateCases(instances) {
     })
         .sort((left, right) => left.id.localeCompare(right.id));
 }
-function record(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
 function integer(value) {
     return Number.isInteger(value) && Number(value) >= 0 ? Number(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 };
-}
-function same(left, right) {
-    return (left.length === right.length &&
-        left.every((value, index) => value === right[index]));
-}
 function invalid(error) {
     return { observations: {}, evidence_records: [], error };
 }

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

@@ -1,2 +1,2 @@
-import type { CompiledCheckV2, DeliveryCheckV2, ExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[]): Promise<CompiledCheckV2>;
+import type { CompiledCheckV2, CompiledDesignTargetV2, DeliveryCheckV2, ExecutionTargetV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+export declare function freezeDeliveryCheck(check: DeliveryCheckV2, outcomeKey: string | null, repository: string, baseline: WorkspaceManifestV2, executionTarget: ExecutionTargetV2, knownExecutionTargets: ExecutionTargetV2[], designConformanceTargets: CompiledDesignTargetV2[]): Promise<CompiledCheckV2>;

package/dist/lib/long-task-runner-freeze.js

@@ -7,7 +7,7 @@ import { nearestRunnerFile, npmCliPath, npxCliPath, } from "./long-task-runner-f
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
 import { repoRelative, resolveInsideRepository, } from "./long-task-workspace.js";
 import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
-export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets) {
+export async function freezeDeliveryCheck(check, outcomeKey, repository, baseline, executionTarget, knownExecutionTargets, designConformanceTargets) {
     const prefix = outcomeKey ? `CHECK.${outcomeKey}` : "CHECK.GLOBAL";
     const expectedOutputs = check.expected_output_paths.map((pattern, index) => assertRepositoryPattern(repository, pattern, `${check.key}.expected_output_paths[${index}]`));
     for (const [index, pattern] of check.input_paths.entries()) {
@@ -32,6 +32,7 @@ export async function freezeDeliveryCheck(check, outcomeKey, repository, baselin
         verification_input_hashes: verificationInputHashes,
         execution_target_definition: executionTarget,
         known_execution_targets: knownExecutionTargets,
+        design_conformance_targets: designConformanceTargets,
     };
     return {
         ...compiled,

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

@@ -1,5 +1,6 @@
 import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, DeliveryRunnerV2, ProofSurface } from "./long-task-contract-types.js";
 import type { EvidenceCapabilityV2, ExecutionTargetV2 } from "./long-task-semantic-contract-types.js";
+import type { CompiledDesignTargetV2 } from "./long-task-ui-surface-types.js";
 import type { AuthorityHashesV2, ContextAuthoritySnapshotV2, InitialTaskBaseV2, NextAuthorityMaterialsV2, VerifierIdentityV2 } from "./long-task-authority-types.js";
 import type { EvidenceAdapter } from "./long-task-evidence-adapter-types.js";
 import type { EvidenceCapabilityRecordV2 } from "./long-task-evidence-capability-types.js";
@@ -25,6 +26,7 @@ export interface CompiledCheckV2 extends Omit<DeliveryCheckV2, "runner"> {
     raw_execution_identity: string;
     execution_target_definition: ExecutionTargetV2;
     known_execution_targets: ExecutionTargetV2[];
+    design_conformance_targets: CompiledDesignTargetV2[];
 }
 export interface ProductClaimV2 {
     id: string;

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

@@ -25,7 +25,7 @@ export interface DeliveryStageV2 {
     gate_outcome: string;
 }
 export type DeliveryJourneyRoleV2 = "success" | "degradation" | "recovery" | "stage_gate" | "conformance";
-export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "target_runtime" | "input_variation";
+export type EvidenceCapabilityV2 = "presence" | "interaction_trace" | "state_delta" | "cross_surface_consistency" | "durable_readback" | "boundary_invocation" | "external_side_effect" | "failure_injection" | "visual_render" | "design_conformance" | "target_runtime" | "input_variation";
 export interface CheckExecutionTargetV2 {
     target_ref: string;
     entrypoint: "root" | "internal";

package/dist/lib/long-task-semantic-drift-migration.js

@@ -37,8 +37,13 @@ export function assertNoSemanticDriftMigration(fields) {
 function collectOutcome(outcome, label, missing) {
     required(outcome, label, ["stage"], missing);
     const product = row(outcome.product);
-    if (product)
+    if (product) {
         required(product, `${label}.product`, ["success_path_required", "degradation_path_required"], missing);
+        if (Array.isArray(product.controls) &&
+            product.controls.length > 0 &&
+            !Object.hasOwn(product, "surface_bindings"))
+            missing.push(`${label}.product.surface_bindings`);
+    }
     const acceptance = row(outcome.acceptance);
     collectChecks(acceptance?.checks, `${label}.acceptance.checks`, missing);
 }

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

@@ -16,5 +16,5 @@ export declare function key(value: unknown, label: string): string;
 export declare function nullable<T>(value: unknown, parser: (value: unknown) => T): T | null;
 export declare const PROOF_SURFACES: readonly ["ui_browser", "runtime_behavior", "api_contract", "data_state", "security_boundary", "population_coverage", "implementation_structure"];
 export declare const JOURNEY_ROLES: readonly ["success", "degradation", "recovery", "stage_gate", "conformance"];
-export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "external_side_effect", "failure_injection", "visual_render", "target_runtime", "input_variation"];
+export declare const EVIDENCE_CAPABILITIES: readonly ["presence", "interaction_trace", "state_delta", "cross_surface_consistency", "durable_readback", "boundary_invocation", "external_side_effect", "failure_injection", "visual_render", "design_conformance", "target_runtime", "input_variation"];
 export declare function fail(label: string, message: string): never;

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

@@ -98,6 +98,7 @@ export const EVIDENCE_CAPABILITIES = [
     "external_side_effect",
     "failure_injection",
     "visual_render",
+    "design_conformance",
     "target_runtime",
     "input_variation",
 ];

package/dist/lib/long-task-status-v2.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { authorityRevisionDecisionNextAction } from "./long-task-authority-revision-brief.js";
 import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
 import { runDeliveryFinalGate } from "./long-task-final-v2.js";
 import { deliveryCompileFreshness } from "./long-task-freshness.js";
@@ -83,10 +84,10 @@ export async function resumeDeliveryTask(workdir) {
     if (active.workdir !== path.resolve(workdir))
         throw new Error("active_task_workdir_mismatch");
     const compiled = active.authority_snapshot;
-    const [status, git] = await Promise.all([
-        readDeliveryStatusForAuthority(active),
-        currentGitState(compiled.repository_root),
-    ]);
+    // Status capture runs git write-tree; finish it before git status can refresh
+    // the same repository index inside currentGitState.
+    const status = await readDeliveryStatusForAuthority(active);
+    const git = await currentGitState(compiled.repository_root);
     return {
         schema_version: "long-task-resume-v2",
         task: {
@@ -312,11 +313,15 @@ function acceptedScopeMessage(workflowStatus, confirmations, targetProfile) {
 }
 function nextAction(status) {
     if (status.pending_authority_revision)
-        return `Ask the user to approve or reject Authority Revision ${status.pending_authority_revision.revision_identity}; keep the previous Authority active until then.`;
+        return authorityRevisionDecisionNextAction(status.pending_authority_revision);
     if (status.findings.length)
         return status.findings.at(-1).next_action;
-    if (status.ready_outcomes.length)
-        return `Implement and verify ready Outcome: ${status.ready_outcomes[0]}.`;
+    if (status.ready_outcomes.length) {
+        const outcome = status.ready_outcomes[0];
+        if (status.outcomes[outcome] === "progress_stale")
+            return `Targeted evidence for ready Outcome ${outcome} is stale. This is a freshness fact, not an immediate per-edit rerun instruction: coalesce relevant changes, use the cheapest reliable project-owned feedback, and refresh the declared Check before relying on this Outcome or entering Final Gate.`;
+        return `Implement and verify ready Outcome: ${outcome}.`;
+    }
     return "Create a clean candidate commit; Stop will run the authoritative Live Final Gate.";
 }
 function message(error) {

package/dist/lib/long-task-ui-design-policy.d.ts

@@ -0,0 +1,17 @@
+import type { CompiledClaimsV2 } from "./long-task-claims.js";
+import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, ProductClaimV2 } from "./long-task-delivery-types.js";
+import { type Reporter } from "./long-task-ui-surface-validation.js";
+interface UiDesignBindingContext {
+    outcome: DeliveryOutcomeV2;
+    binding: DeliveryOutcomeV2["product"]["surface_bindings"][number];
+    outcomeClaims: Map<string, ProductClaimV2>;
+    claims: CompiledClaimsV2;
+    checks: Map<string, DeliveryCheckV2>;
+    confirmations: Map<string, DeliveryContractV2["global"]["acceptance"]["external_confirmations"][number]>;
+    carriers: string[];
+    designTargetKeys: Set<string>;
+    designAssertionRefs: Set<string>;
+    report?: Reporter;
+}
+export declare function validateUiDesignBinding(context: UiDesignBindingContext): void;
+export {};

package/dist/lib/long-task-ui-design-policy.js

@@ -0,0 +1,128 @@
+import { matchesRepoPattern } from "./long-task-paths.js";
+import { issue, unique, validateCarrierInputs, validateRootJourney, validateTargetLocalClaimProof, } from "./long-task-ui-surface-validation.js";
+export function validateUiDesignBinding(context) {
+    validateDesignTargets(context);
+    validateBlockers(context);
+}
+function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carriers, designTargetKeys, designAssertionRefs, report, }) {
+    for (const target of binding.design_targets) {
+        const label = `${outcome.key}:${binding.key}:${target.key}`;
+        if (designTargetKeys.has(target.key))
+            issue(report, "ui_design_target_key_duplicate", label);
+        designTargetKeys.add(target.key);
+        const assertionIdentity = `${target.conformance_check_ref}\0${target.conformance_assertion_ref}`;
+        if (designAssertionRefs.has(assertionIdentity))
+            issue(report, "ui_design_target_assertion_duplicate", label);
+        designAssertionRefs.add(assertionIdentity);
+        unique(target.verification_method_bindings.map((item) => item.method), "ui_design_target_verification_method_duplicate", label, report);
+        unique(target.verification_method_bindings.map((item) => item.assertion_ref), "ui_design_target_verification_assertion_duplicate", label, report);
+        if (!target.verification_method_bindings.length)
+            issue(report, "ui_design_target_verification_methods_required", label);
+        for (const [name, values] of [
+            ["source_paths", target.source_paths],
+            ["condition_keys", target.condition_keys],
+            ["claim_refs", target.claim_refs],
+        ]) {
+            unique(values, `ui_design_target_${name}_duplicate`, label, report);
+            if (!values.length)
+                issue(report, `ui_design_target_${name}_required`, label);
+        }
+        for (const claimRef of target.claim_refs) {
+            const claim = outcomeClaims.get(claimRef);
+            if (!claim ||
+                claim.kind !== "control" ||
+                !binding.control_refs.some((control) => claimRef.startsWith(`control.${control}.`)))
+                issue(report, "ui_design_target_control_claim_required", `${label}:${claimRef}`);
+        }
+        const check = checks.get(target.conformance_check_ref);
+        if (!check) {
+            issue(report, "ui_design_target_conformance_check_unknown", `${label}:${target.conformance_check_ref}`);
+            continue;
+        }
+        validateRootJourney(binding, check, label, report);
+        validateCarrierInputs(check, carriers, label, report);
+        validateDesignAssertion(target, check, label, report);
+        for (const methodBinding of target.verification_method_bindings) {
+            const identity = `${target.conformance_check_ref}\0${methodBinding.assertion_ref}`;
+            if (methodBinding.assertion_ref !== target.conformance_assertion_ref &&
+                designAssertionRefs.has(identity))
+                issue(report, "ui_design_target_assertion_duplicate", `${label}:${methodBinding.assertion_ref}`);
+            if (methodBinding.assertion_ref !== target.conformance_assertion_ref)
+                designAssertionRefs.add(identity);
+            if (!check.positive_assertions.some((item) => item.key === methodBinding.assertion_ref))
+                issue(report, "ui_design_target_verification_assertion_unknown", `${label}:${methodBinding.method}:${methodBinding.assertion_ref}`);
+        }
+        validateDesignFiles(target, check, label, report);
+    }
+}
+function validateDesignAssertion(target, check, label, report) {
+    const assertion = check.positive_assertions.find((item) => item.key === target.conformance_assertion_ref);
+    if (!assertion) {
+        issue(report, "ui_design_target_conformance_assertion_unknown", `${label}:${target.conformance_assertion_ref}`);
+        return;
+    }
+    for (const claimRef of target.claim_refs)
+        if (!assertion.claims.includes(claimRef))
+            issue(report, "ui_design_target_claim_not_asserted", `${label}:${claimRef}`);
+    for (const capability of [
+        "design_conformance",
+        "interaction_trace",
+        "target_runtime",
+    ])
+        if (!assertion.evidence_capabilities.includes(capability))
+            issue(report, "ui_design_target_capability_required", `${label}:${capability}`);
+}
+function validateDesignFiles(target, check, label, report) {
+    for (const source of target.source_paths)
+        if (!check.verification_inputs.some((pattern) => matchesRepoPattern(source, pattern)))
+            issue(report, "ui_design_target_verification_input_missing", `${label}:${source}`);
+    if (target.actual_artifact_path === target.comparison_artifact_path)
+        issue(report, "ui_design_target_artifacts_must_differ", label);
+    for (const artifact of [
+        target.actual_artifact_path,
+        target.comparison_artifact_path,
+    ])
+        if (!check.artifact_globs.some((pattern) => matchesRepoPattern(artifact, pattern)))
+            issue(report, "ui_design_target_artifact_glob_missing", `${label}:${artifact}`);
+}
+function validateBlockers(context) {
+    const { outcome, binding, outcomeClaims, claims, checks, confirmations, report, } = context;
+    const label = `${outcome.key}:${binding.key}`;
+    unique(binding.acceptance_blockers.map((item) => item.key), "ui_design_blocker_key_duplicate", label, report);
+    for (const blocker of binding.acceptance_blockers) {
+        const blockerLabel = `${label}:${blocker.key}`;
+        unique(blocker.refs, "ui_design_blocker_ref_duplicate", blockerLabel, report);
+        if (!blocker.refs.length)
+            issue(report, "ui_design_blocker_ref_required", blockerLabel);
+        unique(blocker.source_item_refs, "ui_design_blocker_source_item_duplicate", blockerLabel, report);
+        unique(blocker.verification_methods, "ui_design_blocker_verification_method_duplicate", blockerLabel, report);
+        if (!blocker.source_item_refs.length)
+            issue(report, "ui_design_blocker_source_item_required", blockerLabel);
+        if (!blocker.verification_methods.length)
+            issue(report, "ui_design_blocker_verification_method_required", blockerLabel);
+        if (blocker.status === "machine_claim")
+            validateMachineBlocker(context, blocker.refs, blockerLabel);
+        if (blocker.status === "external_confirmation")
+            validateExternalBlocker(outcome, confirmations, blocker.refs, blockerLabel, report);
+    }
+}
+function validateMachineBlocker({ outcome, binding, outcomeClaims, claims, checks, report, }, claimRefs, label) {
+    for (const claimRef of claimRefs) {
+        const claim = outcomeClaims.get(claimRef);
+        if (!claim)
+            issue(report, "ui_design_blocker_machine_claim_unknown", `${label}:${claimRef}`);
+        else
+            validateTargetLocalClaimProof(outcome, claim, binding.target_ref, null, claims, checks, label, report);
+    }
+}
+function validateExternalBlocker(outcome, confirmations, confirmationRefs, label, report) {
+    for (const confirmationRef of confirmationRefs) {
+        const confirmation = confirmations.get(confirmationRef);
+        if (!confirmation)
+            issue(report, "ui_design_blocker_confirmation_unknown", `${label}:${confirmationRef}`);
+        else if (!confirmation.blocks_target)
+            issue(report, "ui_design_blocker_confirmation_must_block_target", `${label}:${confirmationRef}`);
+        else if (!confirmation.impact_claims.some((claim) => claim.startsWith(`${outcome.key}.`)))
+            issue(report, "ui_design_blocker_confirmation_impact_mismatch", `${label}:${confirmationRef}`);
+    }
+}

package/dist/lib/long-task-ui-surface-policy.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledClaimsV2 } from "./long-task-claims.js";
+import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
+import { type Reporter } from "./long-task-ui-surface-validation.js";
+export declare function validateUiSurfaceBindings(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter): void;

package/dist/lib/long-task-ui-surface-policy.js

@@ -0,0 +1,109 @@
+import { validateUiDesignBinding } from "./long-task-ui-design-policy.js";
+import { bindingCarriers, controlClaims, expectedControlProofSurface, issue, unique, validateCarrierInputs, validateRootJourney, validateTargetLocalClaimProof, } from "./long-task-ui-surface-validation.js";
+export function validateUiSurfaceBindings(contract, claims, report) {
+    const targets = new Map(contract.task.execution_targets.map((target) => [target.key, target]));
+    const requiredTargets = new Set(contract.task.target_profile.required_target_refs);
+    const confirmations = new Map(contract.global.acceptance.external_confirmations.map((item) => [
+        item.key,
+        item,
+    ]));
+    for (const outcome of contract.outcomes)
+        validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report);
+}
+function validateOutcomeBindings(outcome, claims, targets, requiredTargets, confirmations, report) {
+    const surfaceBindings = outcome.product.surface_bindings ?? [];
+    if (outcome.product.controls.length && !surfaceBindings.length)
+        issue(report, "ui_surface_binding_required", outcome.key);
+    if (!outcome.product.controls.length && surfaceBindings.length)
+        issue(report, "ui_surface_binding_without_controls", outcome.key);
+    unique(surfaceBindings.map((item) => item.key), "ui_surface_binding_key_duplicate", outcome.key, report);
+    const controls = new Map(outcome.product.controls.map((control) => [control.key, control]));
+    const ownerSurfaces = new Set(outcome.product.owner_surfaces);
+    const technicalBindings = new Map(outcome.technical.bindings.map((binding) => [binding.key, binding]));
+    const checks = new Map(outcome.acceptance.checks.map((check) => [check.key, check]));
+    const outcomeClaims = new Map((claims.by_outcome[outcome.key] ?? []).map((claim) => [
+        claim.local_key,
+        claim,
+    ]));
+    const boundControls = new Set();
+    const boundControlTargets = new Set();
+    const designTargetKeys = new Set();
+    const designAssertionRefs = new Set();
+    for (const binding of surfaceBindings) {
+        const label = `${outcome.key}:${binding.key}`;
+        if (!ownerSurfaces.has(binding.surface_ref))
+            issue(report, "ui_surface_binding_owner_surface_unknown", `${label}:${binding.surface_ref}`);
+        const target = targets.get(binding.target_ref);
+        if (!target || target.role !== "product")
+            issue(report, "ui_surface_binding_product_target_required", `${label}:${binding.target_ref}`);
+        if (!requiredTargets.has(binding.target_ref))
+            issue(report, "ui_surface_binding_required_target_required", `${label}:${binding.target_ref}`);
+        validateBoundControls(binding, controls, boundControls, boundControlTargets, label, report);
+        const carriers = bindingCarriers(binding.route_binding_ref, binding.component_binding_refs, technicalBindings, label, report);
+        const rootCheck = checks.get(binding.root_journey_check_ref);
+        if (!rootCheck)
+            issue(report, "ui_surface_binding_root_check_unknown", `${label}:${binding.root_journey_check_ref}`);
+        else {
+            validateRootJourney(binding, rootCheck, label, report);
+            validateCarrierInputs(rootCheck, carriers, label, report);
+            validateRootBoundControlAssertions(binding, rootCheck, controls, label, report);
+        }
+        for (const controlRef of binding.control_refs)
+            for (const claim of controlClaims(outcomeClaims, controlRef))
+                validateTargetLocalClaimProof(outcome, claim, binding.target_ref, expectedControlProofSurface(target?.runtime_family), claims, checks, label, report);
+        validateUiDesignBinding({
+            outcome,
+            binding,
+            outcomeClaims,
+            claims,
+            checks,
+            confirmations,
+            carriers,
+            designTargetKeys,
+            designAssertionRefs,
+            report,
+        });
+    }
+    for (const control of outcome.product.controls)
+        if (!boundControls.has(control.key))
+            issue(report, "ui_surface_binding_control_unbound", `${outcome.key}:${control.key}`);
+}
+function validateBoundControls(binding, controls, boundControls, boundControlTargets, label, report) {
+    unique(binding.control_refs, "ui_surface_binding_control_ref_duplicate", label, report);
+    if (!binding.control_refs.length)
+        issue(report, "ui_surface_binding_control_ref_required", label);
+    for (const controlRef of binding.control_refs) {
+        const control = controls.get(controlRef);
+        if (!control)
+            issue(report, "ui_surface_binding_control_unknown", `${label}:${controlRef}`);
+        else if (control.surface.trim() && control.surface !== binding.surface_ref)
+            issue(report, "ui_surface_binding_control_surface_mismatch", `${label}:${controlRef}:${control.surface}`);
+        const identity = `${controlRef}\0${binding.target_ref}`;
+        if (boundControlTargets.has(identity))
+            issue(report, "ui_surface_binding_control_target_duplicate", `${label}:${controlRef}:${binding.target_ref}`);
+        boundControlTargets.add(identity);
+        boundControls.add(controlRef);
+    }
+}
+function validateRootBoundControlAssertions(binding, check, controls, label, report) {
+    for (const controlRef of binding.control_refs) {
+        const control = controls.get(controlRef);
+        if (!control)
+            continue;
+        const claimRef = rootJourneyClaimRef(control);
+        if (!check.positive_assertions.some((assertion) => assertion.claims.includes(claimRef) &&
+            assertion.evidence_capabilities.includes("interaction_trace") &&
+            assertion.evidence_capabilities.includes("target_runtime")))
+            issue(report, "ui_surface_binding_root_control_proof_missing", `${label}:${controlRef}:${claimRef}`);
+    }
+}
+function rootJourneyClaimRef(control) {
+    const field = control.navigation_result?.trim()
+        ? "navigation_result"
+        : control.interaction?.trim()
+            ? "interaction"
+            : control.trigger?.trim()
+                ? "trigger"
+                : "location";
+    return `control.${control.key}.${field}`;
+}

package/dist/lib/long-task-ui-surface-shape.d.ts

@@ -0,0 +1,2 @@
+import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
+export declare function parseSurfaceBindings(value: unknown, label: string): DeliverySurfaceBindingV2[];