project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/long-task-static-observation-freeze.js

@@ -0,0 +1,428 @@
+import { createHash } from "node:crypto";
+import { constants, watch } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import path from "node:path";
+import { JSON_POINTER_EXACT_LIMITS, assertJsonTree, decodeUtf8Json, extractJsonPointerExactObservationFromBytes, normalizeObservationArtifactPath, parseJsonWithoutDuplicateKeys, resolveJsonPointer, } from "./long-task-json-pointer-observation.js";
+export class StaticObservationFreezeError extends Error {
+    code;
+    artifact_path;
+    cause_code;
+    constructor(code, artifactPath, causeCode = null) {
+        super([code, artifactPath, causeCode]
+            .filter((value) => value !== null && value !== "")
+            .join(":"));
+        this.name = "StaticObservationFreezeError";
+        this.code = code;
+        this.artifact_path = artifactPath;
+        this.cause_code = causeCode;
+    }
+}
+export function createObservationInputFreezeBudget(input) {
+    if (!Number.isSafeInteger(input.max_artifacts) ||
+        input.max_artifacts <= 0 ||
+        !Number.isSafeInteger(input.max_total_artifact_bytes) ||
+        input.max_total_artifact_bytes <= 0)
+        throw new Error("observation_input_freeze_budget_invalid");
+    return {
+        seen_artifact_paths: new Set(),
+        total_artifact_bytes: 0,
+        max_artifacts: input.max_artifacts,
+        max_total_artifact_bytes: input.max_total_artifact_bytes,
+    };
+}
+export async function freezeStaticObservationCarrier(input) {
+    const artifactPath = normalizeStaticArtifactPath(input.artifact_path);
+    assertArtifactCount(input.budget, artifactPath);
+    const prepared = await prepareFrozenObservationInput({
+        snapshot_root: input.snapshot_root,
+        workspace_manifest: input.workspace_manifest,
+        artifact_path: artifactPath,
+        max_file_bytes: JSON_POINTER_EXACT_LIMITS.max_file_bytes,
+        budget: input.input_freeze_budget,
+        retain_bytes: true,
+    });
+    accountForArtifact(input.budget, artifactPath, prepared.preRunIdentity.size);
+    const frozenBytes = prepared.frozenBytes;
+    if (!frozenBytes)
+        throw new Error("static_observation_frozen_bytes_missing");
+    return Object.freeze({
+        artifact_path: artifactPath,
+        manifest_membership: prepared.manifest,
+        pre_run_identity: prepared.preRunIdentity,
+        verifyPostRun: async () => {
+            try {
+                const postRunIdentity = await prepared.verifyPostRunIdentity();
+                return Object.freeze({
+                    artifact_path: artifactPath,
+                    manifest_membership: prepared.manifest,
+                    pre_run_identity: prepared.preRunIdentity,
+                    post_run_identity: postRunIdentity,
+                    copyFrozenBytes: () => Uint8Array.from(frozenBytes),
+                    extractJsonPointerExactObservation: (input) => extractJsonPointerExactObservationFromBytes({
+                        artifact_path: artifactPath,
+                        bytes: frozenBytes,
+                        locator: input.locator,
+                        sensitivity: input.sensitivity,
+                        budget: input.budget,
+                    }),
+                    extractJsonPointerExactValue: (input) => {
+                        const observation = extractJsonPointerExactObservationFromBytes({
+                            artifact_path: artifactPath,
+                            bytes: frozenBytes,
+                            locator: input.locator,
+                            sensitivity: input.sensitivity,
+                            budget: input.budget,
+                        });
+                        const parsed = parseJsonWithoutDuplicateKeys(decodeUtf8Json(frozenBytes));
+                        assertJsonTree(parsed, 0);
+                        return {
+                            raw_value: resolveJsonPointer(parsed, observation.locator.value),
+                            observation,
+                        };
+                    },
+                });
+            }
+            finally {
+                prepared.dispose();
+            }
+        },
+        dispose: prepared.dispose,
+    });
+}
+export async function freezeObservationInputFile(input) {
+    const prepared = await prepareFrozenObservationInput({
+        ...input,
+        retain_bytes: false,
+    });
+    return Object.freeze({
+        artifact_path: prepared.artifactPath,
+        manifest_membership: prepared.manifest,
+        pre_run_identity: prepared.preRunIdentity,
+        verifyPostRun: async () => {
+            try {
+                const postRunIdentity = await prepared.verifyPostRunIdentity();
+                return Object.freeze({
+                    artifact_path: prepared.artifactPath,
+                    manifest_membership: prepared.manifest,
+                    pre_run_identity: prepared.preRunIdentity,
+                    post_run_identity: postRunIdentity,
+                });
+            }
+            finally {
+                prepared.dispose();
+            }
+        },
+        dispose: prepared.dispose,
+    });
+}
+async function prepareFrozenObservationInput(input) {
+    const artifactPath = normalizeStaticArtifactPath(input.artifact_path);
+    const maxFileBytes = observationInputFileLimit(input.max_file_bytes);
+    const manifestEntry = manifestMembership(input.workspace_manifest, artifactPath);
+    assertObservationInputCount(input.budget, artifactPath);
+    const root = path.resolve(input.snapshot_root);
+    const captured = await captureStaticObservationFile(root, artifactPath, maxFileBytes, input.retain_bytes);
+    accountForObservationInput(input.budget, artifactPath, captured.identity.size);
+    const manifest = freezeManifestMembership(manifestEntry);
+    const preRunIdentity = freezeFileIdentity(captured.identity);
+    const frozenBytes = captured.bytes ? Buffer.from(captured.bytes) : null;
+    const mutationMonitor = monitorObservationInput(root, artifactPath);
+    return {
+        artifactPath,
+        manifest,
+        preRunIdentity,
+        frozenBytes,
+        verifyPostRunIdentity: async () => {
+            let post;
+            try {
+                await mutationMonitor.assertUnchanged();
+                post = await captureStaticObservationFile(root, artifactPath, maxFileBytes, false, preRunIdentity);
+                if (post.identity.content_sha256 !== preRunIdentity.content_sha256)
+                    throw freezeError("static_observation_changed_by_runner", artifactPath, "content_sha256");
+                await mutationMonitor.assertUnchanged();
+            }
+            catch (error) {
+                if (error instanceof StaticObservationFreezeError &&
+                    error.code === "static_observation_changed_by_runner")
+                    throw error;
+                throw freezeError("static_observation_changed_by_runner", artifactPath, freezeCause(error));
+            }
+            return freezeFileIdentity(post.identity);
+        },
+        dispose: mutationMonitor.dispose,
+    };
+}
+function monitorObservationInput(root, artifactPath) {
+    const absolute = path.resolve(root, ...artifactPath.split("/"));
+    let changedCause = null;
+    let disposed = false;
+    let watcher;
+    try {
+        watcher = watch(absolute, { persistent: false }, (eventType) => {
+            changedCause ??= `filesystem_event.${eventType}`;
+        });
+    }
+    catch (error) {
+        throw freezeError("static_observation_changed_by_runner", artifactPath, `monitor_unavailable.${nodeErrorCode(error)}`);
+    }
+    watcher.on("error", (error) => {
+        changedCause ??= `filesystem_monitor_error.${nodeErrorCode(error)}`;
+    });
+    return {
+        assertUnchanged: async () => {
+            await settleFilesystemEvents();
+            if (changedCause)
+                throw freezeError("static_observation_changed_by_runner", artifactPath, changedCause);
+        },
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            watcher.close();
+        },
+    };
+}
+async function settleFilesystemEvents() {
+    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => setImmediate(resolve));
+}
+const STATIC_OBSERVATION_METADATA_KEYS = Object.freeze([
+    "device",
+    "inode",
+    "mode",
+    "links",
+    "size",
+    "modified_time_ns",
+    "changed_time_ns",
+    "birth_time_ns",
+]);
+async function captureStaticObservationFile(root, artifactPath, maxFileBytes, retainBytes, expected) {
+    const rootInfo = await lstat(root, { bigint: true }).catch((error) => {
+        throw freezeError("static_observation_root_invalid", artifactPath, nodeErrorCode(error));
+    });
+    if (rootInfo.isSymbolicLink() || !rootInfo.isDirectory())
+        throw freezeError("static_observation_root_invalid", artifactPath);
+    const canonicalRoot = await realpath(root);
+    const absolute = path.resolve(root, ...artifactPath.split("/"));
+    assertContained(root, absolute, artifactPath);
+    const pathInfo = await inspectNoFollowPath(root, artifactPath, expected);
+    const canonicalFile = await realpath(absolute).catch((error) => {
+        throw freezeError(expected
+            ? "static_observation_changed_by_runner"
+            : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
+    });
+    assertContained(canonicalRoot, canonicalFile, artifactPath);
+    const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+    const handle = await open(absolute, constants.O_RDONLY | noFollow).catch((error) => {
+        throw freezeError(expected
+            ? "static_observation_changed_by_runner"
+            : openFailureCode(error), artifactPath, nodeErrorCode(error));
+    });
+    try {
+        const opened = await handle.stat({ bigint: true });
+        assertRegularFile(opened, artifactPath);
+        const openedMetadata = fileMetadata(opened);
+        assertMetadataEqual(pathInfo, openedMetadata, artifactPath, expected);
+        if (expected)
+            assertMetadataEqual(expected, openedMetadata, artifactPath, expected);
+        if (openedMetadata.size > maxFileBytes)
+            throw freezeError("static_observation_size_limit", artifactPath);
+        const content = await readAndHashBounded(handle, artifactPath, maxFileBytes, retainBytes);
+        const afterRead = fileMetadata(await handle.stat({ bigint: true }));
+        assertMetadataEqual(openedMetadata, afterRead, artifactPath, expected);
+        const pathAfter = fileMetadata(await lstat(absolute, { bigint: true }).catch((error) => {
+            throw freezeError(expected
+                ? "static_observation_changed_by_runner"
+                : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
+        }));
+        assertMetadataEqual(afterRead, pathAfter, artifactPath, expected);
+        const canonicalAfter = await realpath(absolute);
+        assertContained(canonicalRoot, canonicalAfter, artifactPath);
+        if (canonicalAfter !== canonicalFile)
+            throw freezeError(expected
+                ? "static_observation_changed_by_runner"
+                : "static_observation_symlink_not_allowed", artifactPath, "realpath_changed");
+        return {
+            identity: {
+                ...openedMetadata,
+                content_sha256: content.sha256,
+            },
+            bytes: content.bytes,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function inspectNoFollowPath(root, artifactPath, expected) {
+    let current = root;
+    const segments = artifactPath.split("/");
+    for (const [index, segment] of segments.entries()) {
+        current = path.join(current, segment);
+        const info = await lstat(current, { bigint: true }).catch((error) => {
+            throw freezeError(expected
+                ? "static_observation_changed_by_runner"
+                : "static_observation_not_in_pre_run_snapshot", artifactPath, nodeErrorCode(error));
+        });
+        if (info.isSymbolicLink())
+            throw freezeError(expected
+                ? "static_observation_changed_by_runner"
+                : "static_observation_symlink_not_allowed", artifactPath, "symbolic_link");
+        if (index < segments.length - 1) {
+            if (!info.isDirectory())
+                throw freezeError(expected
+                    ? "static_observation_changed_by_runner"
+                    : "static_observation_parent_not_directory", artifactPath);
+            continue;
+        }
+        assertRegularFile(info, artifactPath);
+        return fileMetadata(info);
+    }
+    throw freezeError("static_observation_path_escape", artifactPath);
+}
+function manifestMembership(manifest, artifactPath) {
+    const matches = manifest.files.filter((entry) => entry.path === artifactPath);
+    if (!matches.length)
+        throw freezeError("static_observation_not_in_pre_run_snapshot", artifactPath);
+    if (matches.length !== 1)
+        throw freezeError("static_observation_manifest_invalid", artifactPath);
+    const entry = matches[0];
+    if (!isManifestRegularFile(entry))
+        throw freezeError("static_observation_not_regular_file", artifactPath);
+    return {
+        path: entry.path,
+        mode: entry.mode,
+        declared_size: entry.size,
+        manifest_object_identity: entry.sha256,
+    };
+}
+function isManifestRegularFile(entry) {
+    return (entry.mode & 0o170000) === 0o100000;
+}
+function normalizeStaticArtifactPath(value) {
+    try {
+        return normalizeObservationArtifactPath(value);
+    }
+    catch {
+        throw freezeError("static_observation_path_escape", value);
+    }
+}
+function assertRegularFile(info, artifactPath) {
+    if (info.isSymbolicLink())
+        throw freezeError("static_observation_symlink_not_allowed", artifactPath);
+    if (!info.isFile())
+        throw freezeError("static_observation_not_regular_file", artifactPath);
+    if (info.nlink > 1n)
+        throw freezeError("static_observation_hardlink_not_allowed", artifactPath);
+}
+function fileMetadata(info) {
+    return {
+        device: info.dev.toString(),
+        inode: info.ino.toString(),
+        mode: Number(info.mode),
+        links: info.nlink.toString(),
+        size: Number(info.size),
+        modified_time_ns: info.mtimeNs.toString(),
+        changed_time_ns: info.ctimeNs.toString(),
+        birth_time_ns: info.birthtimeNs.toString(),
+    };
+}
+function assertMetadataEqual(left, right, artifactPath, postRunExpected) {
+    const mismatch = STATIC_OBSERVATION_METADATA_KEYS.find((key) => left[key] !== right[key]);
+    if (!mismatch)
+        return;
+    throw freezeError(postRunExpected
+        ? "static_observation_changed_by_runner"
+        : "static_observation_not_in_pre_run_snapshot", artifactPath, `file_identity.${mismatch}`);
+}
+async function readAndHashBounded(handle, artifactPath, limit, retainBytes) {
+    const buffer = Buffer.allocUnsafe(Math.min(65_536, limit + 1));
+    const chunks = [];
+    const hash = createHash("sha256");
+    let offset = 0;
+    while (true) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, offset);
+        if (!bytesRead)
+            break;
+        offset += bytesRead;
+        if (offset > limit)
+            throw freezeError("static_observation_size_limit", artifactPath);
+        const chunk = buffer.subarray(0, bytesRead);
+        hash.update(chunk);
+        if (retainBytes)
+            chunks.push(Buffer.from(chunk));
+    }
+    return {
+        bytes: retainBytes ? Uint8Array.from(Buffer.concat(chunks, offset)) : null,
+        sha256: hash.digest("hex"),
+    };
+}
+function observationInputFileLimit(value) {
+    const limit = value;
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        throw new Error("observation_input_freeze_file_limit_invalid");
+    return limit;
+}
+function assertContained(root, target, artifactPath) {
+    const relative = path.relative(root, target);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative))
+        throw freezeError("static_observation_path_escape", artifactPath);
+}
+function assertArtifactCount(budget, artifactPath) {
+    if (budget &&
+        !budget.seen_artifact_paths.has(artifactPath) &&
+        budget.seen_artifact_paths.size >=
+            JSON_POINTER_EXACT_LIMITS.max_artifacts_per_check)
+        throw new Error("observation_artifact_count_limit");
+}
+function assertObservationInputCount(budget, artifactPath) {
+    if (budget &&
+        !budget.seen_artifact_paths.has(artifactPath) &&
+        budget.seen_artifact_paths.size >= budget.max_artifacts)
+        throw new Error("observation_input_freeze_artifact_count_limit");
+}
+function accountForObservationInput(budget, artifactPath, bytes) {
+    if (!budget || budget.seen_artifact_paths.has(artifactPath))
+        return;
+    if (budget.total_artifact_bytes + bytes > budget.max_total_artifact_bytes)
+        throw new Error("observation_input_freeze_total_size_limit");
+    budget.seen_artifact_paths.add(artifactPath);
+    budget.total_artifact_bytes += bytes;
+}
+function accountForArtifact(budget, artifactPath, bytes) {
+    if (!budget || budget.seen_artifact_paths.has(artifactPath))
+        return;
+    if (budget.total_artifact_bytes + bytes >
+        JSON_POINTER_EXACT_LIMITS.max_total_artifact_bytes)
+        throw new Error("observation_artifact_total_size_limit");
+    budget.seen_artifact_paths.add(artifactPath);
+    budget.total_artifact_bytes += bytes;
+}
+function freezeManifestMembership(value) {
+    return Object.freeze({ ...value });
+}
+function freezeFileIdentity(value) {
+    return Object.freeze({ ...value });
+}
+function freezeError(code, artifactPath, causeCode = null) {
+    return new StaticObservationFreezeError(code, artifactPath, causeCode);
+}
+function openFailureCode(error) {
+    return nodeErrorCode(error) === "ENOENT"
+        ? "static_observation_not_in_pre_run_snapshot"
+        : nodeErrorCode(error) === "ELOOP"
+            ? "static_observation_symlink_not_allowed"
+            : "static_observation_not_regular_file";
+}
+function freezeCause(error) {
+    if (error instanceof StaticObservationFreezeError)
+        return error.cause_code ?? error.code;
+    return nodeErrorCode(error);
+}
+function nodeErrorCode(error) {
+    return (error?.code ??
+        (error instanceof Error ? error.message : String(error)));
+}

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

@@ -1,3 +1,4 @@
+import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
 import { progressRecordFresh } from "./long-task-progress.js";
 export function projectDeliveryStatus(input) {
     const outcomes = projectOutcomes(input);
@@ -46,7 +47,8 @@ function projectOutcomes(input) {
         });
         outcomes[outcome.key] = states.includes("progress_failing")
             ? "progress_failing"
-            : states.includes("blocked_external")
+            : outcomeResultExternallyBlocked(input.compiled, outcome.key) ||
+                states.includes("blocked_external")
                 ? "blocked_external"
                 : states.includes("progress_stale")
                     ? "progress_stale"
@@ -99,7 +101,9 @@ function projectFindings(input) {
 function readyOutcomes(compiled, outcomes, stages) {
     return compiled.outcomes
         .filter((outcome) => stages[outcome.stage] !== "locked" &&
+        stages[outcome.stage] !== "blocked_external" &&
         stages[outcome.stage] !== "progress_passing" &&
+        outcomes[outcome.key] !== "blocked_external" &&
         outcomes[outcome.key] !== "progress_passing" &&
         outcome.depends_on.every((dependency) => outcomes[dependency] === "progress_passing"))
         .map((outcome) => outcome.key);

package/dist/lib/long-task-target-policy.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
+import { type CompiledClaimsV2 } from "./long-task-claims.js";
 import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
 type Reporter = (message: string) => void;
 export declare function validateExecutionTargets(contract: DeliveryContractV2, report?: Reporter): void;

package/dist/lib/long-task-target-policy.js

@@ -1,3 +1,4 @@
+import { outcomeResultExternallyBlocked, } from "./long-task-claims.js";
 const FAMILY_CAPABILITY = {
     browser: "browser-runtime",
     native: "native-runtime",
@@ -94,6 +95,8 @@ function validateCriticalPathTargets(contract, requiredTargetRefs, report) {
         const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
         if (!outcome)
             continue;
+        if (outcomeResultExternallyBlocked(contract, outcome.key))
+            continue;
         for (const targetRef of requiredTargetRefs)
             if (!outcome.acceptance.checks.some((check) => provesSuccess(check, targetRef)))
                 issue(report, "critical_path_required_target_proof_missing", `${outcome.key}:${targetRef}`);

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

@@ -7,6 +7,7 @@ export function validateUiDesignBinding(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}`;
+        const symbolic = target.fact_model === "symbolic_rules_v2";
         if (designTargetKeys.has(target.key))
             issue(report, "ui_design_target_key_duplicate", label);
         designTargetKeys.add(target.key);
@@ -14,10 +15,20 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         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)
+        unique((symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).map((item) => item.method), "ui_design_target_verification_method_duplicate", label, report);
+        unique((symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).map((item) => item.assertion_ref), "ui_design_target_verification_assertion_duplicate", label, report);
+        if (!(symbolic
+            ? (target.symbolic_method_bindings ?? [])
+            : target.verification_method_bindings).length)
             issue(report, "ui_design_target_verification_methods_required", label);
+        if (symbolic &&
+            (target.condition_keys.length ||
+                target.verification_method_bindings.length))
+            issue(report, "ui_design_symbolic_ground_fields_forbidden", label);
         const methodArtifactPaths = new Set();
         const methodFactObligations = new Set();
         for (const [name, values] of [
@@ -26,7 +37,7 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
             ["claim_refs", target.claim_refs],
         ]) {
             unique(values, `ui_design_target_${name}_duplicate`, label, report);
-            if (!values.length)
+            if (!values.length && !(symbolic && name === "condition_keys"))
                 issue(report, `ui_design_target_${name}_required`, label);
         }
         for (const claimRef of target.claim_refs) {
@@ -44,6 +55,11 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         validateRootJourney(binding, check, label, report);
         validateCarrierInputs(check, carriers, label, report);
         validateDesignAssertion(target, check, label, report);
+        if (symbolic) {
+            validateSymbolicDesignBindings(target, check, label, methodArtifactPaths, report);
+            validateDesignFiles(target, check, label, report);
+            continue;
+        }
         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 &&
@@ -86,6 +102,50 @@ function validateDesignTargets({ outcome, binding, outcomeClaims, checks, carrie
         validateDesignFiles(target, check, label, report);
     }
 }
+function validateSymbolicDesignBindings(target, check, label, artifactPaths, report) {
+    const obligationRefs = new Set();
+    for (const binding of target.symbolic_method_bindings ?? []) {
+        const assertion = check.positive_assertions.find((item) => item.key === binding.assertion_ref);
+        if (!assertion)
+            issue(report, "ui_design_symbolic_method_assertion_unknown", `${label}:${binding.method}:${binding.assertion_ref}`);
+        else if (!assertion.evidence_capabilities.includes("design_method"))
+            issue(report, "ui_design_symbolic_method_capability_required", `${label}:${binding.method}`);
+        if (!binding.rule_expectations.length)
+            issue(report, "ui_design_symbolic_rule_expectations_required", `${label}:${binding.method}`);
+        unique(binding.rule_expectations.map((item) => item.obligation_ref), "ui_design_symbolic_obligation_duplicate", `${label}:${binding.method}`, report);
+        for (const expectation of binding.rule_expectations) {
+            if (obligationRefs.has(expectation.obligation_ref))
+                issue(report, "ui_design_symbolic_obligation_reused", `${label}:${expectation.obligation_ref}`);
+            obligationRefs.add(expectation.obligation_ref);
+        }
+        for (const artifactPath of [
+            binding.artifact_path,
+            binding.observation_path,
+        ])
+            validateSymbolicArtifactPath(artifactPath, target, check, label, artifactPaths, report);
+    }
+    const certificate = target.symbolic_certificate_binding;
+    if (!certificate) {
+        issue(report, "ui_design_symbolic_certificate_binding_required", label);
+        return;
+    }
+    const assertion = check.positive_assertions.find((item) => item.key === certificate.assertion_ref);
+    if (!assertion)
+        issue(report, "ui_design_symbolic_certificate_assertion_unknown", `${label}:${certificate.assertion_ref}`);
+    else if (!assertion.evidence_capabilities.includes("design_symbolic_certificate"))
+        issue(report, "ui_design_symbolic_certificate_capability_required", label);
+    if (!certificate.expectations.length)
+        issue(report, "ui_design_symbolic_certificate_expectations_required", label);
+    unique(certificate.expectations.map((item) => item.certificate_ref), "ui_design_symbolic_certificate_duplicate", label, report);
+    validateSymbolicArtifactPath(certificate.artifact_path, target, check, label, artifactPaths, report);
+}
+function validateSymbolicArtifactPath(artifactPath, _target, check, label, artifactPaths, report) {
+    if (artifactPaths.has(artifactPath))
+        issue(report, "ui_design_symbolic_evidence_artifact_reused", `${label}:${artifactPath}`);
+    artifactPaths.add(artifactPath);
+    if (!check.artifact_globs.some((pattern) => matchesRepoPattern(artifactPath, pattern)))
+        issue(report, "ui_design_symbolic_evidence_artifact_glob_missing", `${label}:${artifactPath}`);
+}
 function sameSet(left, right) {
     const leftSet = [...new Set(left)].sort();
     const rightSet = [...new Set(right)].sort();