@blazediff/agent 0.0.1

package/dist/cli.js

@@ -0,0 +1,3205 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var playwright = require('playwright');
+var child_process = require('child_process');
+var fs = require('fs');
+var module$1 = require('module');
+var path2 = require('path');
+var promises = require('fs/promises');
+var os = require('os');
+var crypto$1 = require('crypto');
+var coreNative = require('@blazediff/core-native');
+var sharp = require('sharp');
+var promises$1 = require('readline/promises');
+var url = require('url');
+var net = require('net');
+var util = require('util');
+var treeKill = require('tree-kill');
+var langgraph = require('@langchain/langgraph');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var sharp__default = /*#__PURE__*/_interopDefault(sharp);
+var treeKill__default = /*#__PURE__*/_interopDefault(treeKill);
+
+var FROZEN_NOW = Date.UTC(2025, 0, 1, 0, 0, 0);
+var STABILITY_CSS = `
+*,*::before,*::after{
+	animation-delay:-0.0001s !important;
+	animation-duration:0s !important;
+	animation-iteration-count:1 !important;
+	transition-delay:0s !important;
+	transition-duration:0s !important;
+	caret-color:transparent !important;
+}
+html{scroll-behavior:auto !important}
+`;
+var CHROMIUM_FLAGS = [
+  "--font-render-hinting=none",
+  "--disable-skia-runtime-opts",
+  "--force-color-profile=srgb",
+  "--disable-lcd-text",
+  "--disable-background-timer-throttling",
+  "--disable-renderer-backgrounding",
+  "--disable-backgrounding-occluded-windows",
+  "--hide-scrollbars"
+];
+var cachedBrowser = null;
+var launchInFlight = null;
+async function getBrowser() {
+  if (cachedBrowser?.isConnected()) return cachedBrowser;
+  if (launchInFlight) return launchInFlight;
+  launchInFlight = playwright.chromium.launch({ headless: true, args: CHROMIUM_FLAGS }).then((b) => {
+    cachedBrowser = b;
+    return b;
+  }).finally(() => {
+    launchInFlight = null;
+  });
+  return launchInFlight;
+}
+async function closeBrowser() {
+  if (launchInFlight) {
+    await launchInFlight.catch(() => {
+    });
+  }
+  if (!cachedBrowser) return;
+  await cachedBrowser.close().catch(() => {
+  });
+  cachedBrowser = null;
+}
+async function openStableContext(opts) {
+  const browser = await getBrowser();
+  const context = await browser.newContext({
+    viewport: opts.viewport,
+    deviceScaleFactor: 1,
+    reducedMotion: "reduce",
+    forcedColors: "none",
+    colorScheme: "light",
+    bypassCSP: true
+  });
+  await context.addInitScript(
+    ({ frozenNow }) => {
+      Object.defineProperty(Date, "now", {
+        value: () => frozenNow,
+        writable: true,
+        configurable: true
+      });
+      let perfTick = 0;
+      Object.defineProperty(performance, "now", {
+        value: () => {
+          perfTick += 16.6667;
+          return perfTick;
+        },
+        writable: true,
+        configurable: true
+      });
+      let seed = 2654435769 | 0;
+      Math.random = () => {
+        seed = seed + 1831565813 | 0;
+        let t = seed;
+        t = Math.imul(t ^ t >>> 15, t | 1);
+        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+      };
+      if (typeof crypto !== "undefined") {
+        let uuidCounter = 0;
+        Object.defineProperty(crypto, "randomUUID", {
+          value: () => {
+            uuidCounter += 1;
+            return `00000000-0000-4000-8000-${uuidCounter.toString(16).padStart(12, "0")}`;
+          },
+          writable: true,
+          configurable: true
+        });
+      }
+    },
+    { frozenNow: FROZEN_NOW }
+  );
+  const page = await context.newPage();
+  const injectStability = () => page.addStyleTag({ content: STABILITY_CSS }).catch(() => {
+  });
+  await injectStability();
+  page.on("load", injectStability);
+  return { context, page };
+}
+async function waitForStability(page, waitFor) {
+  for (const w of waitFor) {
+    if (w === "networkidle") {
+      await page.waitForLoadState("networkidle").catch(() => {
+      });
+    } else if (w === "fonts") {
+      await page.evaluate(
+        () => document.fonts && "ready" in document.fonts ? document.fonts.ready.then(() => void 0) : void 0
+      ).catch(() => {
+      });
+    } else {
+      await page.waitForSelector(w.selector, { timeout: w.timeoutMs ?? 5e3 }).catch(() => {
+      });
+    }
+  }
+}
+var DEFAULT_MASK_ATTR = "data-blazediff-agent-mask";
+var DEFAULT_MASK_SELECTOR = `[${DEFAULT_MASK_ATTR}]`;
+async function applyMaskOverlays(page, masks) {
+  const selectors = [DEFAULT_MASK_SELECTOR, ...masks];
+  await page.evaluate((selectors2) => {
+    for (const sel of selectors2) {
+      for (const el of Array.from(
+        document.querySelectorAll(sel)
+      )) {
+        const rect = el.getBoundingClientRect();
+        const overlay = document.createElement("div");
+        overlay.style.position = "absolute";
+        overlay.style.left = `${rect.left + window.scrollX}px`;
+        overlay.style.top = `${rect.top + window.scrollY}px`;
+        overlay.style.width = `${rect.width}px`;
+        overlay.style.height = `${rect.height}px`;
+        overlay.style.background = "#ff00ff";
+        overlay.style.zIndex = "2147483647";
+        overlay.style.pointerEvents = "none";
+        overlay.setAttribute("data-blazediff-mask", "1");
+        document.body.appendChild(overlay);
+      }
+    }
+  }, selectors);
+}
+function resolvePlaywrightCli() {
+  const require_ = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
+  const pkgJson = require_.resolve("playwright/package.json");
+  const dir = path2__default.default.dirname(pkgJson);
+  const candidates = [
+    path2__default.default.join(dir, "cli.js"),
+    path2__default.default.join(dir, "lib", "cli.js")
+  ];
+  const found = candidates.find((p) => fs.existsSync(p));
+  if (!found) {
+    throw new Error(`could not locate playwright CLI under ${dir}`);
+  }
+  return found;
+}
+async function readExecutablePath() {
+  try {
+    const require_ = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
+    const pw = require_("playwright");
+    const p = pw.chromium.executablePath();
+    return p && fs.existsSync(p) ? p : null;
+  } catch {
+    return null;
+  }
+}
+async function installBrowsers(opts = {}) {
+  const cliPath = resolvePlaywrightCli();
+  if (opts.check) {
+    const executablePath2 = await readExecutablePath();
+    return { installed: Boolean(executablePath2), executablePath: executablePath2, cliPath };
+  }
+  await new Promise((resolve, reject) => {
+    const child = child_process.spawn(process.execPath, [cliPath, "install", "chromium"], {
+      stdio: ["ignore", "inherit", "inherit"],
+      env: process.env
+    });
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else
+        reject(
+          new Error(`playwright install chromium exited with code ${code}`)
+        );
+    });
+    child.on("error", reject);
+  });
+  const executablePath = await readExecutablePath();
+  return { installed: Boolean(executablePath), executablePath, cliPath };
+}
+
+// src/cli/commands/browsers.ts
+function registerBrowsers(program, out) {
+  const cmd = program.command("browsers").description("manage browser binaries");
+  cmd.addCommand(
+    new commander.Command("install").description(
+      "install Playwright Chromium using the bundled playwright (no sudo, no --with-deps)"
+    ).option("--check", "only check whether chromium is already installed").action(async (opts) => {
+      const result = await installBrowsers({ check: Boolean(opts.check) });
+      const human = result.installed ? `chromium ready at ${result.executablePath}` : opts.check ? "chromium not installed (run `blazediff-agent browsers install`)" : "chromium installed";
+      out.emit({ ok: true, ...result }, human);
+    })
+  );
+}
+var DEFAULT_VIEWPORT = { width: 1280, height: 800 };
+var DEFAULT_WAIT_FOR = ["networkidle", "fonts"];
+var DEFAULT_FULL_PAGE = true;
+var DEFAULT_THRESHOLD = 0.1;
+var DEFAULT_PORT = 3e3;
+var DEFAULT_READY_TIMEOUT_MS = 6e4;
+var MIN_AUTO_CONCURRENCY = 2;
+var MAX_AUTO_CONCURRENCY = 8;
+function defaultConcurrency() {
+  const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+  if (!cores || !Number.isFinite(cores)) return MIN_AUTO_CONCURRENCY;
+  return Math.max(
+    MIN_AUTO_CONCURRENCY,
+    Math.min(MAX_AUTO_CONCURRENCY, cores - 1)
+  );
+}
+var BLAZEDIFF_DIR = ".blazediff";
+var paths = (cwd = process.cwd()) => {
+  const root = path2__default.default.join(cwd, BLAZEDIFF_DIR);
+  return {
+    root,
+    config: path2__default.default.join(root, "config.json"),
+    manifest: path2__default.default.join(root, "manifest.json"),
+    baselines: path2__default.default.join(root, "baselines"),
+    actual: path2__default.default.join(root, "actual"),
+    judgments: path2__default.default.join(root, "judgments"),
+    summary: path2__default.default.join(root, "summary.md"),
+    gitignore: path2__default.default.join(root, ".gitignore"),
+    serverLog: path2__default.default.join(root, "dev-server.log"),
+    serverPid: path2__default.default.join(root, "dev-server.pid")
+  };
+};
+
+// src/browser/capture.ts
+async function captureScreenshot(baseUrl, opts, cwd = process.cwd()) {
+  const viewport = opts.viewport ?? DEFAULT_VIEWPORT;
+  const waitFor = opts.waitFor ?? DEFAULT_WAIT_FOR;
+  const masks = opts.mask ?? [];
+  const fullPage = opts.fullPage ?? DEFAULT_FULL_PAGE;
+  const { context, page } = await openStableContext({ viewport});
+  try {
+    const url = new URL(opts.url, baseUrl).toString();
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await waitForStability(page, waitFor);
+    await applyMaskOverlays(page, masks);
+    await page.evaluate(
+      () => new Promise((r) => requestAnimationFrame(() => r()))
+    );
+    const outputDir = opts.mode === "baseline" ? paths(cwd).baselines : paths(cwd).actual;
+    await promises.mkdir(outputDir, { recursive: true });
+    const outputPath = path2__default.default.join(outputDir, `${opts.id}.png`);
+    const buffer = await page.screenshot({
+      path: outputPath,
+      type: "png",
+      fullPage,
+      animations: "disabled",
+      caret: "hide",
+      scale: "device"
+    });
+    return { id: opts.id, outputPath, mode: opts.mode, bytes: buffer.length };
+  } finally {
+    await context.close().catch(() => {
+    });
+  }
+}
+async function loadConfig(cwd = process.cwd()) {
+  const file = paths(cwd).config;
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(await promises.readFile(file, "utf8"));
+}
+async function saveConfig(config, cwd = process.cwd()) {
+  const file = paths(cwd).config;
+  await promises.mkdir(path2__default.default.dirname(file), { recursive: true });
+  await promises.writeFile(file, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function configHash(config) {
+  return `sha256:${crypto$1.createHash("sha256").update(JSON.stringify(config)).digest("hex")}`;
+}
+function resolveBaseUrl(config, override) {
+  if (override) return override;
+  if (config?.baseUrl) return config.baseUrl;
+  if (config?.devServer) return `http://127.0.0.1:${config.devServer.port}`;
+  throw new Error("no baseUrl: pass --base-url or run `blazediff-agent init`");
+}
+
+// src/types.ts
+var STABILITY_HOOKS_VERSION = 1;
+
+// src/manifest.ts
+async function loadManifest(cwd = process.cwd()) {
+  const file = paths(cwd).manifest;
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(await promises.readFile(file, "utf8"));
+}
+async function saveManifest(manifest, cwd = process.cwd()) {
+  const file = paths(cwd).manifest;
+  await promises.mkdir(path2__default.default.dirname(file), { recursive: true });
+  await promises.writeFile(file, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function emptyManifest(configHashValue) {
+  return {
+    version: 1,
+    configHash: configHashValue,
+    stabilityHooksVersion: STABILITY_HOOKS_VERSION,
+    entries: []
+  };
+}
+function hashMaterial(input) {
+  const material = {
+    url: input.url,
+    viewport: input.viewport,
+    mask: [...input.mask].sort(),
+    waitFor: input.waitFor,
+    auth: input.auth,
+    fullPage: input.fullPage,
+    hooks: STABILITY_HOOKS_VERSION
+  };
+  return `sha256:${crypto$1.createHash("sha256").update(JSON.stringify(material)).digest("hex")}`;
+}
+function makeEntry(input) {
+  const viewport = input.viewport ?? DEFAULT_VIEWPORT;
+  const waitFor = input.waitFor ?? DEFAULT_WAIT_FOR;
+  const mask = input.mask ?? [];
+  const auth = input.auth ?? null;
+  const fullPage = input.fullPage ?? DEFAULT_FULL_PAGE;
+  return {
+    id: input.id,
+    url: input.url,
+    viewport,
+    auth,
+    waitFor,
+    mask,
+    fullPage,
+    baselinePath: path2__default.default.posix.join(".blazediff", "baselines", `${input.id}.png`),
+    captureHash: hashMaterial({
+      url: input.url,
+      viewport,
+      mask,
+      waitFor,
+      auth,
+      fullPage
+    }),
+    createdBy: input.createdBy ?? "agent",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  };
+}
+function addOrReplaceEntry(manifest, entry) {
+  const entries = [
+    ...manifest.entries.filter((e) => e.id !== entry.id),
+    entry
+  ].sort((a, b) => a.id.localeCompare(b.id));
+  return { ...manifest, entries };
+}
+function removeEntry(manifest, id) {
+  return { ...manifest, entries: manifest.entries.filter((e) => e.id !== id) };
+}
+function findEntry(manifest, id) {
+  return manifest.entries.find((e) => e.id === id);
+}
+function isEntryStale(entry) {
+  const recomputed = hashMaterial({
+    url: entry.url,
+    viewport: entry.viewport,
+    mask: entry.mask,
+    waitFor: entry.waitFor,
+    auth: entry.auth,
+    fullPage: entry.fullPage ?? DEFAULT_FULL_PAGE
+  });
+  return recomputed !== entry.captureHash;
+}
+
+// src/captures.ts
+function validateRoute(route, i) {
+  if (!route || typeof route !== "object")
+    return `route[${i}] must be an object`;
+  if (!route.id || typeof route.id !== "string")
+    return `route[${i}] missing id`;
+  if (!route.url || typeof route.url !== "string")
+    return `route[${i}] missing url`;
+  return null;
+}
+async function loadOrCreateManifest(cwd) {
+  const existing = await loadManifest(cwd);
+  if (existing) return existing;
+  const config = await loadConfig(cwd);
+  return emptyManifest(config ? configHash(config) : "sha256:none");
+}
+async function runCaptures(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const defaultMode = opts.mode ?? "baseline";
+  const writeManifest = opts.writeManifest ?? true;
+  const results = [];
+  const valid = [];
+  opts.routes.forEach((r, i) => {
+    const err = validateRoute(r, i);
+    if (err) {
+      results.push({
+        id: r?.id ?? `route[${i}]`,
+        url: r?.url ?? "",
+        mode: r?.mode ?? defaultMode,
+        ok: false,
+        error: err
+      });
+    } else {
+      valid.push(r);
+    }
+  });
+  let manifest = writeManifest ? await loadOrCreateManifest(cwd) : null;
+  let manifestUpdates = 0;
+  try {
+    for (const r of valid) {
+      const mode = r.mode ?? defaultMode;
+      try {
+        const shot = await captureScreenshot(
+          opts.baseUrl,
+          {
+            id: r.id,
+            url: r.url,
+            viewport: r.viewport,
+            mask: r.mask,
+            waitFor: r.waitFor,
+            fullPage: r.fullPage,
+            mode
+          },
+          cwd
+        );
+        results.push({
+          id: r.id,
+          url: r.url,
+          mode,
+          ok: true,
+          outputPath: shot.outputPath,
+          bytes: shot.bytes
+        });
+        if (manifest && mode === "baseline") {
+          manifest = addOrReplaceEntry(
+            manifest,
+            makeEntry({
+              id: r.id,
+              url: r.url,
+              viewport: r.viewport,
+              mask: r.mask,
+              waitFor: r.waitFor,
+              fullPage: r.fullPage
+            })
+          );
+          manifestUpdates += 1;
+        }
+      } catch (err) {
+        results.push({
+          id: r.id,
+          url: r.url,
+          mode,
+          ok: false,
+          error: err.message
+        });
+      }
+    }
+    if (manifest && manifestUpdates > 0) await saveManifest(manifest, cwd);
+  } finally {
+    await closeBrowser();
+  }
+  const succeeded = results.filter((r) => r.ok).length;
+  return {
+    total: results.length,
+    succeeded,
+    failed: results.length - succeeded,
+    manifestUpdates,
+    results
+  };
+}
+
+// src/cli/parsers.ts
+function parseViewport(value) {
+  const [w, h] = value.split("x").map((n) => Number(n));
+  if (!w || !h) throw new Error(`invalid viewport: ${value} (expected WxH)`);
+  return { width: w, height: h };
+}
+function parseMaskList(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parseWaitFor(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter(Boolean).map(
+    (part) => part === "networkidle" || part === "fonts" ? part : { selector: part }
+  );
+}
+function parseRoutesPayload(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) throw new Error("routes payload is empty");
+  const parsed = JSON.parse(trimmed);
+  if (!Array.isArray(parsed))
+    throw new Error("routes payload must be a JSON array");
+  return parsed;
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on(
+      "end",
+      () => resolve(Buffer.concat(chunks).toString("utf8"))
+    );
+    process.stdin.on("error", reject);
+  });
+}
+
+// src/cli/commands/capture.ts
+async function resolveRoutes(opts) {
+  const sources = [opts.routes, opts.stdin, opts.id || opts.url].filter(
+    Boolean
+  ).length;
+  if (sources === 0) {
+    throw new Error(
+      "provide one of: --routes <file>, --stdin, or --id <id> --url <url>"
+    );
+  }
+  if (opts.routes && opts.stdin) {
+    throw new Error("--routes and --stdin are mutually exclusive");
+  }
+  if (opts.routes) {
+    return parseRoutesPayload(
+      await promises.readFile(path2__default.default.resolve(opts.routes), "utf8")
+    );
+  }
+  if (opts.stdin) {
+    return parseRoutesPayload(await readStdin());
+  }
+  if (!opts.id || !opts.url) {
+    throw new Error(
+      "--id and --url must both be provided for single-route capture"
+    );
+  }
+  return [
+    {
+      id: opts.id,
+      url: opts.url,
+      viewport: parseViewport(opts.viewport),
+      mask: parseMaskList(opts.mask),
+      waitFor: parseWaitFor(opts.waitFor),
+      fullPage: opts.fullPage
+    }
+  ];
+}
+function registerCapture(program, out) {
+  program.command("capture").description(
+    "capture one or more deterministic screenshots. Reads routes from --routes <file>, --stdin, or --id/--url for a single route."
+  ).option("--routes <file>", "JSON file with an array of route entries").option("--stdin", "read JSON array of route entries from stdin").option("--id <id>", "single-route id (used with --url)").option("--url <url>", "single-route URL (used with --id)").option(
+    "--viewport <WxH>",
+    "default viewport for inline single route",
+    "1280x800"
+  ).option("--mask <selectors>", "default mask for inline single route", "").option(
+    "--wait-for <list>",
+    "default wait list for inline single route",
+    "networkidle,fonts"
+  ).option("--no-full-page", "default: viewport-only (default is full page)").option(
+    "--mode <baseline|actual>",
+    "default mode (entries can override)",
+    "baseline"
+  ).option("--base-url <url>", "override base URL").option(
+    "--no-manifest",
+    "do not write manifest entries (baseline mode only)"
+  ).action(async (opts) => {
+    const baseUrl = resolveBaseUrl(await loadConfig(), opts.baseUrl);
+    const routes = await resolveRoutes(opts);
+    const report = await runCaptures({
+      baseUrl,
+      routes,
+      mode: opts.mode,
+      writeManifest: opts.manifest
+    });
+    const human = out.isTTY() ? `captured ${report.succeeded}/${report.total} (manifest: +${report.manifestUpdates})${report.failed ? `, ${report.failed} failed` : ""}` : ".";
+    out.emit(report, human);
+    if (report.failed > 0) process.exitCode = 1;
+  });
+}
+var ENTRIES = [
+  "actual/",
+  "judgments/",
+  "summary.md",
+  "dev-server.log",
+  "dev-server.pid",
+  "*.tmp"
+];
+var STALE_ENTRIES = /* @__PURE__ */ new Set(["diffs/", "pending-judgments/", "report.json"]);
+var HEADER = "# blazediff: generated artifacts (committed: config.json, manifest.json, baselines/)\n";
+async function ensureGitignore(cwd) {
+  const file = paths(cwd).gitignore;
+  await promises.mkdir(path2__default.default.dirname(file), { recursive: true });
+  const existing = fs.existsSync(file) ? await promises.readFile(file, "utf8") : "";
+  const lines = existing.split("\n").map((l) => l.trim());
+  const hasStale = lines.some((l) => STALE_ENTRIES.has(l));
+  const missing = ENTRIES.filter((e) => !lines.includes(e));
+  if (!missing.length && !hasStale && existing) return;
+  if (hasStale) {
+    const kept = lines.filter(
+      (l) => !STALE_ENTRIES.has(l) && !ENTRIES.includes(l) && l !== ""
+    );
+    const body2 = `${kept.length ? `${kept.join("\n")}
+` : HEADER}${ENTRIES.join("\n")}
+`;
+    await promises.writeFile(file, body2, "utf8");
+    return;
+  }
+  const body = existing ? `${existing.replace(/\n+$/, "")}
+${missing.join("\n")}
+` : `${HEADER}${ENTRIES.join("\n")}
+`;
+  await promises.writeFile(file, body, "utf8");
+}
+async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.cwd()) {
+  if (!fs.existsSync(baselinePath) || !fs.existsSync(actualPath)) {
+    return {
+      id,
+      baselinePath,
+      actualPath,
+      match: false,
+      reason: "file-not-exists"
+    };
+  }
+  let diffPath;
+  if (opts.emitDiffPng) {
+    const actualDir = paths(cwd).actual;
+    await promises.mkdir(actualDir, { recursive: true });
+    diffPath = path2__default.default.join(actualDir, `${id}.diff.png`);
+  }
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const antialiasing = opts.antialiasing ?? true;
+  const result = await coreNative.compare(baselinePath, actualPath, diffPath, {
+    threshold,
+    antialiasing
+  });
+  if (result.match) return { id, baselinePath, actualPath, match: true };
+  if (result.reason === "file-not-exists") {
+    return {
+      id,
+      baselinePath,
+      actualPath,
+      match: false,
+      reason: "file-not-exists"
+    };
+  }
+  if (result.reason === "layout-diff") {
+    return {
+      id,
+      baselinePath,
+      actualPath,
+      diffPath,
+      match: false,
+      reason: "layout-diff"
+    };
+  }
+  const interpretation = await coreNative.interpret(baselinePath, actualPath, {
+    threshold,
+    antialiasing
+  }).catch(() => void 0);
+  return {
+    id,
+    baselinePath,
+    actualPath,
+    diffPath,
+    match: false,
+    reason: "pixel-diff",
+    diffCount: result.diffCount,
+    diffPercentage: result.diffPercentage,
+    interpretation
+  };
+}
+
+// src/diff/verdict.ts
+var REGRESSIVE_TYPES = /* @__PURE__ */ new Set(["content-change", "addition", "deletion"]);
+var INTENTIONAL_TYPES = /* @__PURE__ */ new Set(["color-change", "shift"]);
+var NOISE_TYPES = /* @__PURE__ */ new Set(["rendering-noise"]);
+var ELEVATED_SEVERITY = /* @__PURE__ */ new Set(["medium", "high"]);
+var SUB_PERCEPTUAL_PCT = 0.01;
+function pctText(pct) {
+  if (typeof pct !== "number") return "?%";
+  return pct >= 0.01 ? `${pct.toFixed(2)}%` : `${pct.toFixed(3)}%`;
+}
+function countByType(regions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of regions)
+    counts.set(r.changeType, (counts.get(r.changeType) ?? 0) + 1);
+  return counts;
+}
+function dominantType(counts) {
+  let best = "";
+  let bestN = 0;
+  for (const [type, n] of counts) {
+    if (n > bestN) {
+      best = type;
+      bestN = n;
+    }
+  }
+  return best;
+}
+function topPosition(regions) {
+  let best;
+  for (const r of regions)
+    if (!best || r.pixelCount > best.pixelCount) best = r;
+  return best?.position;
+}
+function meanConfidence(regions) {
+  if (regions.length === 0) return 0;
+  return regions.reduce((a, r) => a + (r.confidence ?? 0), 0) / regions.length;
+}
+function formatBreakdown(counts) {
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([type, n]) => `${n} ${type}`).join(", ");
+}
+function buildHeadline(input) {
+  const { reason, interpretation, diffCount, diffPercentage } = input;
+  if (reason === "layout-diff") return "image dimensions changed";
+  if (reason === "file-not-exists") return "baseline or actual capture missing";
+  if (!interpretation || interpretation.regions.length === 0) {
+    const px = diffCount?.toLocaleString() ?? "?";
+    return `${px} px (${pctText(diffPercentage)}) - no region analysis`;
+  }
+  const regions = interpretation.regions;
+  const counts = countByType(regions);
+  const pos = topPosition(regions);
+  const pct = pctText(diffPercentage ?? interpretation.diffPercentage);
+  const sev = interpretation.severity ?? "?";
+  if (regions.length === 1) {
+    return `1 ${dominantType(counts)}${pos ? ` @ ${pos}` : ""} (${pct}, ${sev})`;
+  }
+  return `${regions.length} regions: ${formatBreakdown(counts)}${pos ? ` @ ${pos}` : ""} (${pct}, ${sev})`;
+}
+function deriveVerdict(input) {
+  const { reason, interpretation, diffPercentage } = input;
+  const headline = buildHeadline(input);
+  if (reason === "layout-diff") {
+    return {
+      label: "ambiguous",
+      headline,
+      rationale: [
+        "baseline and actual image dimensions differ \u2014 page height likely shifted",
+        "could be intentional (content added/removed) or regression (broken layout)"
+      ],
+      action: "investigate"
+    };
+  }
+  if (reason === "file-not-exists") {
+    return {
+      label: "regression-likely",
+      headline,
+      rationale: ["baseline or actual capture is missing from disk"],
+      action: "investigate"
+    };
+  }
+  if (!interpretation || interpretation.regions.length === 0) {
+    return {
+      label: "ambiguous",
+      headline,
+      rationale: ["pixels differ but interpret returned no regions"],
+      action: "investigate"
+    };
+  }
+  const regions = interpretation.regions;
+  const severity = interpretation.severity;
+  const counts = countByType(regions);
+  const allNoise = regions.every((r) => NOISE_TYPES.has(r.changeType));
+  const allColor = regions.every((r) => r.changeType === "color-change");
+  const allMoved = regions.every((r) => INTENTIONAL_TYPES.has(r.changeType));
+  const hasRegressive = regions.some((r) => REGRESSIVE_TYPES.has(r.changeType));
+  const pct = typeof diffPercentage === "number" ? diffPercentage : interpretation.diffPercentage;
+  if (allNoise) {
+    return {
+      label: "noise-likely",
+      headline,
+      rationale: ["all regions classified as rendering-noise"],
+      action: "ignore-or-rewrite"
+    };
+  }
+  if (typeof pct === "number" && pct < SUB_PERCEPTUAL_PCT && severity === "low") {
+    return {
+      label: "noise-likely",
+      headline,
+      rationale: [
+        `delta < ${SUB_PERCEPTUAL_PCT}% (got ${pctText(pct)}) at "low" severity`,
+        "sub-perceptual change - review optional"
+      ],
+      action: "ignore-or-rewrite"
+    };
+  }
+  if (hasRegressive && ELEVATED_SEVERITY.has(severity ?? "")) {
+    const types = [...counts].filter(([t]) => REGRESSIVE_TYPES.has(t)).map(([t, n]) => `${n} ${t}`).join(", ");
+    return {
+      label: "regression-likely",
+      headline,
+      rationale: [
+        `severity ${severity} with structural changes (${types})`,
+        "likely affects content or layout, not just styling"
+      ],
+      action: "investigate"
+    };
+  }
+  if (allColor && meanConfidence(regions) > 0.7) {
+    return {
+      label: "intentional-likely",
+      headline,
+      rationale: [
+        `${regions.length} color-change region${regions.length === 1 ? "" : "s"} with mean confidence > 0.7`,
+        "edge structure preserved - looks like a theming / palette change"
+      ],
+      action: "rewrite-if-intended"
+    };
+  }
+  if (allMoved && !allColor) {
+    return {
+      label: "intentional-likely",
+      headline,
+      rationale: [
+        "all regions are shift/color-change - content moved or restyled, structure preserved"
+      ],
+      action: "rewrite-if-intended"
+    };
+  }
+  return {
+    label: "ambiguous",
+    headline,
+    rationale: [
+      `mix of change types (${formatBreakdown(counts)}) at "${severity ?? "?"}" severity`,
+      `${pctText(pct)} of image differs`
+    ],
+    action: "investigate"
+  };
+}
+var DEFAULT_TOP_N = 5;
+var DEFAULT_PADDING = 16;
+var DEFAULT_LOCATOR_MAX_WIDTH = 400;
+var DEFAULT_GUTTER = 2;
+var DEFAULT_ROW_GUTTER = 8;
+var BG_WHITE = { r: 255, g: 255, b: 255 };
+function padAndClamp(bbox, padding, imgWidth, imgHeight) {
+  const left = Math.max(0, Math.floor(bbox.x - padding));
+  const top = Math.max(0, Math.floor(bbox.y - padding));
+  const right = Math.min(imgWidth, Math.ceil(bbox.x + bbox.width + padding));
+  const bottom = Math.min(imgHeight, Math.ceil(bbox.y + bbox.height + padding));
+  return {
+    x: left,
+    y: top,
+    width: Math.max(1, right - left),
+    height: Math.max(1, bottom - top)
+  };
+}
+async function prepareTiles(opts) {
+  const topN = opts.topN ?? DEFAULT_TOP_N;
+  const padding = opts.padding ?? DEFAULT_PADDING;
+  const locatorMaxWidth = opts.locatorMaxWidth ?? DEFAULT_LOCATOR_MAX_WIDTH;
+  const gutter = opts.gutter ?? DEFAULT_GUTTER;
+  const rowGutter = opts.rowGutter ?? DEFAULT_ROW_GUTTER;
+  const diffMeta = await sharp__default.default(opts.diffPath).metadata();
+  const imgWidth = diffMeta.width ?? 0;
+  const imgHeight = diffMeta.height ?? 0;
+  if (!imgWidth || !imgHeight) {
+    throw new Error(`unable to read diff image dimensions: ${opts.diffPath}`);
+  }
+  const ranked = [...opts.regions].sort((a, b) => b.pixelCount - a.pixelCount).slice(0, topN);
+  const regionData = await Promise.all(
+    ranked.map(async (region) => {
+      const padded = padAndClamp(region.bbox, padding, imgWidth, imgHeight);
+      const extract = {
+        left: padded.x,
+        top: padded.y,
+        width: padded.width,
+        height: padded.height
+      };
+      const [base, actual] = await Promise.all([
+        sharp__default.default(opts.baselinePath).extract(extract).toBuffer(),
+        sharp__default.default(opts.actualPath).extract(extract).toBuffer()
+      ]);
+      return { region, padded, base, actual };
+    })
+  );
+  let tilesName;
+  if (regionData.length > 0) {
+    const canvasWidth = Math.max(
+      ...regionData.map((r) => r.padded.width * 2 + gutter)
+    );
+    const totalHeight = regionData.reduce(
+      (sum, r, i) => sum + r.padded.height + (i > 0 ? rowGutter : 0),
+      0
+    );
+    const composites = [];
+    let y = 0;
+    for (let i = 0; i < regionData.length; i++) {
+      const r = regionData[i];
+      const w = r.padded.width;
+      composites.push(
+        { input: r.base, left: 0, top: y },
+        { input: r.actual, left: w + gutter, top: y }
+      );
+      y += r.padded.height;
+      if (i < regionData.length - 1) y += rowGutter;
+    }
+    tilesName = "regions.png";
+    await sharp__default.default({
+      create: {
+        width: canvasWidth,
+        height: totalHeight,
+        channels: 3,
+        background: BG_WHITE
+      }
+    }).composite(composites).png().toFile(path2__default.default.join(opts.outputDir, tilesName));
+  }
+  const scale = locatorMaxWidth / Math.max(imgWidth, imgHeight);
+  const locW = Math.max(1, Math.round(imgWidth * scale));
+  const locH = Math.max(1, Math.round(imgHeight * scale));
+  const rects = opts.regions.map((r) => {
+    const x = Math.round(r.bbox.x * scale);
+    const y = Math.round(r.bbox.y * scale);
+    const w = Math.max(1, Math.round(r.bbox.width * scale));
+    const h = Math.max(1, Math.round(r.bbox.height * scale));
+    return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="none" stroke="red" stroke-width="2" />`;
+  }).join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${locW}" height="${locH}">${rects}</svg>`;
+  const locatorName = "locator.png";
+  await sharp__default.default(opts.diffPath).resize(locW, locH, { fit: "fill" }).composite([{ input: Buffer.from(svg), left: 0, top: 0 }]).png().toFile(path2__default.default.join(opts.outputDir, locatorName));
+  return {
+    locatorPath: locatorName,
+    tilesPath: tilesName,
+    regions: regionData.map((r) => ({
+      bbox: r.region.bbox,
+      pixelCount: r.region.pixelCount
+    }))
+  };
+}
+
+// src/judge/host-harness.ts
+async function tryPrepareTiles(input, entryDir) {
+  if (!input.regions || input.regions.length === 0 || !input.diffPath) {
+    return null;
+  }
+  try {
+    return await prepareTiles({
+      regions: input.regions,
+      baselinePath: input.baselinePath,
+      actualPath: input.actualPath,
+      diffPath: input.diffPath,
+      outputDir: entryDir
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `[blazediff] tile generation failed for ${input.entry.id}: ${message}`
+    );
+    return null;
+  }
+}
+var hostHarnessJudge = {
+  name: "host",
+  async judge(input, cwd) {
+    const p = paths(cwd);
+    const entryDir = path2__default.default.join(p.judgments, input.entry.id);
+    await promises.mkdir(entryDir, { recursive: true });
+    await tryPrepareTiles(input, entryDir);
+    return { kind: "deferred", requestPath: entryDir };
+  }
+};
+
+// src/judge/none.ts
+var noneJudge = {
+  name: "none",
+  async judge(input) {
+    return { kind: "judged", verdict: input.heuristicVerdict };
+  }
+};
+var PREVIEW_WIDTH = 320;
+function escapeCell(s) {
+  return s.replace(/\n/g, " ");
+}
+function toBlazediffRel(cwd, abs) {
+  if (!abs) return void 0;
+  const root = paths(cwd).root;
+  const rel = path2__default.default.isAbsolute(abs) ? path2__default.default.relative(root, abs) : path2__default.default.relative(paths(cwd).root, path2__default.default.join(cwd, abs));
+  return rel.split(path2__default.default.sep).join("/");
+}
+function img(src, alt) {
+  return `<img src="${src}" width="${PREVIEW_WIDTH}" alt="${alt}">`;
+}
+function baselineCell(r, cwd) {
+  const rel = toBlazediffRel(cwd, r.baselinePath) ?? `baselines/${r.id}.png`;
+  return img(rel, `${r.id} baseline`);
+}
+function actualCell(r, cwd) {
+  const actual = toBlazediffRel(cwd, r.actualPath);
+  return actual ? img(actual, `${r.id} actual`) : "-";
+}
+function diffCell(r, cwd) {
+  const diff = toBlazediffRel(cwd, r.diffPath);
+  return diff ? img(diff, `${r.id} diff`) : "-";
+}
+function verdictCell(r) {
+  if (r.status === "missing-baseline") {
+    return `missing-baseline - ${r.message ?? "baseline missing"}`;
+  }
+  if (r.status === "stale-baseline") {
+    return `stale-baseline - ${r.message ?? "manifest entry edited without re-capturing"}`;
+  }
+  if (r.status === "needs-judgment") {
+    return `needs-judgment - see judgments/${r.id}/`;
+  }
+  if (!r.verdict) {
+    return r.message ?? r.status;
+  }
+  return `${r.verdict.label} - ${r.verdict.headline} -> ${r.verdict.action}`;
+}
+function renderRow(r, cwd) {
+  return `| ${r.id} | ${escapeCell(baselineCell(r, cwd))} | ${escapeCell(actualCell(r, cwd))} | ${escapeCell(diffCell(r, cwd))} | ${escapeCell(verdictCell(r))} |`;
+}
+function headerLine(report) {
+  const { passed, failed, pendingJudgments, totalEntries } = report;
+  const parts = [`${passed}/${totalEntries} passed`];
+  if (failed > 0) parts.push(`${failed} failed`);
+  if (pendingJudgments > 0) parts.push(`${pendingJudgments} pending judgment`);
+  return parts.length > 1 ? `${parts[0]} (${parts.slice(1).join(", ")})` : parts[0];
+}
+function renderSummary(report, cwd = process.cwd()) {
+  const nonPass = report.results.filter((r) => r.status !== "pass");
+  const lines = [
+    `# blazediff check - ${report.createdAt}`,
+    "",
+    headerLine(report),
+    ""
+  ];
+  if (nonPass.length === 0) {
+    lines.push("All entries passed.");
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("| id | baseline | actual | diff | verdict |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const r of nonPass) lines.push(renderRow(r, cwd));
+  return `${lines.join("\n")}
+`;
+}
+async function writeSummaryMarkdown(report, cwd = process.cwd()) {
+  const file = paths(cwd).summary;
+  await promises.mkdir(path2__default.default.dirname(file), { recursive: true });
+  await promises.writeFile(file, renderSummary(report, cwd), "utf8");
+  return file;
+}
+
+// src/judge/apply.ts
+var VALID_LABELS = [
+  "regression-likely",
+  "intentional-likely",
+  "noise-likely",
+  "ambiguous"
+];
+var VALID_ACTIONS = [
+  "investigate",
+  "rewrite-if-intended",
+  "ignore-or-rewrite"
+];
+function parseVerdict(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.id !== "string") return null;
+  const v = r.verdict;
+  if (!v || typeof v !== "object") return null;
+  if (typeof v.label !== "string" || !VALID_LABELS.includes(v.label))
+    return null;
+  if (typeof v.headline !== "string") return null;
+  if (typeof v.action !== "string" || !VALID_ACTIONS.includes(v.action))
+    return null;
+  const rationale = Array.isArray(v.rationale) ? v.rationale.filter((x) => typeof x === "string") : [];
+  return {
+    id: r.id,
+    verdict: {
+      label: v.label,
+      headline: v.headline,
+      rationale,
+      action: v.action
+    },
+    rationale: typeof r.rationale === "string" ? r.rationale : void 0,
+    confidence: typeof r.confidence === "number" ? r.confidence : void 0
+  };
+}
+async function readJsonOrNull(file) {
+  try {
+    return JSON.parse(await promises.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readJudgmentDirs(root) {
+  let names;
+  try {
+    names = await promises.readdir(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const dir = path2__default.default.join(root, name);
+    let isDir = false;
+    try {
+      isDir = (await promises.stat(dir)).isDirectory();
+    } catch {
+      isDir = false;
+    }
+    if (!isDir) continue;
+    const request = await readJsonOrNull(
+      path2__default.default.join(dir, "request.json")
+    );
+    const verdictFile = path2__default.default.join(dir, "verdict.json");
+    let verdict = null;
+    let verdictInvalid = false;
+    if (fs.existsSync(verdictFile)) {
+      const raw = await readJsonOrNull(verdictFile);
+      verdict = raw ? parseVerdict(raw) : null;
+      if (raw && !verdict) verdictInvalid = true;
+    }
+    out.push({ id: name, request, verdict, verdictInvalid });
+  }
+  return out;
+}
+function toAbs(cwd, rel) {
+  if (!rel) return void 0;
+  return path2__default.default.isAbsolute(rel) ? rel : path2__default.default.join(cwd, rel);
+}
+function buildResult(cwd, dir, entry) {
+  const req = dir.request;
+  const finalVerdict = dir.verdict?.verdict ?? req?.heuristicVerdict;
+  const status = req ? dir.verdict ? "fail" : req.status : "fail";
+  const message = dir.verdict?.rationale ?? (dir.verdict?.confidence !== void 0 ? `judged (confidence ${dir.verdict.confidence.toFixed(2)})` : req?.message);
+  return {
+    id: dir.id,
+    url: req?.url ?? entry?.url ?? "",
+    status,
+    diffPercentage: req?.diffPercentage,
+    severity: req?.severity,
+    regions: req?.regions,
+    verdict: finalVerdict,
+    diffPath: toAbs(cwd, req?.paths.diff),
+    actualPath: toAbs(cwd, req?.paths.actual),
+    baselinePath: toAbs(cwd, req?.paths.baseline),
+    message
+  };
+}
+function passResult(entry, cwd) {
+  const baselineAbs = path2__default.default.join(paths(cwd).baselines, `${entry.id}.png`);
+  const actualAbs = path2__default.default.join(paths(cwd).actual, `${entry.id}.png`);
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "pass",
+    baselinePath: baselineAbs,
+    actualPath: fs.existsSync(actualAbs) ? actualAbs : void 0
+  };
+}
+async function applyJudgments(cwd = process.cwd()) {
+  const p = paths(cwd);
+  const manifest = await loadManifest(cwd);
+  if (!manifest) {
+    throw new Error(
+      `no manifest at ${p.manifest}. Run \`blazediff-agent init\` first.`
+    );
+  }
+  const dirs = await readJudgmentDirs(p.judgments);
+  const dirById = new Map(dirs.map((d) => [d.id, d]));
+  const applied = [];
+  const missing = [];
+  const invalid = [];
+  for (const d of dirs) {
+    if (d.verdictInvalid) invalid.push(path2__default.default.join(p.judgments, d.id));
+    else if (d.verdict) applied.push(d.id);
+    else missing.push(d.id);
+  }
+  const nonPassResults = [];
+  for (const d of dirs) {
+    const entry = manifest.entries.find((e) => e.id === d.id);
+    nonPassResults.push(buildResult(cwd, d, entry));
+  }
+  const passResults = [];
+  for (const entry of manifest.entries) {
+    if (dirById.has(entry.id)) continue;
+    passResults.push(passResult(entry, cwd));
+  }
+  const results = [...passResults, ...nonPassResults];
+  const passed = results.filter((r) => r.status === "pass").length;
+  const pendingJudgments = results.filter(
+    (r) => r.status === "needs-judgment"
+  ).length;
+  const report = {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalEntries: results.length,
+    passed,
+    failed: results.length - passed - pendingJudgments,
+    pendingJudgments,
+    results
+  };
+  await writeSummaryMarkdown(report, cwd);
+  return { report, applied, missing, invalid };
+}
+var HOST_INSTRUCTIONS = [
+  "The visual-regression heuristic could not classify this diff confidently.",
+  "Read `locator.png` AND `regions.png` in parallel - issue both Read calls in a single tool batch. locator.png is a small thumbnail of the diff with every change region outlined in red; regions.png is a vertical stack of [baseline | actual] pairs, one row per change region at native resolution. Row order matches the `regions[]` array (top = largest by pixelCount).",
+  "Decide from the tile pairs. Only open the full diff / baseline / actual PNGs if the composite is itself ambiguous (e.g., a change clearly continues outside the cropped region).",
+  "Decide whether the change is a regression, an intentional UI change, or rendering noise.",
+  "Write your decision to `verdict.json` (next to this `request.json`) with shape:",
+  '  { "id": string, "verdict": { "label": "regression-likely" | "intentional-likely" | "noise-likely", "headline": string, "rationale": string[], "action": "investigate" | "rewrite-if-intended" | "ignore-or-rewrite" }, "rationale": string, "confidence": number }',
+  "Then re-run `blazediff-agent check --apply-judgments --json` to regenerate summary.md."
+].join("\n");
+function relTo(cwd, abs) {
+  if (!abs) return void 0;
+  return path2__default.default.relative(cwd, abs).split(path2__default.default.sep).join("/");
+}
+function signatureOf(r) {
+  const pct = typeof r.diffPercentage === "number" ? r.diffPercentage.toFixed(4) : "?";
+  const regions = r.regions?.length ?? 0;
+  const severity = r.severity ?? "?";
+  return `${r.status}|diff:${pct}|regions:${regions}|severity:${severity}`;
+}
+async function readJsonOrNull2(file) {
+  try {
+    return JSON.parse(await promises.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function entryById(manifest, id) {
+  return manifest.entries.find((e) => e.id === id);
+}
+function buildRequest(result, entry, cwd, tiles) {
+  const isAmbiguous = result.status === "needs-judgment" || result.verdict?.label === "ambiguous" && result.status === "fail";
+  return {
+    id: result.id,
+    url: result.url,
+    status: result.status,
+    diffPercentage: result.diffPercentage,
+    severity: result.severity,
+    regions: result.regions,
+    paths: {
+      baseline: relTo(cwd, result.baselinePath),
+      actual: relTo(cwd, result.actualPath),
+      diff: relTo(cwd, result.diffPath),
+      locator: tiles.locatorPath,
+      tiles: tiles.tilesPath
+    },
+    heuristicVerdict: result.verdict,
+    manifestEntry: {
+      viewport: entry.viewport,
+      mask: entry.mask,
+      waitFor: entry.waitFor,
+      fullPage: entry.fullPage
+    },
+    signature: signatureOf(result),
+    message: result.message,
+    instructions: isAmbiguous ? HOST_INSTRUCTIONS : void 0,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function autoVerdict(result) {
+  if (!result.verdict) return null;
+  if (result.status === "needs-judgment") return null;
+  if (result.verdict.label === "ambiguous") return null;
+  return {
+    id: result.id,
+    verdict: result.verdict,
+    rationale: result.verdict.rationale.join(" "),
+    confidence: 1
+  };
+}
+async function discoverTiles(dir) {
+  const locatorAbs = path2__default.default.join(dir, "locator.png");
+  const tilesAbs = path2__default.default.join(dir, "regions.png");
+  return {
+    locatorPath: fs.existsSync(locatorAbs) ? "locator.png" : void 0,
+    tilesPath: fs.existsSync(tilesAbs) ? "regions.png" : void 0
+  };
+}
+async function writeJudgments(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const root = paths(cwd).judgments;
+  await promises.mkdir(root, { recursive: true });
+  const knownIds = /* @__PURE__ */ new Set();
+  for (const r of opts.report.results) knownIds.add(r.id);
+  for (const result of opts.report.results) {
+    const dir = path2__default.default.join(root, result.id);
+    if (result.status === "pass") {
+      if (fs.existsSync(dir)) await promises.rm(dir, { recursive: true, force: true });
+      continue;
+    }
+    const entry = entryById(opts.manifest, result.id);
+    if (!entry) continue;
+    await promises.mkdir(dir, { recursive: true });
+    const tiles = await discoverTiles(dir);
+    const request = buildRequest(result, entry, cwd, tiles);
+    const requestFile = path2__default.default.join(dir, "request.json");
+    const prior = await readJsonOrNull2(requestFile);
+    const verdictFile = path2__default.default.join(dir, "verdict.json");
+    const priorVerdict = fs.existsSync(verdictFile) ? await readJsonOrNull2(verdictFile) : null;
+    const signatureMatches = prior !== null && prior.signature === request.signature;
+    await promises.writeFile(
+      requestFile,
+      `${JSON.stringify(request, null, 2)}
+`,
+      "utf8"
+    );
+    if (priorVerdict && signatureMatches) {
+      continue;
+    }
+    const auto = autoVerdict(result);
+    if (auto) {
+      await promises.writeFile(
+        verdictFile,
+        `${JSON.stringify(auto, null, 2)}
+`,
+        "utf8"
+      );
+    } else if (priorVerdict && !signatureMatches) {
+      await promises.rm(verdictFile, { force: true });
+    }
+  }
+  let entries;
+  try {
+    entries = await promises.readdir(root);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (knownIds.has(name)) continue;
+    await promises.rm(path2__default.default.join(root, name), { recursive: true, force: true });
+  }
+}
+
+// src/judge/index.ts
+function resolveJudge(backend) {
+  switch (backend) {
+    case "none":
+      return noneJudge;
+    case "host":
+      return hostHarnessJudge;
+  }
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function writeJunit(report, destPath) {
+  await promises.mkdir(path2__default.default.dirname(destPath), { recursive: true });
+  const cases = report.results.map((r) => {
+    if (r.status === "pass") {
+      return `    <testcase classname="blazediff" name="${escapeXml(r.id)}"/>`;
+    }
+    const message = r.message ?? r.status;
+    return `    <testcase classname="blazediff" name="${escapeXml(r.id)}">
+      <failure message="${escapeXml(message)}" type="${escapeXml(r.status)}">${escapeXml(message)}</failure>
+    </testcase>`;
+  });
+  const failures = report.totalEntries - report.passed;
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="blazediff" tests="${report.totalEntries}" failures="${failures}">
+${cases.join("\n")}
+  </testsuite>
+</testsuites>
+`;
+  await promises.writeFile(destPath, xml, "utf8");
+  return destPath;
+}
+
+// src/check.ts
+function narrowRegion(r) {
+  return {
+    bbox: r.bbox,
+    pixelCount: r.pixelCount,
+    percentage: r.percentage,
+    changeType: r.changeType,
+    confidence: r.confidence
+  };
+}
+async function pool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (true) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function passResult2(entry, baselinePath, actualPath) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "pass",
+    baselinePath,
+    actualPath
+  };
+}
+function skipResult(entry, message) {
+  return { id: entry.id, url: entry.url, status: "pass", message };
+}
+function staleResult(entry) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "stale-baseline",
+    message: "captureHash mismatch: entry was edited without re-capturing"
+  };
+}
+function missingBaselineResult(entry, baselinePath) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "missing-baseline",
+    message: `baseline missing at ${baselinePath}`
+  };
+}
+function failResult(entry, outcome, actualPath, baselinePath, verdict) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "fail",
+    diffCount: outcome.diffCount,
+    diffPercentage: outcome.diffPercentage,
+    severity: outcome.interpretation?.severity,
+    regions: outcome.interpretation?.regions?.map(narrowRegion),
+    verdict,
+    diffPath: outcome.diffPath,
+    baselinePath,
+    actualPath,
+    message: outcome.reason === "layout-diff" ? "layout differs (dimensions changed)" : `${outcome.diffCount ?? 0} pixels differ (${(outcome.diffPercentage ?? 0).toFixed(3)}%)`
+  };
+}
+async function judgeAmbiguous(result, entry, judge, cwd) {
+  if (result.status !== "fail" || !result.verdict || result.verdict.label !== "ambiguous" || !result.baselinePath || !result.actualPath) {
+    return result;
+  }
+  const output = await judge.judge(
+    {
+      entry,
+      baselinePath: result.baselinePath,
+      actualPath: result.actualPath,
+      diffPath: result.diffPath,
+      regions: result.regions,
+      diffPercentage: result.diffPercentage,
+      severity: result.severity,
+      heuristicVerdict: result.verdict
+    },
+    cwd
+  );
+  if (output.kind === "judged") {
+    return { ...result, verdict: output.verdict };
+  }
+  return {
+    ...result,
+    status: "needs-judgment",
+    message: `awaiting judgment in ${output.requestPath}`
+  };
+}
+async function checkEntry(entry, opts, cwd, baselinesDir, judge) {
+  if (entry.auth === "required") {
+    return skipResult(entry, "skipped: auth required (deferred to v0.2)");
+  }
+  if (isEntryStale(entry)) {
+    return staleResult(entry);
+  }
+  const baselinePath = path2__default.default.join(baselinesDir, `${entry.id}.png`);
+  const capture = await captureScreenshot(
+    opts.baseUrl,
+    {
+      id: entry.id,
+      url: entry.url,
+      viewport: entry.viewport,
+      mask: entry.mask,
+      waitFor: entry.waitFor,
+      fullPage: entry.fullPage ?? DEFAULT_FULL_PAGE,
+      mode: "actual"
+    },
+    cwd
+  );
+  const outcome = await diffEntry(
+    entry.id,
+    baselinePath,
+    capture.outputPath,
+    { threshold: opts.threshold, emitDiffPng: opts.emitDiffPng ?? true },
+    cwd
+  );
+  if (outcome.match) return passResult2(entry, baselinePath, capture.outputPath);
+  if (outcome.reason === "file-not-exists")
+    return missingBaselineResult(entry, baselinePath);
+  const verdict = deriveVerdict({
+    reason: outcome.reason,
+    interpretation: outcome.interpretation,
+    diffCount: outcome.diffCount,
+    diffPercentage: outcome.diffPercentage
+  });
+  const failed = failResult(
+    entry,
+    outcome,
+    capture.outputPath,
+    baselinePath,
+    verdict
+  );
+  return judgeAmbiguous(failed, entry, judge, cwd);
+}
+async function runCheck(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const manifest = await loadManifest(cwd);
+  if (!manifest) {
+    throw new Error(
+      `no manifest found at ${paths(cwd).manifest}. Run \`blazediff init\` then \`/blazediff\` (or capture manually) first.`
+    );
+  }
+  const baselinesDir = paths(cwd).baselines;
+  const concurrency = opts.concurrency ?? defaultConcurrency();
+  const judge = resolveJudge(opts.judge ?? "none");
+  let results;
+  try {
+    results = await pool(
+      manifest.entries,
+      concurrency,
+      (entry) => checkEntry(entry, opts, cwd, baselinesDir, judge)
+    );
+  } finally {
+    await closeBrowser();
+  }
+  const passed = results.filter((r) => r.status === "pass").length;
+  const pendingJudgments = results.filter(
+    (r) => r.status === "needs-judgment"
+  ).length;
+  const report = {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalEntries: results.length,
+    passed,
+    failed: results.length - passed - pendingJudgments,
+    pendingJudgments,
+    results
+  };
+  await writeJudgments({ report, manifest, cwd });
+  await writeSummaryMarkdown(report, cwd);
+  await ensureGitignore(cwd);
+  if (opts.junitPath) {
+    const target = path2__default.default.isAbsolute(opts.junitPath) ? opts.junitPath : path2__default.default.join(cwd, opts.junitPath);
+    await writeJunit(report, target);
+  }
+  return report;
+}
+
+// src/cli/commands/check.ts
+function slimResult(r) {
+  return {
+    id: r.id,
+    url: r.url,
+    status: r.status,
+    verdict: r.verdict ? {
+      label: r.verdict.label,
+      headline: r.verdict.headline,
+      action: r.verdict.action
+    } : void 0
+  };
+}
+function slimReport(report, summaryPath) {
+  return {
+    summaryPath,
+    createdAt: report.createdAt,
+    totalEntries: report.totalEntries,
+    passed: report.passed,
+    failed: report.failed,
+    pendingJudgments: report.pendingJudgments,
+    results: report.results.filter((r) => r.status !== "pass").map(slimResult)
+  };
+}
+function failureLines(results) {
+  return results.filter((r) => r.status !== "pass").flatMap((r) => {
+    const lines = [];
+    const prefix = r.status === "needs-judgment" ? "?" : "\u2717";
+    if (r.verdict) {
+      lines.push(
+        `  ${prefix} ${r.id}  [${r.verdict.label}]  ${r.verdict.headline}`
+      );
+      lines.push(`      \u2192 ${r.verdict.action}`);
+    } else {
+      const detail = typeof r.diffPercentage === "number" ? `${r.status} (${r.diffPercentage.toFixed(3)}%)` : r.status;
+      lines.push(`  ${prefix} ${r.id}: ${detail}`);
+    }
+    if (r.status === "needs-judgment" && r.message) {
+      lines.push(`      ${r.message}`);
+    }
+    if (r.diffPath) lines.push(`      diff: ${r.diffPath}`);
+    return lines;
+  });
+}
+function parseJudge(input) {
+  if (input === "host" || input === "none") return input;
+  throw new Error(`unknown --judge backend: ${input} (expected: host | none)`);
+}
+function registerCheck(program, out) {
+  program.command("check").description("run the visual regression check (CI verb)").option("--base-url <url>", "override base URL").option(
+    "--threshold <n>",
+    "color threshold (0-1)",
+    String(DEFAULT_THRESHOLD)
+  ).option(
+    "--concurrency <n>",
+    "max entries checked in parallel (default: auto based on CPU cores, capped at 8)"
+  ).option("--no-diff-png", "skip writing diff PNGs").option("--junit <path>", "write JUnit XML to this path (default: skipped)").option(
+    "--judge <backend>",
+    "judge backend for ambiguous diffs (host | none)",
+    "none"
+  ).option(
+    "--apply-judgments",
+    "regenerate summary.md from .blazediff/judgments/<id>/verdict.json files (no re-check)"
+  ).action(async (opts) => {
+    if (opts.applyJudgments) {
+      const { report: report2, applied, missing, invalid } = await applyJudgments();
+      const summaryPath2 = paths().summary;
+      const human2 = applied.length === 0 && missing.length === 0 && invalid.length === 0 ? `no judgments to apply
+  summary: ${summaryPath2}` : [
+        `applied ${applied.length} judgment(s)`,
+        missing.length ? `  ${missing.length} pending without judgment: ${missing.join(", ")}` : void 0,
+        invalid.length ? `  ${invalid.length} invalid judgment file(s): ${invalid.join(", ")}` : void 0,
+        `  ${report2.passed}/${report2.totalEntries} passed (${report2.failed} failed, ${report2.pendingJudgments} pending)`,
+        `  summary: ${summaryPath2}`
+      ].filter(Boolean).join("\n");
+      out.emit(
+        {
+          ok: true,
+          applied,
+          missing,
+          invalid,
+          ...slimReport(report2, summaryPath2)
+        },
+        human2
+      );
+      if (report2.failed > 0) process.exitCode = 1;
+      return;
+    }
+    const baseUrl = resolveBaseUrl(await loadConfig(), opts.baseUrl);
+    const report = await runCheck({
+      baseUrl,
+      threshold: Number(opts.threshold),
+      concurrency: opts.concurrency ? Number(opts.concurrency) : void 0,
+      emitDiffPng: opts.diffPng,
+      junitPath: opts.junit,
+      judge: parseJudge(opts.judge)
+    });
+    const summaryPath = paths().summary;
+    const summary = report.pendingJudgments > 0 ? `${report.passed}/${report.totalEntries} passed (${report.failed} failed, ${report.pendingJudgments} pending judgment)` : report.failed === 0 ? `${report.passed}/${report.totalEntries} passed` : `${report.passed}/${report.totalEntries} passed (${report.failed} failed)`;
+    const human = report.failed === 0 && report.pendingJudgments === 0 ? `${summary}
+  summary: ${summaryPath}` : [
+      `${summary}:`,
+      ...failureLines(report.results),
+      `  summary: ${summaryPath}`,
+      report.pendingJudgments > 0 ? `  pending: ${paths().judgments}/ - host writes <id>/verdict.json, then re-run check --apply-judgments` : void 0
+    ].filter(Boolean).join("\n");
+    out.emit(slimReport(report, summaryPath), human);
+    if (report.failed > 0) process.exitCode = 1;
+  });
+}
+
+// src/cli/commands/diff.ts
+function registerDiff(program, out) {
+  program.command("diff <id>").description("diff a route's baseline against its actual capture").option(
+    "--threshold <n>",
+    "color threshold (0-1)",
+    String(DEFAULT_THRESHOLD)
+  ).option("--emit-diff-png", "write diff PNG to .blazediff/diffs/").action(async (id, opts) => {
+    const manifest = await loadManifest();
+    if (!manifest) throw new Error("no manifest");
+    const entry = findEntry(manifest, id);
+    if (!entry) throw new Error(`no entry with id ${id}`);
+    const baselinePath = `${paths().baselines}/${id}.png`;
+    const actualPath = `${paths().actual}/${id}.png`;
+    const outcome = await diffEntry(id, baselinePath, actualPath, {
+      threshold: Number(opts.threshold),
+      emitDiffPng: Boolean(opts.emitDiffPng)
+    });
+    out.emit(
+      outcome,
+      outcome.match ? `${id}: match` : `${id}: ${outcome.reason ?? "diff"}`
+    );
+    if (!outcome.match) process.exitCode = 1;
+  });
+}
+
+// src/discover/crawl.ts
+function extractInternalLinks(base, target, hrefs) {
+  const out = [];
+  for (const href of hrefs) {
+    if (!href || href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      continue;
+    }
+    try {
+      const u = new URL(href, target);
+      if (u.origin !== base.origin) continue;
+      const path23 = u.pathname + u.search;
+      if (path23.startsWith("/api/")) continue;
+      out.push(path23);
+    } catch {
+    }
+  }
+  return out;
+}
+async function crawlRoutes(opts) {
+  const maxRoutes = opts.maxRoutes ?? 50;
+  const maxDepth = opts.maxDepth ?? 2;
+  const base = new URL(opts.baseUrl);
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [{ url: "/", depth: 0 }];
+  visited.add("/");
+  const discovered = [];
+  const browser = await getBrowser();
+  const context = await browser.newContext({
+    viewport: { width: 1024, height: 768 },
+    deviceScaleFactor: 1
+  });
+  try {
+    while (queue.length && discovered.length < maxRoutes) {
+      const { url, depth } = queue.shift();
+      const page = await context.newPage();
+      try {
+        const target = new URL(url, base).toString();
+        await page.goto(target, {
+          waitUntil: "domcontentloaded",
+          timeout: 15e3
+        });
+        discovered.push({ url, source: "crawl" });
+        if (depth >= maxDepth) continue;
+        const hrefs = await page.evaluate(
+          () => Array.from(
+            document.querySelectorAll("a[href]")
+          ).map((a) => a.getAttribute("href") ?? "")
+        );
+        for (const path23 of extractInternalLinks(base, target, hrefs)) {
+          if (visited.has(path23)) continue;
+          visited.add(path23);
+          queue.push({ url: path23, depth: depth + 1 });
+        }
+      } catch {
+      } finally {
+        await page.close().catch(() => {
+        });
+      }
+    }
+  } finally {
+    await context.close().catch(() => {
+    });
+  }
+  return discovered;
+}
+var DYNAMIC_SEGMENT = /\[[^\]]+\]/;
+async function readJson(file) {
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(await promises.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isPublicRoute(route) {
+  if (DYNAMIC_SEGMENT.test(route)) return false;
+  if (route === "/api" || route.startsWith("/api/")) return false;
+  return true;
+}
+async function discoverFromNextManifest(cwd = process.cwd()) {
+  const nextDir = path2__default.default.join(cwd, ".next");
+  if (!fs.existsSync(nextDir)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (url) => {
+    if (seen.has(url)) return;
+    seen.add(url);
+    out.push({ url, source: "next-manifest" });
+  };
+  const routes = await readJson(
+    path2__default.default.join(nextDir, "routes-manifest.json")
+  );
+  for (const r of routes?.staticRoutes ?? []) {
+    if (isPublicRoute(r.page)) add(r.page);
+  }
+  const appPaths = await readJson(
+    path2__default.default.join(nextDir, "server", "app-paths-manifest.json")
+  );
+  for (const route of Object.keys(appPaths ?? {})) {
+    const normalized = route.replace(/\/page$/, "") || "/";
+    if (isPublicRoute(normalized)) add(normalized);
+  }
+  return out;
+}
+
+// src/discover/sitemap.ts
+var CANDIDATES = ["/sitemap.xml", "/sitemap_index.xml"];
+var LOC_RE = /<loc>([^<]+)<\/loc>/g;
+async function discoverFromSitemap(baseUrl) {
+  for (const candidate of CANDIDATES) {
+    try {
+      const res = await fetch(new URL(candidate, baseUrl));
+      if (!res.ok) continue;
+      const text = await res.text();
+      const urls = Array.from(text.matchAll(LOC_RE)).map((m) => m[1]);
+      if (!urls.length) continue;
+      return urls.map((u) => {
+        const url = new URL(u);
+        return { url: url.pathname + url.search, source: "sitemap" };
+      });
+    } catch {
+    }
+  }
+  return [];
+}
+
+// src/discover/index.ts
+function normalizePath(url) {
+  const [pathPart, query = ""] = url.split("?", 2);
+  const trimmed = pathPart.replace(/\/+$/, "");
+  const normalizedPath = trimmed === "" ? "/" : trimmed;
+  return query ? `${normalizedPath}?${query}` : normalizedPath;
+}
+function mergeBy(routes, into) {
+  for (const r of routes) {
+    const key = normalizePath(r.url);
+    if (!into.has(key)) into.set(key, { ...r, url: key });
+  }
+}
+async function discover(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const merged = /* @__PURE__ */ new Map();
+  mergeBy(await discoverFromNextManifest(cwd), merged);
+  mergeBy(await discoverFromSitemap(opts.baseUrl), merged);
+  if (!opts.skipCrawl) {
+    const crawlMax = Math.max(0, (opts.maxRoutes ?? 50) - merged.size);
+    if (crawlMax > 0) {
+      mergeBy(
+        await crawlRoutes({ baseUrl: opts.baseUrl, maxRoutes: crawlMax }),
+        merged
+      );
+    }
+  }
+  return Array.from(merged.values()).sort((a, b) => a.url.localeCompare(b.url));
+}
+
+// src/cli/commands/discover.ts
+function registerDiscover(program, out) {
+  program.command("discover").description(
+    "enumerate candidate routes via BFS crawl + Next manifest + sitemap"
+  ).option("--base-url <url>", "override base URL").option("--max-routes <n>", "cap on routes returned", "50").option("--no-crawl", "skip BFS crawl fallback").action(async (opts) => {
+    const baseUrl = resolveBaseUrl(await loadConfig(), opts.baseUrl);
+    const routes = await discover({
+      baseUrl,
+      maxRoutes: Number(opts.maxRoutes),
+      skipCrawl: !opts.crawl
+    });
+    await closeBrowser();
+    out.emit(
+      { ok: true, baseUrl, routes },
+      routes.length ? routes.map((r) => `${r.source.padEnd(14)} ${r.url}`).join("\n") : "no routes discovered"
+    );
+  });
+}
+
+// src/introspect/framework.ts
+var SIGNALS = [
+  ["next", ["next"]],
+  ["remix", ["@remix-run/dev", "@remix-run/serve"]],
+  ["sveltekit", ["@sveltejs/kit"]],
+  ["nuxt", ["nuxt", "nuxt3"]],
+  ["astro", ["astro"]],
+  ["gatsby", ["gatsby"]],
+  ["vite-react", ["vite", "react"]]
+];
+function detectFramework(pkg) {
+  const deps = pkg.allDependencies;
+  for (const [framework, required] of SIGNALS) {
+    if (required.every((d) => d in deps)) return framework;
+  }
+  return "unknown";
+}
+async function readPackageJson(cwd = process.cwd()) {
+  const file = path2__default.default.join(cwd, "package.json");
+  if (!fs.existsSync(file)) return null;
+  return JSON.parse(await promises.readFile(file, "utf8"));
+}
+function detectPackageManager(cwd = process.cwd()) {
+  let dir = cwd;
+  const { root } = path2__default.default.parse(dir);
+  while (true) {
+    if (fs.existsSync(path2__default.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs.existsSync(path2__default.default.join(dir, "bun.lockb")) || fs.existsSync(path2__default.default.join(dir, "bun.lock")))
+      return "bun";
+    if (fs.existsSync(path2__default.default.join(dir, "yarn.lock"))) return "yarn";
+    if (fs.existsSync(path2__default.default.join(dir, "package-lock.json"))) return "npm";
+    if (dir === root) return "npm";
+    dir = path2__default.default.dirname(dir);
+  }
+}
+var DEFAULT_PORTS = {
+  next: 3e3,
+  "react-scripts": 3e3,
+  vite: 5173,
+  remix: 3e3,
+  "@remix-run/dev": 3e3,
+  astro: 4321,
+  svelte: 5173,
+  vue: 5173,
+  nuxt: 3e3,
+  gatsby: 8e3,
+  parcel: 1234
+};
+var DEV_SCRIPT_CANDIDATES = ["dev", "start", "serve", "develop"];
+function inferPort(script, deps) {
+  const portArg = script.match(/(?:--port[\s=]|-p\s+)(\d+)/);
+  if (portArg) return Number(portArg[1]);
+  const portEnv = script.match(/PORT[\s=]+(\d+)/);
+  if (portEnv) return Number(portEnv[1]);
+  const depNames = Object.keys(deps);
+  for (const [pkg, port] of Object.entries(DEFAULT_PORTS)) {
+    if (depNames.some((d) => d.startsWith(pkg))) return port;
+  }
+  return DEFAULT_PORT;
+}
+function runnerFor(pm, scriptName) {
+  if (pm === "npm") return `npm run ${scriptName}`;
+  if (pm === "yarn") return `yarn ${scriptName}`;
+  if (pm === "bun") return `bun run ${scriptName}`;
+  return `pnpm ${scriptName}`;
+}
+function collectCandidates(scripts, deps, pm) {
+  const out = [];
+  for (const name of DEV_SCRIPT_CANDIDATES) {
+    if (scripts[name]) {
+      out.push({
+        name,
+        body: scripts[name],
+        command: runnerFor(pm, name),
+        port: inferPort(scripts[name], deps)
+      });
+    }
+  }
+  return out;
+}
+async function introspectPackage(cwd = process.cwd()) {
+  const pkg = await readPackageJson(cwd);
+  if (!pkg) return null;
+  const packageManager = detectPackageManager(cwd);
+  const scripts = pkg.scripts ?? {};
+  const devDependencies = pkg.devDependencies ?? {};
+  const dependencies = pkg.dependencies ?? {};
+  const allDependencies = { ...devDependencies, ...dependencies };
+  const candidates = collectCandidates(
+    scripts,
+    allDependencies,
+    packageManager
+  );
+  if (!candidates.length) return null;
+  const chosen = candidates[0];
+  return {
+    packageManager,
+    devScript: chosen.name,
+    devCommand: chosen.command,
+    port: chosen.port,
+    candidates,
+    devDependencies,
+    dependencies,
+    allDependencies
+  };
+}
+
+// src/cli/commands/init.ts
+async function buildConfig(opts) {
+  if (opts.url) {
+    if (opts.devCommand || opts.port || opts.devScript) {
+      throw new Error(
+        "--url is mutually exclusive with --dev-command/--port/--dev-script"
+      );
+    }
+    const baseUrl = new URL(opts.url).toString().replace(/\/$/, "");
+    return { devServer: null, baseUrl };
+  }
+  if (opts.devCommand) {
+    const port2 = opts.port ? Number(opts.port) : DEFAULT_PORT;
+    return {
+      devServer: {
+        command: opts.devCommand,
+        port: port2,
+        readyTimeoutMs: DEFAULT_READY_TIMEOUT_MS
+      },
+      baseUrl: `http://127.0.0.1:${port2}`
+    };
+  }
+  const pkg = await introspectPackage();
+  if (!pkg) {
+    throw new Error(
+      "no package.json with a dev/start script in cwd. Pass --url <baseUrl> or --dev-command <cmd>."
+    );
+  }
+  let chosen = pkg.candidates[0];
+  if (pkg.candidates.length > 1) {
+    if (!opts.devScript) {
+      const names = pkg.candidates.map((c) => `${c.name} (${c.command})`).join(", ");
+      throw new Error(
+        `multiple dev-script candidates: ${names}. Pass --dev-script <name> or --dev-command <cmd>.`
+      );
+    }
+    const match = pkg.candidates.find((c) => c.name === opts.devScript);
+    if (!match) {
+      const names = pkg.candidates.map((c) => c.name).join(", ");
+      throw new Error(
+        `--dev-script "${opts.devScript}" not found among candidates: ${names}`
+      );
+    }
+    chosen = match;
+  }
+  const port = opts.port ? Number(opts.port) : chosen.port;
+  return {
+    devServer: {
+      command: chosen.command,
+      port,
+      readyTimeoutMs: DEFAULT_READY_TIMEOUT_MS
+    },
+    framework: detectFramework(pkg),
+    packageManager: pkg.packageManager,
+    baseUrl: `http://127.0.0.1:${port}`
+  };
+}
+function registerInit(program, out) {
+  program.command("init").description("write .blazediff/config.json and .gitignore").option("--force", "overwrite existing config").option(
+    "--url <baseUrl>",
+    "point at an already-running server / external URL"
+  ).option("--dev-command <cmd>", "override detected dev-server command").option("--port <n>", "override detected port").option(
+    "--dev-script <name>",
+    "select a dev script by name when multiple candidates exist"
+  ).action(async (opts) => {
+    const existing = await loadConfig();
+    if (existing && !opts.force) {
+      await ensureGitignore(process.cwd());
+      out.emit(
+        {
+          ok: true,
+          created: false,
+          config: existing,
+          configHash: configHash(existing)
+        },
+        `config exists at ${paths().config} (use --force to overwrite)`
+      );
+      return;
+    }
+    const config = await buildConfig(opts);
+    await saveConfig(config);
+    await ensureGitignore(process.cwd());
+    const human = config.devServer ? `wrote ${paths().config}
+  baseUrl: ${config.baseUrl}
+  dev: ${config.devServer.command} (port ${config.devServer.port})` : `wrote ${paths().config}
+  baseUrl: ${config.baseUrl}
+  external server (no devServer managed)`;
+    out.emit(
+      { ok: true, created: true, config, configHash: configHash(config) },
+      human
+    );
+  });
+}
+
+// src/cli/commands/manifest.ts
+function registerManifest(program, out) {
+  const cmd = program.command("manifest").description("manage .blazediff/manifest.json");
+  cmd.command("add <id>").requiredOption("--url <url>").option("--viewport <WxH>", "viewport", "1280x800").option("--mask <selectors>", "selectors", "").option("--wait-for <list>", "wait list", "networkidle,fonts").option("--no-full-page", "viewport-only (default: full page)").option("--auth <required|none>", "mark auth-gated", "none").option("--created-by <agent|human>", "provenance", "agent").action(async (id, opts) => {
+    const config = await loadConfig();
+    if (!config)
+      throw new Error("no config. Run `blazediff-agent init` first.");
+    const manifest = await loadManifest() ?? emptyManifest(configHash(config));
+    const entry = makeEntry({
+      id,
+      url: opts.url,
+      viewport: parseViewport(opts.viewport),
+      mask: parseMaskList(opts.mask),
+      waitFor: parseWaitFor(opts.waitFor),
+      fullPage: opts.fullPage,
+      auth: opts.auth === "required" ? "required" : null,
+      createdBy: opts.createdBy
+    });
+    await saveManifest(addOrReplaceEntry(manifest, entry));
+    out.emit(
+      { ok: true, entry },
+      out.isTTY() ? `manifest: added ${id} (${entry.url})` : "."
+    );
+  });
+  cmd.command("remove <id>").action(async (id) => {
+    const manifest = await loadManifest();
+    if (!manifest) throw new Error("no manifest");
+    await saveManifest(removeEntry(manifest, id));
+    out.emit({ ok: true, removed: id }, `manifest: removed ${id}`);
+  });
+  cmd.command("list").action(async () => {
+    const manifest = await loadManifest();
+    if (!manifest) {
+      out.emit({ entries: [] }, "no manifest");
+      return;
+    }
+    out.emit(
+      { entries: manifest.entries },
+      manifest.entries.map((e) => `${e.id.padEnd(30)} ${e.url}`).join("\n") || "no entries"
+    );
+  });
+}
+var someExists = (paths2) => paths2.some((p) => fs.existsSync(p));
+var HARNESSES = {
+  claude: {
+    id: "claude",
+    label: "Claude Code",
+    detect: (cwd) => someExists([
+      path2.join(cwd, ".claude"),
+      path2.join(cwd, "CLAUDE.md"),
+      path2.join(cwd, "AGENTS.md")
+    ]),
+    target: (cwd) => path2.join(cwd, ".claude", "skills", "blazediff", "SKILL.md"),
+    format: "skill-file",
+    scope: "project"
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    detect: (cwd) => someExists([
+      path2.join(cwd, "AGENTS.md"),
+      path2.join(cwd, ".codex"),
+      path2.join(os.homedir(), ".codex")
+    ]),
+    target: () => path2.join(os.homedir(), ".codex", "skills", "blazediff", "SKILL.md"),
+    format: "skill-file",
+    scope: "user"
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    detect: (cwd) => someExists([path2.join(cwd, ".cursor"), path2.join(cwd, ".cursorrules")]),
+    target: (cwd) => path2.join(cwd, ".cursor", "rules", "blazediff.mdc"),
+    format: "cursor-rule",
+    scope: "project"
+  }
+};
+var ALL_HARNESSES = ["claude", "codex", "cursor"];
+function detectHarnesses(cwd) {
+  return ALL_HARNESSES.filter((id) => HARNESSES[id].detect(cwd));
+}
+function parseHarnessList(input) {
+  const tokens = input.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  if (tokens.includes("all")) return [...ALL_HARNESSES];
+  const out = [];
+  for (const t of tokens) {
+    if (!(t in HARNESSES)) {
+      throw new Error(
+        `unknown harness "${t}". valid: ${[...ALL_HARNESSES, "all"].join(", ")}`
+      );
+    }
+    if (!out.includes(t)) out.push(t);
+  }
+  return out;
+}
+var SKILL_FILES = ["SKILL.md", "JUDGING.md", "MASKING.md"];
+var cachedDir = null;
+var cachedFiles = null;
+function moduleDir() {
+  return path2.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href))));
+}
+function resolveSkillDir() {
+  if (cachedDir !== null) return cachedDir;
+  const here = moduleDir();
+  const candidates = [
+    path2.join(here, ".."),
+    path2.join(here, "..", ".."),
+    path2.join(here, "..", "..", "..", "skill", "blazediff"),
+    path2.join(here, "..", "..", "..", "..", "skill", "blazediff")
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(path2.join(dir, "SKILL.md"))) {
+      cachedDir = dir;
+      return cachedDir;
+    }
+  }
+  throw new Error(
+    `could not locate bundled SKILL.md (looked in: ${candidates.join(", ")}). reinstall @blazediff/agent.`
+  );
+}
+function loadSkillFiles() {
+  if (cachedFiles !== null) return cachedFiles;
+  const dir = resolveSkillDir();
+  cachedFiles = SKILL_FILES.filter((name) => fs.existsSync(path2.join(dir, name))).map(
+    (name) => ({ name, content: fs.readFileSync(path2.join(dir, name), "utf8") })
+  );
+  return cachedFiles;
+}
+function skillBodyOnly(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.startsWith("---")) {
+    let end = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i]?.startsWith("---")) {
+        end = i;
+        break;
+      }
+    }
+    if (end > 0)
+      return lines.slice(end + 1).join("\n").trimStart();
+  }
+  return content;
+}
+
+// src/onboard/install.ts
+function ensureTrailingNewline(s) {
+  return s.endsWith("\n") ? s : `${s}
+`;
+}
+function renderCursorRule(files) {
+  const skill = files.find((f) => f.name === "SKILL.md")?.content ?? "";
+  const sidecars = files.filter((f) => f.name !== "SKILL.md");
+  const body = skillBodyOnly(skill).trim();
+  const frontmatter = [
+    "---",
+    'description: "Run, author, or update BlazeDiff visual regression tests. Trigger on visual test, screenshot regression, blazediff, /blazediff."',
+    "alwaysApply: false",
+    "---",
+    ""
+  ].join("\n");
+  const sidecarBlocks = sidecars.map((f) => `
+
+---
+
+<!-- ${f.name} -->
+
+${f.content.trim()}`).join("");
+  return `${frontmatter}${body}${sidecarBlocks}
+`;
+}
+async function writeIfChanged(target, content, force) {
+  const stat2 = await promises.lstat(target).catch(() => null);
+  const isSymlink = stat2?.isSymbolicLink() ?? false;
+  const exists = stat2 !== null;
+  if (isSymlink) {
+    await promises.unlink(target);
+    await promises.mkdir(path2.dirname(target), { recursive: true });
+    await promises.writeFile(target, content, "utf8");
+    return "updated";
+  }
+  if (exists) {
+    const current = fs.readFileSync(target, "utf8");
+    if (current === content) return "unchanged";
+    if (!force) return "skipped-exists";
+  }
+  await promises.mkdir(path2.dirname(target), { recursive: true });
+  await promises.writeFile(target, content, "utf8");
+  return exists ? "updated" : "created";
+}
+function combineStatuses(statuses) {
+  if (statuses.some((s) => s === "skipped-exists")) return "skipped-exists";
+  if (statuses.some((s) => s === "created")) return "created";
+  if (statuses.some((s) => s === "updated")) return "updated";
+  return "unchanged";
+}
+async function installHarness(harness, cwd, opts = {}) {
+  const info = HARNESSES[harness];
+  const target = info.target(cwd);
+  const files = loadSkillFiles();
+  if (info.format === "cursor-rule") {
+    const content = renderCursorRule(files);
+    const status = await writeIfChanged(target, content, opts.force);
+    return { harness, path: target, status };
+  }
+  const targetDir = path2.dirname(target);
+  const statuses = [];
+  for (const file of files) {
+    const filePath = path2.join(targetDir, file.name);
+    const status = await writeIfChanged(
+      filePath,
+      ensureTrailingNewline(file.content),
+      opts.force
+    );
+    statuses.push(status);
+  }
+  return { harness, path: target, status: combineStatuses(statuses) };
+}
+
+// src/cli/commands/onboard.ts
+function suggestOtherHarnesses(installed) {
+  const missing = ALL_HARNESSES.filter((h) => !installed.includes(h));
+  if (missing.length === 0) return "";
+  const labels = missing.map((h) => HARNESSES[h].label).join(" / ");
+  const ids = missing.join(",");
+  return `
+Also use ${labels}? Run: blazediff-agent onboard --harness ${ids}`;
+}
+async function promptForHarnesses() {
+  const rl = promises$1.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  try {
+    const lines = [
+      "No coding-agent harness detected. Which one(s) do you use?",
+      ...ALL_HARNESSES.map(
+        (id, i) => `  [${i + 1}] ${HARNESSES[id].label.padEnd(12)} ${HARNESSES[id].target(process.cwd())}`
+      ),
+      "  [a] all three",
+      ""
+    ];
+    process.stderr.write(`${lines.join("\n")}`);
+    const answer = (await rl.question("Choice (1/2/3/a): ")).trim().toLowerCase();
+    if (!answer) throw new Error("no harness selected; aborting");
+    if (answer === "a" || answer === "all") return [...ALL_HARNESSES];
+    const idx = Number(answer);
+    if (!Number.isInteger(idx) || idx < 1 || idx > ALL_HARNESSES.length) {
+      throw new Error(
+        `invalid choice "${answer}"; expected 1-${ALL_HARNESSES.length} or "a"`
+      );
+    }
+    return [ALL_HARNESSES[idx - 1]];
+  } finally {
+    rl.close();
+  }
+}
+function humanizeResults(results) {
+  const lines = results.map((r) => {
+    const verb = r.status === "created" ? "wrote" : r.status === "updated" ? "updated" : r.status === "unchanged" ? "unchanged" : "skipped (exists; pass --force to overwrite)";
+    const info = HARNESSES[r.harness];
+    const scopeTag = info.scope === "user" ? " [user-global]" : "";
+    return `  ${info.label.padEnd(12)} ${verb}: ${r.path}${scopeTag}`;
+  });
+  const installed = results.map((r) => r.harness);
+  const hint = suggestOtherHarnesses(installed);
+  return ["BlazeDiff playbook installed:", ...lines].join("\n") + hint;
+}
+function registerOnboard(program, out) {
+  program.command("onboard").description(
+    "install the BlazeDiff playbook into the coding-agent harness in cwd. Auto-detects Claude Code (.claude/), Codex (AGENTS.md), and Cursor (.cursor/). Prompts on TTY when none detected."
+  ).option(
+    "--harness <list>",
+    'comma-separated harness ids, or "all". valid: claude,codex,cursor,all'
+  ).option(
+    "--force",
+    "overwrite existing playbook files (idempotent without --force only when content matches)"
+  ).action(async (opts) => {
+    const cwd = process.cwd();
+    let targets;
+    if (opts.harness) {
+      targets = parseHarnessList(opts.harness);
+    } else {
+      const detected = detectHarnesses(cwd);
+      if (detected.length > 0) {
+        targets = detected;
+      } else if (out.isTTY() && !out.isJson()) {
+        targets = await promptForHarnesses();
+      } else {
+        throw new Error(
+          "no coding-agent harness detected in cwd. pass --harness <claude|codex|cursor|all> explicitly."
+        );
+      }
+    }
+    const results = [];
+    for (const t of targets) {
+      results.push(await installHarness(t, cwd, { force: opts.force }));
+    }
+    out.emit(
+      {
+        ok: true,
+        detected: detectHarnesses(cwd),
+        installed: results
+      },
+      humanizeResults(results)
+    );
+  });
+}
+var execFileP = util.promisify(child_process.execFile);
+async function isPortOpen(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ port, host });
+    socket.setTimeout(500);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => resolve(false));
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+async function waitForPort(port, timeoutMs = 6e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isPortOpen(port)) return;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  throw new Error(`dev server did not open port ${port} within ${timeoutMs}ms`);
+}
+async function findPidByPort(port) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin" || platform === "linux") {
+      const { stdout } = await execFileP("lsof", [
+        "-ti",
+        `tcp:${port}`,
+        "-sTCP:LISTEN"
+      ]);
+      const pid = Number(stdout.trim().split("\n")[0]);
+      return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+    if (platform === "win32") {
+      const { stdout } = await execFileP("netstat", ["-ano"]);
+      const line = stdout.split(/\r?\n/).find((l) => l.includes(`:${port} `) && l.includes("LISTENING"));
+      if (!line) return null;
+      const parts = line.trim().split(/\s+/);
+      const pid = Number(parts[parts.length - 1]);
+      return Number.isFinite(pid) && pid > 0 ? pid : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function startServer(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const logPath = opts.logPath ?? paths(cwd).serverLog;
+  const pidPath = opts.pidPath ?? paths(cwd).serverPid;
+  await promises.mkdir(path2__default.default.dirname(logPath), { recursive: true });
+  if (await isPortOpen(opts.port)) {
+    const discoveredPid = await findPidByPort(opts.port);
+    if (discoveredPid) {
+      await promises.writeFile(pidPath, String(discoveredPid), "utf8").catch(() => {
+      });
+    }
+    return {
+      pid: discoveredPid ?? 0,
+      port: opts.port,
+      url: `http://127.0.0.1:${opts.port}`,
+      attached: true
+    };
+  }
+  const [bin, ...args] = parseCommand(opts.command);
+  const child = child_process.spawn(bin, args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    env: { ...process.env, FORCE_COLOR: "0", CI: "1" }
+  });
+  const logStream = await import('fs').then(
+    (m) => m.createWriteStream(logPath, { flags: "a" })
+  );
+  child.stdout?.pipe(logStream);
+  child.stderr?.pipe(logStream);
+  if (!child.pid) throw new Error("failed to spawn dev server");
+  await promises.writeFile(pidPath, String(child.pid), "utf8");
+  installSignalHandlers(child);
+  try {
+    await waitForPort(opts.port, opts.readyTimeoutMs ?? 6e4);
+  } catch (err) {
+    await stopProcess(child.pid);
+    throw err;
+  }
+  return {
+    pid: child.pid,
+    port: opts.port,
+    url: `http://127.0.0.1:${opts.port}`
+  };
+}
+async function stopServer(cwd = process.cwd(), portFallback) {
+  const pidPath = paths(cwd).serverPid;
+  let pid = null;
+  let via = "none";
+  if (fs.existsSync(pidPath)) {
+    const raw = (await promises.readFile(pidPath, "utf8")).trim();
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed > 0 && processExists(parsed)) {
+      pid = parsed;
+      via = "pidfile";
+    }
+  }
+  if (!pid && portFallback) {
+    pid = await findPidByPort(portFallback);
+    if (pid) via = "port";
+  }
+  if (!pid) {
+    await promises.writeFile(pidPath, "", "utf8").catch(() => {
+    });
+    return { killed: false, pid: null, via: "none" };
+  }
+  await stopProcess(pid);
+  await promises.writeFile(pidPath, "", "utf8").catch(() => {
+  });
+  return { killed: true, pid, via };
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopProcess(pid) {
+  if (!pid) return;
+  await new Promise((resolve) => {
+    treeKill__default.default(pid, "SIGTERM", (err) => {
+      if (err) {
+        treeKill__default.default(pid, "SIGKILL", () => resolve());
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function parseCommand(command) {
+  const out = [];
+  let current = "";
+  let inQuote = false;
+  for (const ch of command) {
+    if (ch === '"') {
+      inQuote = !inQuote;
+      continue;
+    }
+    if (ch === " " && !inQuote) {
+      if (current) {
+        out.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current) out.push(current);
+  return out;
+}
+var signalsInstalled = false;
+function installSignalHandlers(child) {
+  if (signalsInstalled) return;
+  signalsInstalled = true;
+  const cleanup = () => {
+    if (child.pid) {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+      }
+      treeKill__default.default(child.pid, "SIGKILL", () => {
+      });
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  process.on("exit", cleanup);
+}
+
+// src/cli/commands/reset.ts
+async function stopTrackedServer() {
+  const config = await loadConfig();
+  if (!config?.devServer) return { stopped: false };
+  try {
+    const result = await stopServer(process.cwd(), config.devServer.port);
+    return { stopped: result.killed, via: result.via, pid: result.pid };
+  } catch {
+    return { stopped: false };
+  }
+}
+function registerReset(program, out) {
+  program.command("reset").description(
+    "wipe .blazediff/ entirely - config, manifest, baselines, actual, judgments, summary, pid/log (stops the dev server first if one is tracked). Re-run /blazediff or `init` afterward to start from scratch."
+  ).option("--yes", "do not prompt; required when stdin is a TTY").action(async (opts) => {
+    const root = paths().root;
+    if (!fs.existsSync(root)) {
+      out.emit(
+        { ok: true, removed: false, root },
+        `nothing to reset (no ${root})`
+      );
+      return;
+    }
+    if (out.isTTY() && !opts.yes && !out.isJson()) {
+      throw new Error(
+        `refusing to wipe ${root} without --yes (interactive run)`
+      );
+    }
+    const stopOutcome = await stopTrackedServer();
+    await promises.rm(root, { recursive: true, force: true });
+    out.emit(
+      { ok: true, removed: true, root, devServer: stopOutcome },
+      stopOutcome.stopped ? `stopped dev server (pid ${stopOutcome.pid} via ${stopOutcome.via}) and removed ${root}` : `removed ${root}`
+    );
+  });
+}
+async function resolveTargets(manifest, ids, opts) {
+  const exclusive = [
+    ids.length > 0,
+    Boolean(opts.failed),
+    Boolean(opts.all)
+  ].filter(Boolean).length;
+  if (exclusive === 0) throw new Error("provide ids, --failed, or --all");
+  if (exclusive > 1)
+    throw new Error("ids / --failed / --all are mutually exclusive");
+  if (opts.all) return new Set(manifest.entries.map((e) => e.id));
+  if (opts.failed) {
+    const judgmentsDir = paths().judgments;
+    if (!fs.existsSync(judgmentsDir)) {
+      throw new Error(
+        `no judgments at ${judgmentsDir}. Run \`blazediff-agent check\` first.`
+      );
+    }
+    const names = await promises.readdir(judgmentsDir);
+    const failed = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const full = path2__default.default.join(judgmentsDir, name);
+      if (fs.statSync(full).isDirectory()) failed.add(name);
+    }
+    return failed;
+  }
+  const targets = new Set(ids);
+  const missing = ids.filter(
+    (id) => !manifest.entries.some((e) => e.id === id)
+  );
+  if (missing.length) throw new Error(`unknown ids: ${missing.join(", ")}`);
+  return targets;
+}
+function registerRewrite(program, out) {
+  program.command("rewrite [ids...]").description(
+    "rewrite baselines for existing manifest entries, preserving mask/viewport/etc. Pick targets via positional ids, --failed (uses .blazediff/judgments/ from last check), or --all."
+  ).option("--failed", "rewrite entries that failed the most recent check").option("--all", "rewrite every manifest entry").option("--base-url <url>", "override base URL").action(async (ids, opts) => {
+    const manifest = await loadManifest();
+    if (!manifest) throw new Error("no manifest. Run authoring first.");
+    const baseUrl = resolveBaseUrl(await loadConfig(), opts.baseUrl);
+    const targets = await resolveTargets(manifest, ids, opts);
+    if (targets.size === 0 && opts.failed) {
+      out.emit({ ok: true, rewritten: 0 }, "no failed entries to rewrite");
+      return;
+    }
+    const routes = manifest.entries.filter((e) => targets.has(e.id)).map((e) => ({
+      id: e.id,
+      url: e.url,
+      mask: e.mask,
+      viewport: e.viewport,
+      waitFor: e.waitFor,
+      fullPage: e.fullPage
+    }));
+    const report = await runCaptures({
+      baseUrl,
+      routes,
+      mode: "baseline",
+      writeManifest: true
+    });
+    const failureLines3 = report.results.filter((r) => !r.ok).map((r) => `  \u2717 ${r.id}: ${r.error ?? "failed"}`);
+    const human = report.failed === 0 ? `rewrote ${report.succeeded}/${report.total} baseline${report.total === 1 ? "" : "s"}` : [
+      `rewrote ${report.succeeded}/${report.total} (${report.failed} failed):`,
+      ...failureLines3
+    ].join("\n");
+    out.emit(report, human);
+    if (report.failed > 0) process.exitCode = 1;
+  });
+}
+
+// src/graph/nodes/aggregate.ts
+async function aggregateNode(state) {
+  const options = state.options;
+  if (!options) throw new Error("aggregateNode: options missing");
+  const manifest = state.manifest;
+  if (!manifest) throw new Error("aggregateNode: manifest missing");
+  const results = state.results;
+  const passed = results.filter((r) => r.status === "pass").length;
+  const pendingJudgments = results.filter(
+    (r) => r.status === "needs-judgment"
+  ).length;
+  const report = {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalEntries: results.length,
+    passed,
+    failed: results.length - passed - pendingJudgments,
+    pendingJudgments,
+    results
+  };
+  await writeJudgments({ report, manifest, cwd: options.cwd });
+  await writeSummaryMarkdown(report, options.cwd);
+  await ensureGitignore(options.cwd);
+  return { report };
+}
+
+// src/graph/nodes/load.ts
+async function loadNode(state) {
+  if (!state.options) {
+    throw new Error("loadNode: graph options missing");
+  }
+  const manifest = await loadManifest(state.options.cwd);
+  if (!manifest) {
+    throw new Error(
+      `no manifest found at ${paths(state.options.cwd).manifest}. Run \`blazediff init\` then \`/blazediff\` (or capture manually) first.`
+    );
+  }
+  return { entries: manifest.entries, manifest };
+}
+function narrowRegion2(r) {
+  return {
+    bbox: r.bbox,
+    pixelCount: r.pixelCount,
+    percentage: r.percentage,
+    changeType: r.changeType,
+    confidence: r.confidence
+  };
+}
+function skipResult2(entry, message) {
+  return { id: entry.id, url: entry.url, status: "pass", message };
+}
+function staleResult2(entry) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "stale-baseline",
+    message: "captureHash mismatch: entry was edited without re-capturing"
+  };
+}
+function passResult3(entry, baselinePath, actualPath) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "pass",
+    baselinePath,
+    actualPath
+  };
+}
+function missingBaselineResult2(entry, baselinePath) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "missing-baseline",
+    message: `baseline missing at ${baselinePath}`
+  };
+}
+function failResult2(entry, outcome, actualPath, baselinePath, verdict) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "fail",
+    diffCount: outcome.diffCount,
+    diffPercentage: outcome.diffPercentage,
+    severity: outcome.interpretation?.severity,
+    regions: outcome.interpretation?.regions?.map(narrowRegion2),
+    verdict,
+    diffPath: outcome.diffPath,
+    baselinePath,
+    actualPath,
+    message: outcome.reason === "layout-diff" ? "layout differs (dimensions changed)" : `${outcome.diffCount ?? 0} pixels differ (${(outcome.diffPercentage ?? 0).toFixed(3)}%)`
+  };
+}
+function makeProcessNode(semaphore) {
+  return async function processNode(state) {
+    const entry = state.entry;
+    const options = state.options;
+    if (!entry || !options) {
+      throw new Error("processNode: entry or options missing");
+    }
+    if (entry.auth === "required") {
+      return {
+        results: [
+          skipResult2(entry, "skipped: auth required (deferred to v0.2)")
+        ]
+      };
+    }
+    if (isEntryStale(entry)) {
+      return { results: [staleResult2(entry)] };
+    }
+    const capture = await semaphore.run(
+      () => captureScreenshot(
+        options.baseUrl,
+        {
+          id: entry.id,
+          url: entry.url,
+          viewport: entry.viewport,
+          mask: entry.mask,
+          waitFor: entry.waitFor,
+          fullPage: entry.fullPage ?? DEFAULT_FULL_PAGE,
+          mode: "actual"
+        },
+        options.cwd
+      )
+    );
+    const baselinePath = path2__default.default.join(options.baselinesDir, `${entry.id}.png`);
+    const outcome = await diffEntry(
+      entry.id,
+      baselinePath,
+      capture.outputPath,
+      { threshold: options.threshold, emitDiffPng: options.emitDiffPng },
+      options.cwd
+    );
+    if (outcome.match) {
+      return { results: [passResult3(entry, baselinePath, capture.outputPath)] };
+    }
+    if (outcome.reason === "file-not-exists") {
+      return { results: [missingBaselineResult2(entry, baselinePath)] };
+    }
+    const verdict = deriveVerdict({
+      reason: outcome.reason,
+      interpretation: outcome.interpretation,
+      diffCount: outcome.diffCount,
+      diffPercentage: outcome.diffPercentage
+    });
+    let result = failResult2(
+      entry,
+      outcome,
+      capture.outputPath,
+      baselinePath,
+      verdict
+    );
+    if (result.verdict?.label === "ambiguous" && result.baselinePath && result.actualPath) {
+      const judge = resolveJudge(options.judge);
+      const output = await judge.judge(
+        {
+          entry,
+          baselinePath: result.baselinePath,
+          actualPath: result.actualPath,
+          diffPath: result.diffPath,
+          regions: result.regions,
+          diffPercentage: result.diffPercentage,
+          severity: result.severity,
+          heuristicVerdict: result.verdict
+        },
+        options.cwd
+      );
+      if (output.kind === "judged") {
+        result = { ...result, verdict: output.verdict };
+      } else {
+        result = {
+          ...result,
+          status: "needs-judgment",
+          message: `awaiting judgment in ${output.requestPath}`
+        };
+      }
+    }
+    return { results: [result] };
+  };
+}
+
+// src/graph/semaphore.ts
+var Semaphore = class {
+  constructor(limit) {
+    this.limit = limit;
+    this.current = 0;
+    this.queue = [];
+    if (limit < 1)
+      throw new Error(`semaphore limit must be >= 1 (got ${limit})`);
+  }
+  async run(fn) {
+    if (this.current >= this.limit) {
+      await new Promise((resolve) => this.queue.push(resolve));
+    }
+    this.current++;
+    try {
+      return await fn();
+    } finally {
+      this.current--;
+      const next = this.queue.shift();
+      if (next) next();
+    }
+  }
+};
+var GraphState = langgraph.Annotation.Root({
+  options: langgraph.Annotation({
+    reducer: (acc, next) => next ?? acc,
+    default: () => void 0
+  }),
+  entries: langgraph.Annotation({
+    reducer: (acc, next) => next ?? acc,
+    default: () => []
+  }),
+  entry: langgraph.Annotation({
+    reducer: (_, next) => next,
+    default: () => void 0
+  }),
+  results: langgraph.Annotation({
+    reducer: (acc, next) => [...acc, ...next],
+    default: () => []
+  }),
+  manifest: langgraph.Annotation({
+    reducer: (acc, next) => next ?? acc,
+    default: () => void 0
+  }),
+  report: langgraph.Annotation({
+    reducer: (acc, next) => next ?? acc,
+    default: () => void 0
+  })
+});
+
+// src/graph/index.ts
+function buildGraph(semaphore) {
+  return new langgraph.StateGraph(GraphState).addNode("load", loadNode).addNode("process", makeProcessNode(semaphore)).addNode("aggregate", aggregateNode).addEdge(langgraph.START, "load").addConditionalEdges(
+    "load",
+    (state) => state.entries.map(
+      (entry) => new langgraph.Send("process", { entry, options: state.options })
+    ),
+    ["process"]
+  ).addEdge("process", "aggregate").addEdge("aggregate", langgraph.END).compile();
+}
+async function runGraph(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const concurrency = opts.concurrency ?? defaultConcurrency();
+  const semaphore = new Semaphore(concurrency);
+  const baselinesDir = paths(cwd).baselines;
+  const graph = buildGraph(semaphore);
+  let finalState;
+  try {
+    finalState = await graph.invoke({
+      options: {
+        baseUrl: opts.baseUrl,
+        cwd,
+        threshold: opts.threshold,
+        concurrency,
+        emitDiffPng: opts.emitDiffPng ?? true,
+        judge: opts.judge ?? "none",
+        baselinesDir
+      }
+    });
+  } finally {
+    await closeBrowser();
+  }
+  const report = finalState.report;
+  if (!report) {
+    throw new Error("runGraph: graph completed without producing a report");
+  }
+  if (opts.junitPath) {
+    const target = path2__default.default.isAbsolute(opts.junitPath) ? opts.junitPath : path2__default.default.join(cwd, opts.junitPath);
+    await writeJunit(report, target);
+  }
+  return report;
+}
+
+// src/cli/commands/run.ts
+function slimResult2(r) {
+  return {
+    id: r.id,
+    url: r.url,
+    status: r.status,
+    verdict: r.verdict ? {
+      label: r.verdict.label,
+      headline: r.verdict.headline,
+      action: r.verdict.action
+    } : void 0
+  };
+}
+function slimReport2(report, summaryPath) {
+  return {
+    summaryPath,
+    createdAt: report.createdAt,
+    totalEntries: report.totalEntries,
+    passed: report.passed,
+    failed: report.failed,
+    pendingJudgments: report.pendingJudgments,
+    results: report.results.filter((r) => r.status !== "pass").map(slimResult2)
+  };
+}
+function failureLines2(results) {
+  return results.filter((r) => r.status !== "pass").flatMap((r) => {
+    const lines = [];
+    const prefix = r.status === "needs-judgment" ? "?" : "\u2717";
+    if (r.verdict) {
+      lines.push(
+        `  ${prefix} ${r.id}  [${r.verdict.label}]  ${r.verdict.headline}`
+      );
+      lines.push(`      \u2192 ${r.verdict.action}`);
+    } else {
+      const detail = typeof r.diffPercentage === "number" ? `${r.status} (${r.diffPercentage.toFixed(3)}%)` : r.status;
+      lines.push(`  ${prefix} ${r.id}: ${detail}`);
+    }
+    if (r.status === "needs-judgment" && r.message) {
+      lines.push(`      ${r.message}`);
+    }
+    if (r.diffPath) lines.push(`      diff: ${r.diffPath}`);
+    return lines;
+  });
+}
+function parseJudge2(input) {
+  if (input === "host" || input === "none") return input;
+  throw new Error(`unknown --judge backend: ${input} (expected: host | none)`);
+}
+function parseMode(input) {
+  if (input === "actual") return input;
+  if (input === "baseline") {
+    throw new Error(
+      "`run --mode baseline` is not yet implemented. Use `init` + `capture` for authoring."
+    );
+  }
+  throw new Error(`unknown --mode: ${input} (expected: actual)`);
+}
+function registerRun(program, out) {
+  program.command("run").description(
+    "streaming check pipeline via LangGraph (alternative to `check`)"
+  ).option("--mode <mode>", "pipeline mode (actual)", "actual").option("--base-url <url>", "override base URL").option(
+    "--threshold <n>",
+    "color threshold (0-1)",
+    String(DEFAULT_THRESHOLD)
+  ).option(
+    "--concurrency <n>",
+    "max entries captured in parallel (default: auto based on CPU cores, capped at 8)"
+  ).option("--no-diff-png", "skip writing diff PNGs").option("--junit <path>", "write JUnit XML to this path (default: skipped)").option(
+    "--judge <backend>",
+    "judge backend for ambiguous diffs (host | none)",
+    "none"
+  ).action(async (opts) => {
+    parseMode(opts.mode);
+    const baseUrl = resolveBaseUrl(await loadConfig(), opts.baseUrl);
+    const report = await runGraph({
+      baseUrl,
+      threshold: Number(opts.threshold),
+      concurrency: opts.concurrency ? Number(opts.concurrency) : void 0,
+      emitDiffPng: opts.diffPng,
+      junitPath: opts.junit,
+      judge: parseJudge2(opts.judge)
+    });
+    const summaryPath = paths().summary;
+    const summary = report.pendingJudgments > 0 ? `${report.passed}/${report.totalEntries} passed (${report.failed} failed, ${report.pendingJudgments} pending judgment)` : report.failed === 0 ? `${report.passed}/${report.totalEntries} passed` : `${report.passed}/${report.totalEntries} passed (${report.failed} failed)`;
+    const human = report.failed === 0 && report.pendingJudgments === 0 ? `${summary}
+  summary: ${summaryPath}` : [
+      `${summary}:`,
+      ...failureLines2(report.results),
+      `  summary: ${summaryPath}`,
+      report.pendingJudgments > 0 ? `  pending: ${paths().judgments}/ - host writes <id>/verdict.json, then re-run check --apply-judgments` : void 0
+    ].filter(Boolean).join("\n");
+    out.emit(slimReport2(report, summaryPath), human);
+    if (report.failed > 0) process.exitCode = 1;
+  });
+}
+
+// src/cli/commands/serve-status.ts
+function registerServeStatus(program, out) {
+  program.command("serve-status").description("start/stop the configured dev server").option("--start", "start (default)").option(
+    "--detach",
+    "alias for --start; waits up to readyTimeoutMs for the port"
+  ).option("--kill", "stop the dev server").option("--port <n>", "override port from config").action(async (opts) => {
+    const config = await loadConfig();
+    if (!config) {
+      throw new Error(
+        "no .blazediff/config.json. Run `blazediff-agent init` first."
+      );
+    }
+    if (!config.devServer) {
+      out.emit(
+        { ok: true, external: true, baseUrl: config.baseUrl },
+        `external base URL (${config.baseUrl}); no dev server managed`
+      );
+      return;
+    }
+    const port = opts.port ? Number(opts.port) : config.devServer.port;
+    if (opts.kill) {
+      const result = await stopServer(process.cwd(), port);
+      const human = result.killed ? `dev server stopped (pid ${result.pid} via ${result.via})` : `no dev server found to stop on :${port}`;
+      out.emit({ ok: true, stopped: result.killed, ...result }, human);
+      return;
+    }
+    if (await isPortOpen(port)) {
+      out.emit(
+        { ok: true, attached: true, port },
+        `dev server already up on :${port}`
+      );
+      return;
+    }
+    const handle = await startServer({
+      command: config.devServer.command,
+      port,
+      readyTimeoutMs: config.devServer.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS
+    });
+    out.emit(
+      { ok: true, ...handle },
+      `dev server up on :${handle.port} (pid ${handle.pid})`
+    );
+  });
+}
+function extractCwdArg(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-C" || a === "--cwd") return argv[i + 1] ?? null;
+    if (a.startsWith("--cwd=")) return a.slice("--cwd=".length);
+    if (a.startsWith("-C=")) return a.slice("-C=".length);
+  }
+  return null;
+}
+function applyCwdFromArgv() {
+  const value = extractCwdArg(process.argv.slice(2));
+  if (!value) return;
+  const resolved = path2__default.default.resolve(value);
+  if (fs.existsSync(resolved)) {
+    process.chdir(resolved);
+    return;
+  }
+  const cwdBase = path2__default.default.basename(process.cwd());
+  const inputBase = path2__default.default.basename(value);
+  const doubled = cwdBase && inputBase && cwdBase === inputBase && resolved.endsWith(path2__default.default.join(cwdBase, cwdBase));
+  if (doubled) {
+    throw new Error(
+      `--cwd "${value}" resolves to ${resolved} which does not exist. Looks like you may already be inside that directory - re-run with --cwd as an absolute path, or from the parent.`
+    );
+  }
+  throw new Error(`--cwd path does not exist: ${resolved}`);
+}
+function maybeDefaultToCheck() {
+  const positional = process.argv.slice(2).filter((a) => !a.startsWith("-"));
+  if (positional.length) return;
+  if (!fs.existsSync(paths().manifest)) return;
+  process.argv = [
+    process.argv[0],
+    process.argv[1],
+    "check",
+    ...process.argv.slice(2)
+  ];
+}
+
+// src/cli/output.ts
+function makeOutput(getRootOpts) {
+  const isJson = () => Boolean(getRootOpts().json);
+  const isQuiet = () => Boolean(getRootOpts().quiet);
+  const isTTY = () => Boolean(process.stdout.isTTY);
+  const emit = (payload, human) => {
+    if (isQuiet()) return;
+    if (isJson()) {
+      process.stdout.write(`${JSON.stringify(payload)}
+`);
+      return;
+    }
+    if (human) process.stdout.write(`${human}
+`);
+  };
+  return { isJson, isQuiet, isTTY, emit };
+}
+
+// src/cli.ts
+function buildProgram() {
+  const program = new commander.Command().name("blazediff-agent").description("Agentic visual regression for BlazeDiff").version("0.1.2").option("-C, --cwd <path>", "operate on a different directory").option("--json", "emit JSON to stdout where applicable").option("--quiet", "suppress non-error output");
+  const out = makeOutput(() => program.opts());
+  registerOnboard(program, out);
+  registerInit(program, out);
+  registerDiscover(program, out);
+  registerServeStatus(program, out);
+  registerCapture(program, out);
+  registerBrowsers(program, out);
+  registerDiff(program, out);
+  registerManifest(program, out);
+  registerCheck(program, out);
+  registerRun(program, out);
+  registerRewrite(program, out);
+  registerReset(program, out);
+  return program;
+}
+async function main() {
+  try {
+    applyCwdFromArgv();
+  } catch (err) {
+    process.stderr.write(`${err.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  maybeDefaultToCheck();
+  const program = buildProgram();
+  try {
+    await program.parseAsync();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const json = Boolean(program.opts().json);
+    if (json) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: false, error: message })}
+`
+      );
+    } else {
+      process.stderr.write(`error: ${message}
+`);
+    }
+    process.exitCode = 1;
+  } finally {
+    await closeBrowser();
+  }
+}
+void main();