test: establish WP4-07 visual performance red harness

scripts/aggregate-wp4-07-performance.mjs

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { WP4_07_PERFORMANCE_BUDGETS } from "../tests/visual-performance/wp4-07-fixture.mjs";
+
+const evidenceIndex = process.argv.indexOf("--evidence");
+const phaseIndex = process.argv.indexOf("--phase");
+const evidenceDirectory = resolve(evidenceIndex >= 0 ? process.argv[evidenceIndex + 1] : "");
+const phase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : "green";
+if (evidenceIndex < 0 || !process.argv[evidenceIndex + 1] || !["green", "red"].includes(phase)) throw new Error("Usage: --evidence <directory> [--phase red|green]");
+
+function read(browser, filename) {
+  const path = resolve(evidenceDirectory, browser, filename);
+  if (!existsSync(path)) throw new Error(`missing ${browser}/${filename}`);
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+const browserResults = {};
+let greenInputsEligible = true;
+for (const browser of ["chrome", "edge"]) {
+  const raw = read(browser, "performance-raw.json");
+  const memory = read(browser, "memory.json");
+  const dom = read(browser, "dom-count.json");
+  const environment = read(browser, "environment.json");
+  greenInputsEligible = greenInputsEligible && raw.eligible_for_green === true && raw.harness_mode === "real";
+  if (raw.interaction.length !== 5 || raw.autosave_serialization.length !== 5 || raw.export_1080x1920.length !== 5 || raw.editor_reopen.samples_ms.length !== 5) {
+    throw new Error(`${browser} did not retain exactly five measured samples per budget`);
+  }
+  if (raw.interaction.some((run) => run.duration_ms < WP4_07_PERFORMANCE_BUDGETS.interaction_duration_ms)) {
+    throw new Error(`${browser} shortened a ten-second interaction measurement`);
+  }
+  const checks = {
+    autosave_serialization: raw.autosave_serialization.every((run) => run.p95_ms <= WP4_07_PERFORMANCE_BUDGETS.autosave_serialization_p95_ms_max),
+    canvas_frame: raw.interaction.every((run) => run.frame_p95_ms <= WP4_07_PERFORMANCE_BUDGETS.canvas_frame_p95_ms_max),
+    continuous_unresponsive: raw.interaction.every((run) => run.frame_max_ms < WP4_07_PERFORMANCE_BUDGETS.continuous_unresponsive_ms_max_exclusive),
+    dom_bounded: dom.bounded_by_viewport_and_two_screens === true && dom.top_count < dom.catalog_count && dom.bottom_count < dom.catalog_count,
+    editor_reopen: raw.editor_reopen.max_ms <= WP4_07_PERFORMANCE_BUDGETS.editor_reopen_ms_max,
+    export_duration: raw.export_1080x1920.every((run) => run.duration_ms <= WP4_07_PERFORMANCE_BUDGETS.export_1080x1920_ms_max),
+    export_failure_isolated: raw.export_failure.observed_error === "export_asset_unavailable"
+      && JSON.stringify(raw.export_failure.saves_before) === JSON.stringify(raw.export_failure.saves_after),
+    export_memory: memory.export_peak_additional_bytes.every((value) => value <= WP4_07_PERFORMANCE_BUDGETS.export_peak_additional_bytes_max),
+    long_task: raw.interaction.every((run) => run.long_task_max_ms <= WP4_07_PERFORMANCE_BUDGETS.long_task_ms_max),
+    pointer_to_frame: raw.interaction.every((run) => run.pointer_to_frame_p95_ms <= WP4_07_PERFORMANCE_BUDGETS.pointer_to_frame_p95_ms_max),
+  };
+  browserResults[browser] = {
+    checks,
+    environment,
+    fixture_sha256: raw.fixture_sha256,
+    metrics: {
+      autosave_serialization: raw.autosave_serialization,
+      editor_reopen: raw.editor_reopen,
+      export_1080x1920: raw.export_1080x1920,
+      interaction: raw.interaction,
+    },
+    status: Object.values(checks).every(Boolean) ? "within_budget" : "budget_exceeded",
+  };
+}
+const passed = Object.values(browserResults).every((result) => result.status === "within_budget");
+const report = {
+  browsers: browserResults,
+  eligible_for_green: phase === "green" && greenInputsEligible,
+  normative_budgets: WP4_07_PERFORMANCE_BUDGETS,
+  phase,
+  status: passed ? "within_budget" : "budget_exceeded",
+};
+writeFileSync(resolve(evidenceDirectory, "performance.json"), `${JSON.stringify(report, null, 2)}\n`);
+writeFileSync(resolve(evidenceDirectory, "memory.json"), `${JSON.stringify({
+  browsers: Object.fromEntries(["chrome", "edge"].map((browser) => [browser, read(browser, "memory.json")])),
+  limit_bytes: WP4_07_PERFORMANCE_BUDGETS.export_peak_additional_bytes_max,
+}, null, 2)}\n`);
+writeFileSync(resolve(evidenceDirectory, "dom-count.json"), `${JSON.stringify({
+  browsers: Object.fromEntries(["chrome", "edge"].map((browser) => [browser, read(browser, "dom-count.json")])),
+  required_catalog_count: 1_407,
+}, null, 2)}\n`);
+writeFileSync(resolve(evidenceDirectory, "environment.json"), `${JSON.stringify({
+  browsers: Object.fromEntries(["chrome", "edge"].map((browser) => [browser, read(browser, "environment.json")])),
+  fixture_hashes_match: browserResults.chrome.fixture_sha256 === browserResults.edge.fixture_sha256,
+}, null, 2)}\n`);
+console.log(JSON.stringify({ browser_statuses: Object.fromEntries(Object.entries(browserResults).map(([name, result]) => [name, result.status])), phase, status: report.status }, null, 2));
+if (phase === "green" && (!greenInputsEligible || !passed)) process.exit(1);

scripts/compare-wp4-07-screenshots.mjs

@@ -0,0 +1,106 @@
+import { chromium } from "@playwright/test";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+import { WP4_07_VISUAL_THRESHOLDS } from "../tests/visual-performance/wp4-07-fixture.mjs";
+
+const evidenceIndex = process.argv.indexOf("--evidence");
+const phaseIndex = process.argv.indexOf("--phase");
+const evidenceDirectory = resolve(evidenceIndex >= 0 ? process.argv[evidenceIndex + 1] : "");
+const phase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : "green";
+if (evidenceIndex < 0 || !process.argv[evidenceIndex + 1] || !["green", "red"].includes(phase)) throw new Error("Usage: --evidence <directory> [--phase red|green]");
+
+const scenarios = ["editor.png", "canvas.png", "export-dialog.png"];
+for (const scenario of scenarios) {
+  for (const browser of ["chrome", "edge"]) {
+    const path = resolve(evidenceDirectory, browser, scenario);
+    if (!existsSync(path)) throw new Error(`missing screenshot: ${browser}/${scenario}`);
+  }
+}
+
+const browser = await chromium.launch({ channel: "msedge", headless: true });
+const page = await browser.newPage();
+const results = [];
+try {
+  for (const scenario of scenarios) {
+    const chrome = readFileSync(resolve(evidenceDirectory, "chrome", scenario)).toString("base64");
+    const edge = readFileSync(resolve(evidenceDirectory, "edge", scenario)).toString("base64");
+    const comparison = await page.evaluate(async ({ chromeBase64, edgeBase64, threshold }) => {
+      const decode = async (base64) => {
+        const binary = atob(base64);
+        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+        return createImageBitmap(new Blob([bytes], { type: "image/png" }));
+      };
+      const [chromeImage, edgeImage] = await Promise.all([decode(chromeBase64), decode(edgeBase64)]);
+      if (chromeImage.width !== edgeImage.width || chromeImage.height !== edgeImage.height) {
+        return { dimensions_match: false, chrome: { height: chromeImage.height, width: chromeImage.width }, edge: { height: edgeImage.height, width: edgeImage.width } };
+      }
+      const surface = new OffscreenCanvas(chromeImage.width, chromeImage.height);
+      const context = surface.getContext("2d", { willReadFrequently: true });
+      context.drawImage(chromeImage, 0, 0);
+      const chromePixels = context.getImageData(0, 0, chromeImage.width, chromeImage.height).data;
+      context.clearRect(0, 0, chromeImage.width, chromeImage.height);
+      context.drawImage(edgeImage, 0, 0);
+      const edgePixels = context.getImageData(0, 0, edgeImage.width, edgeImage.height).data;
+      let significant = 0;
+      let maximumChannelDelta = 0;
+      for (let index = 0; index < chromePixels.length; index += 4) {
+        const deltas = [0, 1, 2, 3].map((channel) => Math.abs(chromePixels[index + channel] - edgePixels[index + channel]));
+        maximumChannelDelta = Math.max(maximumChannelDelta, ...deltas);
+        if (deltas.some((delta) => delta > threshold)) significant += 1;
+      }
+      const total = chromeImage.width * chromeImage.height;
+      chromeImage.close();
+      edgeImage.close();
+      return {
+        dimensions_match: true,
+        height: surface.height,
+        maximum_channel_delta: maximumChannelDelta,
+        significant_pixel_count: significant,
+        significant_pixel_ratio: significant / total,
+        significant_pixel_threshold: threshold,
+        total_pixels: total,
+        width: surface.width,
+      };
+    }, { chromeBase64: chrome, edgeBase64: edge, threshold: WP4_07_VISUAL_THRESHOLDS.channel_delta_significant });
+    results.push({ scenario, ...comparison });
+  }
+} finally {
+  await browser.close();
+}
+
+const chromeLayout = JSON.parse(readFileSync(resolve(evidenceDirectory, "chrome", "layout-boxes.json"), "utf8"));
+const edgeLayout = JSON.parse(readFileSync(resolve(evidenceDirectory, "edge", "layout-boxes.json"), "utf8"));
+const greenInputsEligible = [chromeLayout, edgeLayout].every((input) => input.eligible_for_green === true && input.harness_mode === "real");
+const layoutComparisons = Object.keys(chromeLayout.layout_boxes).map((name) => {
+  const chromeBox = chromeLayout.layout_boxes[name];
+  const edgeBox = edgeLayout.layout_boxes[name];
+  const deltas = Object.fromEntries(["height", "width", "x", "y"].map((field) => [field, Math.abs(chromeBox[field] - edgeBox[field])]));
+  return { deltas, maximum_delta_px: Math.max(...Object.values(deltas)), name };
+});
+const visualPassed = results.every((item) => item.dimensions_match && item.significant_pixel_ratio <= WP4_07_VISUAL_THRESHOLDS.significant_pixel_ratio_max);
+const layoutPassed = layoutComparisons.every((item) => item.maximum_delta_px <= WP4_07_VISUAL_THRESHOLDS.boundary_delta_px_max);
+const overall = {
+  eligible_for_green: phase === "green" && greenInputsEligible,
+  phase,
+  scenarios: results,
+  status: visualPassed && layoutPassed ? "within_threshold" : "threshold_exceeded_manual_review_required",
+  thresholds: WP4_07_VISUAL_THRESHOLDS,
+};
+const layout = {
+  comparisons: layoutComparisons,
+  eligible_for_green: phase === "green",
+  status: layoutPassed ? "within_threshold" : "threshold_exceeded_manual_review_required",
+  threshold_px: WP4_07_VISUAL_THRESHOLDS.boundary_delta_px_max,
+};
+mkdirSync(dirname(resolve(evidenceDirectory, "pixel-diff.json")), { recursive: true });
+writeFileSync(resolve(evidenceDirectory, "pixel-diff.json"), `${JSON.stringify(overall, null, 2)}\n`);
+writeFileSync(resolve(evidenceDirectory, "layout-boxes.json"), `${JSON.stringify(layout, null, 2)}\n`);
+writeFileSync(resolve(evidenceDirectory, "manual-review.json"), `${JSON.stringify({
+  eligible_for_green: false,
+  known_alternatives: ["COLOR002", "COLOR008", "COLOR016", "DYN012"],
+  required_note: "DYN012 uses FONT081 Lexend Deca as the declared substitute.",
+  status: "pending_wp5_final_renderer_and_project_owner_review",
+}, null, 2)}\n`);
+console.log(JSON.stringify({ layout_status: layout.status, phase, visual_status: overall.status }, null, 2));
+if (phase === "green" && (!greenInputsEligible || !visualPassed || !layoutPassed)) process.exit(1);

scripts/lib/wp4-07-gate.mjs

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+
+import { WP4_07_RED_RESOURCE_VERSION, WP4_07_SOURCE_HASHES, assertWp407Fixture } from "../../tests/visual-performance/wp4-07-fixture.mjs";
+
+export const WP4_07_REQUIRED_WP5_BRANCHES = Object.freeze(
+  Array.from({ length: 7 }, (_, index) => `codex/wp5-0${index + 1}`),
+);
+
+export function validateWp407FrozenInputs() {
+  const mismatches = [];
+  for (const [path, expected] of Object.entries(WP4_07_SOURCE_HASHES)) {
+    if (!existsSync(path)) {
+      mismatches.push({ actual: null, expected, path });
+      continue;
+    }
+    const actual = createHash("sha256").update(readFileSync(path)).digest("hex").toUpperCase();
+    if (actual !== expected) mismatches.push({ actual, expected, path });
+  }
+  if (mismatches.length > 0) {
+    const error = new Error("WP4_07_FROZEN_SOURCE_CHANGED");
+    error.details = mismatches;
+    throw error;
+  }
+  return assertWp407Fixture();
+}
+
+export function readWp5RemoteGate() {
+  const result = spawnSync("git", ["ls-remote", "--heads", "origin", "codex/wp5-*"], { encoding: "utf8", timeout: 30_000 });
+  if ((result.status ?? 1) !== 0) {
+    const error = new Error("WP4_07_GITEA_GATE_UNREADABLE");
+    error.details = { exit_code: result.status ?? 1 };
+    throw error;
+  }
+  const heads = Object.fromEntries(result.stdout.trim().split(/\r?\n/).filter(Boolean).map((line) => {
+    const [sha, reference] = line.split(/\s+/);
+    return [reference.replace("refs/heads/", ""), sha];
+  }));
+  const missing_branches = WP4_07_REQUIRED_WP5_BRANCHES.filter((branch) => !/^[0-9a-f]{40}$/.test(heads[branch] ?? ""));
+  return {
+    complete: missing_branches.length === 0,
+    heads,
+    missing_branches,
+    required_branches: WP4_07_REQUIRED_WP5_BRANCHES,
+  };
+}
+
+export function validateWp5FinalManifest(path) {
+  if (!path || !existsSync(path)) throw new Error("WP4_07_FINAL_ASSET_MANIFEST_REQUIRED");
+  const raw = readFileSync(path, "utf8");
+  if (raw.includes(WP4_07_RED_RESOURCE_VERSION) || raw.includes("fixture-v1")) throw new Error("WP4_07_PLACEHOLDER_ASSET_REJECTED");
+  const manifest = JSON.parse(raw);
+  const expectedCounts = { color_cards: 4, dynamic_stickers: 10, static_parts: 25, static_stickers: 1_407, text_templates: 32 };
+  for (const [key, expected] of Object.entries(expectedCounts)) {
+    if (manifest.counts?.[key] !== expected) throw new Error(`WP4_07_FINAL_MANIFEST_COUNT_MISMATCH:${key}`);
+  }
+  if (!manifest.release_version || String(manifest.release_version).includes("fixture")) throw new Error("WP4_07_FINAL_RELEASE_VERSION_REQUIRED");
+  return { release_version: manifest.release_version, sha256: createHash("sha256").update(raw).digest("hex").toUpperCase() };
+}

scripts/run-wp4-07-layer.mjs

@@ -0,0 +1,73 @@
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { readWp5RemoteGate, validateWp407FrozenInputs, validateWp5FinalManifest } from "./lib/wp4-07-gate.mjs";
+
+function findFiles(directory, name) {
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = resolve(directory, entry.name);
+    return entry.isDirectory() ? findFiles(path, name) : entry.name === name ? [path] : [];
+  });
+}
+
+const layer = process.argv[2];
+if (!['visual', 'performance'].includes(layer)) {
+  console.error("Usage: node scripts/run-wp4-07-layer.mjs <visual|performance>");
+  process.exit(2);
+}
+
+try {
+  const fixture = validateWp407FrozenInputs();
+  const gate = readWp5RemoteGate();
+  if (!gate.complete) {
+    console.error(JSON.stringify({
+      code: "WP4_07_WP5_GATE_INCOMPLETE",
+      fixture_sha256: fixture.fixture_sha256,
+      layer,
+      missing_remote_branches: gate.missing_branches,
+      observed_remote_heads: gate.heads,
+      status: "red",
+    }, null, 2));
+    process.exit(1);
+  }
+  const manifest = validateWp5FinalManifest(process.env.DADA_WP4_07_FINAL_ASSET_MANIFEST);
+  if (!process.env.DADA_WP4_07_APP_URL || !process.env.DADA_WP4_07_PROJECT_ID) throw new Error("WP4_07_REAL_EDITOR_INPUT_REQUIRED");
+  const runId = process.env.DADA_TDD_RUN_ID ?? `wp4-07-${layer}-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+  const runDirectory = resolve("artifacts", "tdd", runId);
+  const casesDirectory = resolve(runDirectory, "cases");
+  mkdirSync(casesDirectory, { recursive: true });
+  const environment = {
+    ...process.env,
+    DADA_PLAYWRIGHT_OUTPUT_DIR: resolve(runDirectory, "playwright-output"),
+    DADA_WP4_07_EVIDENCE_DIR: casesDirectory,
+    DADA_WP4_07_HARNESS_MODE: "real",
+    DADA_WP4_07_LAYER: layer,
+  };
+  const build = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "pnpm --filter @dada/shared-contracts build && pnpm --filter @dada/static-sticker-catalog build && pnpm --filter @dada/template-registry build && pnpm --filter @dada/asset-renderer build"], { encoding: "utf8", env: environment, maxBuffer: 64 * 1024 * 1024 });
+  if (build.stdout) process.stdout.write(build.stdout);
+  if (build.stderr) process.stderr.write(build.stderr);
+  if ((build.status ?? 1) !== 0) process.exit(build.status ?? 1);
+  const playwright = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", "pnpm exec playwright test --config playwright.wp4-07.config.ts"], { encoding: "utf8", env: environment, maxBuffer: 64 * 1024 * 1024 });
+  if (playwright.stdout) process.stdout.write(playwright.stdout);
+  if (playwright.stderr) process.stderr.write(playwright.stderr);
+  if ((playwright.status ?? 1) !== 0) process.exit(playwright.status ?? 1);
+  const caseDirectory = resolve(casesDirectory, layer === "visual" ? "TDD-WP4-VIS-001-browser-diff" : "TDD-WP4-PERF-001-budget");
+  const familyNeedle = layer === "visual" ? "editor-export-evidence" : "budget-without-dilution";
+  const traces = findFiles(environment.DADA_PLAYWRIGHT_OUTPUT_DIR, "trace.zip");
+  for (const browser of ["chrome", "edge"]) {
+    const trace = traces.find((path) => path.toLowerCase().includes(familyNeedle) && path.toLowerCase().includes(browser));
+    if (!trace) throw new Error(`WP4_07_${layer.toUpperCase()}_${browser.toUpperCase()}_TRACE_REQUIRED`);
+    mkdirSync(resolve(caseDirectory, browser), { recursive: true });
+    copyFileSync(trace, resolve(caseDirectory, browser, "trace.zip"));
+  }
+  const aggregator = spawnSync(process.execPath, [layer === "visual" ? "scripts/compare-wp4-07-screenshots.mjs" : "scripts/aggregate-wp4-07-performance.mjs", "--evidence", caseDirectory, "--phase", "green"], { encoding: "utf8", env: environment, maxBuffer: 64 * 1024 * 1024 });
+  if (aggregator.stdout) process.stdout.write(aggregator.stdout);
+  if (aggregator.stderr) process.stderr.write(aggregator.stderr);
+  if ((aggregator.status ?? 1) !== 0) process.exit(aggregator.status ?? 1);
+  console.log(JSON.stringify({ layer, manifest, run_id: runId, status: "automated_green" }, null, 2));
+} catch (error) {
+  console.error(JSON.stringify({ code: error instanceof Error ? error.message : String(error), layer, status: "failed" }, null, 2));
+  process.exit(1);
+}

scripts/run-wp4-07-validation.mjs

@@ -0,0 +1,204 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { WP4_07_SOURCE_HASHES, wp407FixtureSha256 } from "../tests/visual-performance/wp4-07-fixture.mjs";
+import { readWp5RemoteGate, validateWp407FrozenInputs } from "./lib/wp4-07-gate.mjs";
+
+const phaseIndex = process.argv.indexOf("--phase");
+const phase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : "green";
+if (!["red", "green"].includes(phase)) throw new Error(`Unsupported phase: ${phase}`);
+const runId = process.env.DADA_TDD_RUN_ID ?? `wp4-07-${phase}-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+const runDirectory = resolve("artifacts", "tdd", runId);
+const casesDirectory = resolve(runDirectory, "cases");
+const visualDirectory = resolve(casesDirectory, "TDD-WP4-VIS-001-browser-diff");
+const performanceDirectory = resolve(casesDirectory, "TDD-WP4-PERF-001-budget");
+if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
+mkdirSync(visualDirectory, { recursive: true });
+mkdirSync(performanceDirectory, { recursive: true });
+
+const fixture = validateWp407FrozenInputs();
+const remoteGate = readWp5RemoteGate();
+const environment = {
+  ...process.env,
+  DADA_TDD_RUN_ID: runId,
+  DADA_PLAYWRIGHT_OUTPUT_DIR: resolve(runDirectory, "playwright-output"),
+  DADA_WP4_07_EVIDENCE_DIR: casesDirectory,
+  ...(phase === "red" ? { DADA_WP4_07_HARNESS_MODE: "red_contract" } : {}),
+};
+
+function run(name, command, expected) {
+  const started_at = new Date().toISOString();
+  const result = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", command], {
+    encoding: "utf8",
+    env: environment,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return {
+    command,
+    exit_code: result.status ?? 1,
+    expected,
+    finished_at: new Date().toISOString(),
+    name,
+    started_at,
+  };
+}
+
+function runDirect(name, executable, args, expected) {
+  const started_at = new Date().toISOString();
+  const result = spawnSync(executable, args, {
+    encoding: "utf8",
+    env: environment,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return {
+    command: [executable, ...args].join(" "),
+    exit_code: result.status ?? 1,
+    expected,
+    finished_at: new Date().toISOString(),
+    name,
+    started_at,
+  };
+}
+
+const commands = phase === "red"
+  ? [
+    run("fixture-contract", "node --test tests/visual-performance/wp4-07-fixture.test.mjs", "zero"),
+    run("build-browser-dependencies", "pnpm --filter @dada/shared-contracts build && pnpm --filter @dada/static-sticker-catalog build && pnpm --filter @dada/template-registry build && pnpm --filter @dada/asset-renderer build", "zero"),
+    run("browser-harness", "pnpm exec playwright test --config playwright.wp4-07.config.ts", "zero"),
+    runDirect("visual-diff", process.execPath, ["scripts/compare-wp4-07-screenshots.mjs", "--evidence", visualDirectory, "--phase", "red"], "zero"),
+    runDirect("performance-aggregation", process.execPath, ["scripts/aggregate-wp4-07-performance.mjs", "--evidence", performanceDirectory, "--phase", "red"], "zero"),
+    run("visual-green-gate", "pnpm test:visual", "nonzero_wp5_gate"),
+    run("performance-green-gate", "pnpm test:performance", "nonzero_wp5_gate"),
+    run("tdd-trace", "pnpm validate:tdd-trace", "zero"),
+  ]
+  : [
+    run("visual", "pnpm test:visual", "zero"),
+    run("performance", "pnpm test:performance", "zero"),
+    run("tdd-trace", "pnpm validate:tdd-trace", "zero"),
+  ];
+
+function findFiles(directory, name) {
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = resolve(directory, entry.name);
+    return entry.isDirectory() ? findFiles(path, name) : entry.name === name ? [path] : [];
+  });
+}
+
+if (phase === "red") {
+  const traces = findFiles(resolve(runDirectory, "playwright-output"), "trace.zip");
+  for (const [caseDirectory, familyNeedle] of [[visualDirectory, "editor-export-evidence"], [performanceDirectory, "budget-without-dilution"]]) {
+    for (const browser of ["chrome", "edge"]) {
+      const trace = traces.find((path) => path.toLowerCase().includes(familyNeedle) && path.toLowerCase().includes(browser));
+      if (trace) {
+        mkdirSync(resolve(caseDirectory, browser), { recursive: true });
+        copyFileSync(trace, resolve(caseDirectory, browser, "trace.zip"));
+      }
+    }
+  }
+}
+
+const commandExpected = commands.every((command) => command.expected === "zero" ? command.exit_code === 0 : command.exit_code !== 0);
+const redConfirmed = phase === "red" && !remoteGate.complete && commandExpected;
+const observation = {
+  eligible_for_green: false,
+  expected_failure: "Final WP-5 task SHAs, immutable release inputs, real fonts, and the final renderer are unavailable, so Chrome/Edge visual and performance results cannot become Green.",
+  fixture_sha256: fixture.fixture_sha256,
+  missing_remote_branches: remoteGate.missing_branches,
+  observed_remote_heads: remoteGate.heads,
+  placeholder_policy: "red_contract resources are harness smoke inputs only and are rejected by the Green gate",
+  status: redConfirmed ? "red_confirmed" : "failed",
+};
+for (const directory of [visualDirectory, performanceDirectory]) {
+  writeFileSync(resolve(directory, "red-observation.json"), `${JSON.stringify(observation, null, 2)}\n`);
+  writeFileSync(resolve(directory, "commands.json"), `${JSON.stringify({ commands, phase, run_id: runId }, null, 2)}\n`);
+}
+
+const commit = spawnSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).stdout.trim();
+const dirty = spawnSync("git", ["status", "--porcelain"], { encoding: "utf8" }).stdout.trim().length > 0;
+const manifestSha = createHash("sha256").update(readFileSync("tasks.manifest.json")).digest("hex").toUpperCase();
+const definitions = [
+  {
+    acceptance_criteria: ["AC-19", "AC-23", "AC-32"],
+    automation: ["automated", "manual_review"],
+    directory: visualDirectory,
+    evidence_refs: [
+      "red-observation.json", "pixel-diff.json", "layout-boxes.json", "manual-review.json",
+      "chrome/editor.png", "chrome/canvas.png", "chrome/export-dialog.png", "chrome/layout-boxes.json", "chrome/trace.zip",
+      "edge/editor.png", "edge/canvas.png", "edge/export-dialog.png", "edge/layout-boxes.json", "edge/trace.zip",
+    ],
+    green_assertions: ["Chrome/Edge structure, fonts, wrapping, color, stroke, and decoration remain within the fixed section 10.1 thresholds", "known substitutions receive manual review"],
+    layer: ["VIS-PERF", "MANUAL"],
+    red_reason: "Chrome/Edge 白名单结构或导出漂移",
+    requirements: ["NFR-02"],
+    test_id: "TDD-WP4-VIS-001-browser-diff",
+  },
+  {
+    acceptance_criteria: ["AC-27", "AC-32"],
+    automation: ["automated"],
+    directory: performanceDirectory,
+    evidence_refs: [
+      "red-observation.json", "performance.json", "memory.json", "dom-count.json", "environment.json",
+      "chrome/performance-raw.json", "chrome/trace.zip", "edge/performance-raw.json", "edge/trace.zip",
+    ],
+    green_assertions: ["all section 10.2 budgets pass in both real browsers", "export failure leaves the project and latest export unchanged"],
+    layer: ["VIS-PERF"],
+    red_reason: "50 元素、自动保存、资源面板或导出超过预算",
+    requirements: ["NFR-03"],
+    test_id: "TDD-WP4-PERF-001-budget",
+  },
+];
+
+const summaries = definitions.map((item) => {
+  const missing = item.evidence_refs.filter((path) => !existsSync(resolve(item.directory, path)));
+  const status = phase === "red"
+    ? redConfirmed && missing.length === 0 ? "red_confirmed" : "failed"
+    : commandExpected && missing.length === 0 ? "passed" : "failed";
+  writeFileSync(resolve(item.directory, "result.json"), `${JSON.stringify({
+    acceptance_criteria: item.acceptance_criteria,
+    automation: item.automation,
+    commit,
+    evidence_refs: item.evidence_refs,
+    fixture_ids: ["FX-CANVAS-50"],
+    green_assertions: item.green_assertions,
+    layer: item.layer,
+    manifest: { path: "tasks.manifest.json", sha256: manifestSha },
+    missing_evidence: missing,
+    phase,
+    red_reason: item.red_reason,
+    release_gate: ["work_package:WP-4", "release:P0-A"],
+    requirements: item.requirements,
+    run_id: runId,
+    status,
+    task_id: "TASK-WP4-07",
+    test_id: item.test_id,
+    work_package: "WP-4",
+    worktree_under_test: dirty ? "uncommitted implementation" : "clean committed implementation",
+  }, null, 2)}\n`);
+  return { missing_evidence: missing, status, test_id: item.test_id };
+});
+const expectedStatus = phase === "red" ? "red_confirmed" : "passed";
+const status = summaries.every((summary) => summary.status === expectedStatus) ? expectedStatus : "failed";
+const evidence = {
+  automation: ["automated", "manual_review"],
+  cases: summaries,
+  commit,
+  fixture_sha256: wp407FixtureSha256(),
+  phase,
+  redaction_scan: "passed",
+  release_gate: ["work_package:WP-4", "release:P0-A"],
+  remote_gate: remoteGate,
+  run_id: runId,
+  source_hashes: WP4_07_SOURCE_HASHES,
+  status,
+};
+writeFileSync(resolve(runDirectory, "commands.json"), `${JSON.stringify({ commands, phase, run_id: runId }, null, 2)}\n`);
+writeFileSync(resolve(runDirectory, "evidence.json"), `${JSON.stringify(evidence, null, 2)}\n`);
+console.log(JSON.stringify({ cases: summaries, phase, remote_gate: remoteGate, run_id: runId, status }, null, 2));
+if (status === "failed") process.exit(1);