frontend-harness 0.7.4 → 0.7.6

package/dist/runtime/verify.d.ts

@@ -5,27 +5,3 @@ export interface VerifyOptions {
     build?: string;
 }
 export declare function runVerification(projectRoot: string, options: VerifyOptions): VerificationResult;
-export interface EvidenceTemplateResult {
-    manifestPath: string;
-    generatedAt: string;
-    status: "ready" | "not_configured";
-    entries: EvidenceManifestEntry[];
-    instructions: string[];
-}
-export interface EvidenceRecordResult {
-    status: "passed";
-    inputPath: string;
-    manifestPath: string;
-    recordedEntries: EvidenceManifestEntry[];
-    entryCount: number;
-}
-export declare function createEvidenceTemplate(projectRoot: string): EvidenceTemplateResult;
-export declare function recordEvidence(projectRoot: string, inputPath: string | undefined): EvidenceRecordResult;
-export declare function assertDesignSourceReadyForProjectChanges(projectRoot: string, files: string[]): void;
-export interface EvidenceManifestEntry {
-    unitId: string;
-    kind: string;
-    artifactPaths: string[];
-    createdAt: string;
-    metadata?: Record<string, unknown>;
-}

package/dist/runtime/verify.js

@@ -1,16 +1,15 @@
 import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { harnessPath } from "../storage/paths.js";
 import { ensureDir, readJson, writeJson, writeText } from "../storage/json.js";
+import { checkVerificationEvidence } from "./evidence.js";
 import { checkStateContract, loadState, updateVerificationState } from "./state.js";
 import { checkKnowledgeCoverage } from "./knowledge.js";
 import { inspectVerificationCommands } from "./verification-commands.js";
 import { createRepairPacket } from "./repair-packet.js";
 import { projectScriptCommand } from "./command-taxonomy.js";
-import { isProjectRelativeSubpath, normalizeProjectRelativePath, resolveProjectOrHarnessRelativePath } from "./project-paths.js";
 const MAX_NODE_E_SCRIPT_LENGTH = 200;
 export function runVerification(projectRoot, options) {
     const startedFromFailed = readPreviousStatus(projectRoot) === "failed";
@@ -242,614 +241,6 @@ export function runVerification(projectRoot, options) {
     }
     return result;
 }
-export function createEvidenceTemplate(projectRoot) {
-    const manifestPath = ".frontend-harness/verification/evidence.json";
-    const requiredEvidence = requiredVerificationEvidence(projectRoot);
-    const generatedAt = new Date().toISOString();
-    return {
-        manifestPath,
-        generatedAt,
-        status: requiredEvidence.length > 0 ? "ready" : "not_configured",
-        entries: requiredEvidence.map((required) => evidenceTemplateEntry(required, generatedAt)),
-        instructions: requiredEvidence.length > 0
-            ? [
-                "Use this as a schema template, not as proof.",
-                "Replace placeholder artifact paths, timestamps, metadata values, and hashes with facts from real source capture, command output, browser/manual inspection, or screenshot comparison.",
-                "For design_to_code sources, preserve the generated artifact under .frontend-harness/ and classify usability before copying or mining it for project source.",
-                "For visual-restoration entries, repair project UI when comparison fails before recording a passing verdict."
-            ]
-            : [`Run ${projectScriptCommand("frontend-harness plan --json \"<task>\"")} before generating an evidence template.`]
-    };
-}
-export function recordEvidence(projectRoot, inputPath) {
-    if (!inputPath) {
-        throw new Error("evidence record requires --file <evidence-input.json>");
-    }
-    const input = resolveProjectOrHarnessRelativePath(projectRoot, inputPath, "evidence input file");
-    if (isProjectRelativeSubpath(input.relativePath, ".frontend-harness/verification")) {
-        throw new Error("evidence input file must be outside .frontend-harness/verification; use a project-local JSON file or a captured artifact under .frontend-harness/evidence/.");
-    }
-    if (isProjectRelativeSubpath(input.relativePath, ".frontend-harness") && !isProjectRelativeSubpath(input.relativePath, ".frontend-harness/evidence")) {
-        throw new Error("evidence input file under .frontend-harness must be stored below .frontend-harness/evidence/.");
-    }
-    if (!fs.existsSync(input.fullPath) || !fs.statSync(input.fullPath).isFile()) {
-        throw new Error(`evidence input file does not exist: ${input.relativePath}`);
-    }
-    const submitted = readEvidenceManifest(projectRoot, input.relativePath, { fillMissingCreatedAt: new Date().toISOString() });
-    if (!submitted.ok) {
-        throw new Error(submitted.error);
-    }
-    if (submitted.entries.length === 0) {
-        throw new Error("Evidence input must include at least one entry.");
-    }
-    const required = requiredVerificationEvidence(projectRoot);
-    const unsupported = submitted.entries.filter((entry) => !required.some((candidate) => candidate.unitId === entry.unitId && candidate.kind === entry.kind));
-    if (unsupported.length > 0) {
-        throw new Error(`Evidence input contains entries that are not required by the current plan: ${unsupported.map((entry) => `${entry.unitId}: ${entry.kind}`).join(", ")}.`);
-    }
-    const submittedRequired = submitted.entries.map((entry) => ({ unitId: entry.unitId, kind: entry.kind }));
-    const errors = validateEvidenceEntries(projectRoot, submittedRequired, submitted.entries);
-    if (errors.length > 0) {
-        throw new Error(`Evidence input failed validation: ${errors.join(" ")}`);
-    }
-    const manifestPath = ".frontend-harness/verification/evidence.json";
-    const existing = readOptionalEvidenceEntries(projectRoot, manifestPath);
-    const next = [...existing];
-    for (const entry of submitted.entries) {
-        const index = next.findIndex((candidate) => candidate.unitId === entry.unitId && candidate.kind === entry.kind);
-        if (index >= 0) {
-            next[index] = entry;
-        }
-        else {
-            next.push(entry);
-        }
-    }
-    writeJson(path.join(projectRoot, manifestPath), { entries: next });
-    return {
-        status: "passed",
-        inputPath: input.relativePath,
-        manifestPath,
-        recordedEntries: submitted.entries,
-        entryCount: next.length
-    };
-}
-export function assertDesignSourceReadyForProjectChanges(projectRoot, files) {
-    const state = loadState(projectRoot);
-    if (!requiresDesignRestorationEvidence(state)) {
-        return;
-    }
-    const existingProjectFiles = files.flatMap((file) => {
-        const trimmed = file.trim();
-        if (!trimmed || isProjectRelativeSubpath(trimmed, ".frontend-harness")) {
-            return [];
-        }
-        const normalized = normalizeProjectRelativePath(trimmed, "changed file");
-        return [normalized];
-    }).filter((file) => {
-        const fullPath = path.join(projectRoot, file);
-        return fs.existsSync(fullPath) && fs.statSync(fullPath).isFile();
-    });
-    if (existingProjectFiles.length === 0) {
-        return;
-    }
-    const changedUnitIds = new Set(state.units.filter((unit) => existingProjectFiles.includes(unit.file)).map((unit) => unit.id));
-    if (changedUnitIds.size === 0) {
-        return;
-    }
-    const prerequisiteKinds = ["design-source", "semantic-map", "visual-baseline"];
-    const required = [...changedUnitIds].flatMap((unitId) => prerequisiteKinds.map((kind) => ({ unitId, kind })));
-    const manifest = readEvidenceManifest(projectRoot, ".frontend-harness/verification/evidence.json");
-    const errors = !manifest.ok
-        ? [manifest.error]
-        : validateEvidenceEntries(projectRoot, required, manifest.entries);
-    if (errors.length > 0) {
-        throw new Error([
-            "Design restoration source files cannot be recorded as changed before design source, semantic mapping, and visual baseline evidence are recorded through evidence record --file.",
-            ...errors
-        ].join(" "));
-    }
-}
-function checkVerificationEvidence(projectRoot) {
-    const manifestPath = ".frontend-harness/verification/evidence.json";
-    const requiredEvidence = requiredVerificationEvidence(projectRoot);
-    if (requiredEvidence.length === 0) {
-        return {
-            status: "passed",
-            manifestPath,
-            requiredEvidence,
-            errors: []
-        };
-    }
-    const manifest = readEvidenceManifest(projectRoot, manifestPath);
-    if (!manifest.ok) {
-        return {
-            status: "failed",
-            manifestPath,
-            requiredEvidence,
-            errors: [manifest.error]
-        };
-    }
-    const entries = manifest.entries;
-    const errors = validateEvidenceEntries(projectRoot, requiredEvidence, entries);
-    return {
-        status: errors.length ? "failed" : "passed",
-        manifestPath,
-        requiredEvidence,
-        errors
-    };
-}
-function requiredVerificationEvidence(projectRoot) {
-    const state = loadState(projectRoot);
-    return state.units.flatMap((unit) => [...new Set(unit.verificationEvidence ?? [])]
-        .map(evidenceArtifactKind)
-        .filter((kind) => Boolean(kind))
-        .map((kind) => ({ unitId: unit.id, kind })));
-}
-function requiresDesignRestorationEvidence(state) {
-    return state.units.some((unit) => (unit.verificationEvidence ?? []).some((evidence) => evidence.toLowerCase().includes("design source")
-        || evidence.toLowerCase().includes("visual baseline")
-        || evidence.toLowerCase().includes("visual restoration")));
-}
-function evidenceArtifactKind(evidence) {
-    const normalized = evidence.toLowerCase();
-    if (normalized.includes("visual baseline") || normalized.includes("design baseline") || normalized.includes("design_to_code")) {
-        return "visual-baseline";
-    }
-    if (normalized.includes("visual")) {
-        return "visual-restoration";
-    }
-    if (normalized.includes("design source") || normalized.includes("design evidence")) {
-        return "design-source";
-    }
-    if (normalized.includes("semantic") && normalized.includes("mapping")) {
-        return "semantic-map";
-    }
-    if (normalized.includes("component behavior")) {
-        return "component-behavior";
-    }
-    if (normalized.includes("interaction")) {
-        return "interaction-smoke";
-    }
-    if (normalized.includes("responsive")) {
-        return "responsive-rendering";
-    }
-    return null;
-}
-function evidenceTemplateEntry(required, createdAt) {
-    const artifactPath = `.frontend-harness/evidence/${required.unitId}-${required.kind}.md`;
-    return {
-        unitId: required.unitId,
-        kind: required.kind,
-        artifactPaths: [artifactPath],
-        createdAt,
-        metadata: evidenceMetadataTemplate(required.kind)
-    };
-}
-function evidenceMetadataTemplate(kind) {
-    switch (kind) {
-        case "design-source":
-            return {
-                sourceType: "design-artifact | screenshot | design_to_code | generated_markup",
-                hasVisualReference: true,
-                hasStructureReference: false,
-                hasStyleReference: false,
-                referenceArtifactPaths: [".frontend-harness/evidence/<design-source-artifact>"]
-            };
-        case "semantic-map":
-            return {
-                mappedComponentCount: 1,
-                mappingActions: ["mapped <design region> to <project component or file>"]
-            };
-        case "visual-baseline":
-            return {
-                sourceType: "<actual baseline source type; use design_to_code only when generated design code exists>",
-                baselineArtifactPaths: [".frontend-harness/evidence/<baseline-or-generated-source>"],
-                viewports: ["desktop"],
-                preservedAt: "before-project-native-rewrite",
-                designToCodeOnlyFields: {
-                    usability: "usable_as_visual_baseline | usable_for_patch_reference | usable_as_source | unusable",
-                    usabilityReasons: ["required only when sourceType is design_to_code"],
-                    temporaryAssetsLocalized: false,
-                    sourceReadinessReasons: ["required only when usability is usable_as_source"]
-                }
-            };
-        case "visual-restoration":
-            return {
-                verdict: "pass",
-                score: 90,
-                threshold: 90,
-                comparisonTool: "<tool name>",
-                comparisonCommand: "<exact command or inspection procedure>",
-                viewports: ["desktop"],
-                comparedRegions: ["<region compared>"],
-                differences: ["<remaining visual difference or none>"],
-                acceptedGaps: [],
-                designArtifactPaths: [".frontend-harness/evidence/<design-screenshot>"],
-                actualArtifactPaths: [".frontend-harness/evidence/<actual-screenshot>"],
-                diffArtifactPaths: [".frontend-harness/evidence/<diff-artifact>"],
-                artifactSha256: {
-                    design: "<sha256 matching designArtifactPaths>",
-                    actual: "<sha256 matching actualArtifactPaths>",
-                    diff: "<sha256 matching diffArtifactPaths>"
-                }
-            };
-        case "responsive-rendering":
-            return {
-                viewports: ["desktop", "mobile"]
-            };
-        case "component-behavior":
-            return {
-                checkedScenarios: ["<scenario checked>"]
-            };
-        case "interaction-smoke":
-            return {
-                checkedInteractions: ["<interaction checked>"]
-            };
-        default:
-            return {};
-    }
-}
-function readEvidenceManifest(projectRoot, relativePath, options = {}) {
-    const fullPath = path.join(projectRoot, relativePath);
-    if (!fs.existsSync(fullPath)) {
-        return { ok: false, error: `Missing evidence manifest: ${relativePath}.` };
-    }
-    let parsed;
-    try {
-        parsed = readJson(fullPath);
-    }
-    catch (error) {
-        return { ok: false, error: `Evidence manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}.` };
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        return { ok: false, error: "Evidence manifest root must be an object." };
-    }
-    const entryValues = parsed["entries"];
-    if (!Array.isArray(entryValues)) {
-        return { ok: false, error: "Evidence manifest must contain an entries array." };
-    }
-    const entries = [];
-    for (const [index, entryValue] of entryValues.entries()) {
-        const entry = parseEvidenceEntry(entryValue, index, options);
-        if (!entry.ok) {
-            return { ok: false, error: entry.error };
-        }
-        entries.push(entry.entry);
-    }
-    return { ok: true, entries };
-}
-function readOptionalEvidenceEntries(projectRoot, relativePath) {
-    if (!fs.existsSync(path.join(projectRoot, relativePath))) {
-        return [];
-    }
-    const manifest = readEvidenceManifest(projectRoot, relativePath);
-    if (!manifest.ok) {
-        throw new Error(manifest.error);
-    }
-    return manifest.entries;
-}
-function parseEvidenceEntry(value, index, options = {}) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return { ok: false, error: `Evidence manifest entries[${index}] must be an object.` };
-    }
-    const entry = value;
-    const unitId = entry["unitId"];
-    const kind = entry["kind"];
-    const artifactPaths = entry["artifactPaths"];
-    const createdAt = entry["createdAt"];
-    if (typeof unitId !== "string"
-        || typeof kind !== "string"
-        || !Array.isArray(artifactPaths)
-        || artifactPaths.some((artifactPath) => typeof artifactPath !== "string")
-        || (createdAt !== undefined && typeof createdAt !== "string")
-        || (createdAt === undefined && !options.fillMissingCreatedAt)) {
-        return { ok: false, error: `Evidence manifest entries[${index}] must include string unitId, string kind, string[] artifactPaths, and string createdAt.` };
-    }
-    return {
-        ok: true,
-        entry: {
-            unitId,
-            kind,
-            artifactPaths: artifactPaths,
-            createdAt: typeof createdAt === "string" ? createdAt : options.fillMissingCreatedAt,
-            ...(isPlainRecord(entry["metadata"]) ? { metadata: entry["metadata"] } : {})
-        }
-    };
-}
-function validateEvidenceEntries(projectRoot, requiredEvidence, entries) {
-    const errors = [];
-    for (const required of requiredEvidence) {
-        const entry = entries.find((candidate) => candidate.unitId === required.unitId && candidate.kind === required.kind);
-        if (!entry) {
-            errors.push(`Missing evidence entry for ${required.unitId}: ${required.kind}.`);
-            continue;
-        }
-        if (!/^\d{4}-\d{2}-\d{2}T/.test(entry.createdAt)) {
-            errors.push(`Evidence entry for ${required.unitId}: ${required.kind} must include an ISO createdAt timestamp.`);
-        }
-        if (entry.artifactPaths.length === 0) {
-            errors.push(`Evidence entry for ${required.unitId}: ${required.kind} must include at least one artifact path.`);
-            continue;
-        }
-        for (const artifactPath of entry.artifactPaths) {
-            validateEvidenceArtifactPath(projectRoot, artifactPath, `${required.unitId}: ${required.kind}`, errors);
-        }
-        validateEvidenceMetadata(projectRoot, entry, `${required.unitId}: ${required.kind}`, errors);
-    }
-    return errors;
-}
-function validateEvidenceArtifactPath(projectRoot, artifactPath, label, errors) {
-    const normalized = path.posix.normalize(artifactPath.replace(/\\/g, "/"));
-    if (!normalized.startsWith(".frontend-harness/") || normalized.includes("..") || path.isAbsolute(artifactPath)) {
-        errors.push(`Evidence artifact for ${label} must be a project-relative path under .frontend-harness/: ${artifactPath}.`);
-        return;
-    }
-    const fullPath = path.join(projectRoot, normalized);
-    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
-        errors.push(`Evidence artifact for ${label} does not exist: ${artifactPath}.`);
-    }
-}
-function validateEvidenceMetadata(projectRoot, entry, label, errors) {
-    const metadata = entry.metadata;
-    switch (entry.kind) {
-        case "design-source":
-            requireMetadataObject(metadata, label, errors);
-            requireMetadataString(metadata, "sourceType", label, errors);
-            requireMetadataTrue(metadata, "hasVisualReference", label, errors);
-            requireMetadataBoolean(metadata, "hasStructureReference", label, errors);
-            requireMetadataBoolean(metadata, "hasStyleReference", label, errors);
-            requireMetadataArtifactPathArray(metadata, "referenceArtifactPaths", projectRoot, label, errors);
-            break;
-        case "semantic-map":
-            requireMetadataObject(metadata, label, errors);
-            requirePositiveMetadataNumber(metadata, "mappedComponentCount", label, errors);
-            requireMetadataStringArray(metadata, "mappingActions", label, errors);
-            break;
-        case "visual-restoration":
-            requireMetadataObject(metadata, label, errors);
-            requireVisualVerdict(metadata, label, errors);
-            requirePassingVisualScore(metadata, label, errors);
-            requireVisualComparisonProvenance(metadata, projectRoot, label, errors);
-            requireMetadataStringArray(metadata, "comparedRegions", label, errors);
-            requireMetadataStringArray(metadata, "differences", label, errors);
-            requireMetadataStringArray(metadata, "acceptedGaps", label, errors, { allowEmpty: true });
-            break;
-        case "visual-baseline":
-            requireMetadataObject(metadata, label, errors);
-            requireMetadataString(metadata, "sourceType", label, errors);
-            requireMetadataArtifactPathArray(metadata, "baselineArtifactPaths", projectRoot, label, errors);
-            requireMetadataStringArray(metadata, "viewports", label, errors);
-            requireMetadataString(metadata, "preservedAt", label, errors);
-            requireDesignToCodeUsability(metadata, label, errors);
-            break;
-        case "responsive-rendering":
-            requireMetadataObject(metadata, label, errors);
-            requireMetadataStringArray(metadata, "viewports", label, errors);
-            break;
-        case "component-behavior":
-            requireMetadataObject(metadata, label, errors);
-            requireMetadataStringArray(metadata, "checkedScenarios", label, errors);
-            break;
-        case "interaction-smoke":
-            requireMetadataObject(metadata, label, errors);
-            requireMetadataStringArray(metadata, "checkedInteractions", label, errors);
-            break;
-    }
-}
-function requireMetadataObject(metadata, label, errors) {
-    if (!metadata) {
-        errors.push(`Evidence entry for ${label} must include metadata.`);
-        return false;
-    }
-    return true;
-}
-function requireMetadataString(metadata, key, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    if (typeof metadata[key] !== "string" || !metadata[key].trim()) {
-        errors.push(`Evidence metadata for ${label} must include non-empty ${key}.`);
-        return;
-    }
-    if (metadata[key].includes("<") || metadata[key].includes(">")) {
-        errors.push(`Evidence metadata for ${label} must replace placeholder ${key} with real evidence.`);
-    }
-}
-function requireDesignToCodeUsability(metadata, label, errors) {
-    if (!metadata || metadata["sourceType"] !== "design_to_code") {
-        return;
-    }
-    const usability = metadata["usability"];
-    const allowed = ["usable_as_source", "usable_as_visual_baseline", "usable_for_patch_reference", "unusable"];
-    if (typeof usability !== "string" || !allowed.includes(usability)) {
-        errors.push(`Evidence metadata for ${label} with sourceType design_to_code must include usability of ${allowed.join(", ")}.`);
-    }
-    requireMetadataStringArray(metadata, "usabilityReasons", label, errors);
-    requireMetadataBoolean(metadata, "temporaryAssetsLocalized", label, errors);
-    if (usability === "usable_as_source") {
-        requireMetadataStringArray(metadata, "sourceReadinessReasons", label, errors);
-    }
-}
-function requireMetadataTrue(metadata, key, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    if (metadata[key] !== true) {
-        errors.push(`Evidence metadata for ${label} must set ${key} to true.`);
-    }
-}
-function requireMetadataBoolean(metadata, key, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    if (typeof metadata[key] !== "boolean") {
-        errors.push(`Evidence metadata for ${label} must include boolean ${key}.`);
-    }
-}
-function requirePositiveMetadataNumber(metadata, key, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    const value = metadata[key];
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        errors.push(`Evidence metadata for ${label} must include positive numeric ${key}.`);
-    }
-}
-function requireMetadataScore(metadata, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    const score = metadata["score"];
-    if (typeof score !== "number" || !Number.isFinite(score) || score < 0 || score > 100) {
-        errors.push(`Evidence metadata for ${label} must include numeric score between 0 and 100.`);
-    }
-}
-function requirePassingVisualScore(metadata, label, errors) {
-    requireMetadataScore(metadata, label, errors);
-    if (!metadata) {
-        return;
-    }
-    const score = metadata["score"];
-    if (typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 100 && score < 90) {
-        errors.push(`Evidence metadata for ${label} must include visual restoration score of at least 90.`);
-    }
-    const threshold = metadata["threshold"];
-    if (threshold !== undefined) {
-        if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold < 90 || threshold > 100) {
-            errors.push(`Evidence metadata for ${label} must include numeric threshold between 90 and 100 when threshold is present.`);
-            return;
-        }
-        if (typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 100 && score < threshold) {
-            errors.push(`Evidence metadata for ${label} must include visual restoration score greater than or equal to threshold.`);
-        }
-    }
-}
-function requireVisualVerdict(metadata, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    const verdict = metadata["verdict"];
-    if (verdict !== "pass") {
-        errors.push(`Evidence metadata for ${label} must include verdict of pass.`);
-    }
-}
-function requireVisualComparisonProvenance(metadata, projectRoot, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    requireMetadataString(metadata, "comparisonTool", label, errors);
-    requireMetadataString(metadata, "comparisonCommand", label, errors);
-    requireMetadataStringArray(metadata, "viewports", label, errors);
-    requireMetadataArtifactPathArray(metadata, "designArtifactPaths", projectRoot, label, errors);
-    requireMetadataArtifactPathArray(metadata, "actualArtifactPaths", projectRoot, label, errors);
-    requireMetadataArtifactPathArray(metadata, "diffArtifactPaths", projectRoot, label, errors);
-    requireArtifactSha256(metadata, projectRoot, label, errors);
-}
-function requireMetadataArtifactPathArray(metadata, key, projectRoot, label, errors) {
-    requireMetadataStringArray(metadata, key, label, errors);
-    if (!metadata) {
-        return;
-    }
-    const value = metadata[key];
-    if (!Array.isArray(value)) {
-        return;
-    }
-    for (const artifactPath of value) {
-        if (typeof artifactPath === "string") {
-            validateEvidenceArtifactPath(projectRoot, artifactPath, `${label} metadata ${key}`, errors);
-        }
-    }
-}
-function requireArtifactSha256(metadata, projectRoot, label, errors) {
-    if (!metadata) {
-        return;
-    }
-    const artifactSha256 = metadata["artifactSha256"];
-    if (!isPlainRecord(artifactSha256)) {
-        errors.push(`Evidence metadata for ${label} must include artifactSha256 object.`);
-        return;
-    }
-    const categories = [
-        ["design", "designArtifactPaths"],
-        ["actual", "actualArtifactPaths"],
-        ["diff", "diffArtifactPaths"]
-    ];
-    for (const [key, pathKey] of categories) {
-        const value = artifactSha256[key];
-        const artifactPaths = metadata[pathKey];
-        if (!Array.isArray(artifactPaths) || artifactPaths.some((artifactPath) => typeof artifactPath !== "string")) {
-            continue;
-        }
-        if (typeof value === "string") {
-            if (!isSha256(value)) {
-                errors.push(`Evidence metadata for ${label} must include sha256 hash for artifactSha256.${key}.`);
-                continue;
-            }
-            if (artifactPaths.length !== 1) {
-                errors.push(`Evidence metadata for ${label} must use per-path hashes for artifactSha256.${key} when multiple ${pathKey} are present.`);
-                continue;
-            }
-            requireArtifactHashMatch(projectRoot, artifactPaths[0], value, `${label} artifactSha256.${key}`, errors);
-            continue;
-        }
-        if (Array.isArray(value)) {
-            if (value.length !== artifactPaths.length || value.some((item) => typeof item !== "string" || !isSha256(item))) {
-                errors.push(`Evidence metadata for ${label} must include one sha256 hash per ${pathKey} entry for artifactSha256.${key}.`);
-                continue;
-            }
-            value.forEach((hash, index) => requireArtifactHashMatch(projectRoot, artifactPaths[index], hash, `${label} artifactSha256.${key}[${index}]`, errors));
-            continue;
-        }
-        if (isPlainRecord(value)) {
-            for (const artifactPath of artifactPaths) {
-                const hash = value[artifactPath];
-                if (typeof hash !== "string" || !isSha256(hash)) {
-                    errors.push(`Evidence metadata for ${label} must include sha256 hash for artifactSha256.${key}.${artifactPath}.`);
-                    continue;
-                }
-                requireArtifactHashMatch(projectRoot, artifactPath, hash, `${label} artifactSha256.${key}.${artifactPath}`, errors);
-            }
-            continue;
-        }
-        errors.push(`Evidence metadata for ${label} must include sha256 hash for artifactSha256.${key}.`);
-    }
-}
-function requireArtifactHashMatch(projectRoot, artifactPath, expectedHash, label, errors) {
-    const fullPath = evidenceArtifactFullPath(projectRoot, artifactPath);
-    if (!fullPath) {
-        return;
-    }
-    const actualHash = createHash("sha256").update(fs.readFileSync(fullPath)).digest("hex");
-    if (actualHash.toLowerCase() !== expectedHash.toLowerCase()) {
-        errors.push(`Evidence metadata for ${label} must match actual artifact sha256 for ${artifactPath}.`);
-    }
-}
-function evidenceArtifactFullPath(projectRoot, artifactPath) {
-    const normalized = path.posix.normalize(artifactPath.replace(/\\/g, "/"));
-    if (!normalized.startsWith(".frontend-harness/") || normalized.includes("..") || path.isAbsolute(artifactPath)) {
-        return null;
-    }
-    const fullPath = path.join(projectRoot, normalized);
-    if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) {
-        return null;
-    }
-    return fullPath;
-}
-function isSha256(value) {
-    return /^[a-f0-9]{64}$/i.test(value);
-}
-function requireMetadataStringArray(metadata, key, label, errors, options = {}) {
-    if (!metadata) {
-        return;
-    }
-    const value = metadata[key];
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string") || (!options.allowEmpty && value.length === 0)) {
-        errors.push(`Evidence metadata for ${label} must include ${options.allowEmpty ? "array" : "non-empty string array"} ${key}.`);
-    }
-}
-function isPlainRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function resolveCommands(commands) {
     return commands
         .flatMap((entry) => entry.command ? [{ name: entry.name, source: entry.source, command: entry.command }] : []);