@blazediff/agent 0.0.1 → 0.1.0

package/dist/cli.js

@@ -10,14 +10,15 @@ 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 langgraph = require('@langchain/langgraph');
 var sharp = require('sharp');
+var langgraphCheckpoint = require('@langchain/langgraph-checkpoint');
+var coreNative = require('@blazediff/core-native');
 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 }; }
@@ -50,6 +51,7 @@ var CHROMIUM_FLAGS = [
 ];
 var cachedBrowser = null;
 var launchInFlight = null;
+var contextPool = /* @__PURE__ */ new Map();
 async function getBrowser() {
   if (cachedBrowser?.isConnected()) return cachedBrowser;
   if (launchInFlight) return launchInFlight;
@@ -66,15 +68,22 @@ async function closeBrowser() {
     await launchInFlight.catch(() => {
     });
   }
+  const ctxs = Array.from(contextPool.values()).flat();
+  contextPool.clear();
+  await Promise.all(ctxs.map((c) => c.close().catch(() => {
+  })));
   if (!cachedBrowser) return;
   await cachedBrowser.close().catch(() => {
   });
   cachedBrowser = null;
 }
-async function openStableContext(opts) {
+function viewportKey(v) {
+  return `${v.width}x${v.height}`;
+}
+async function createStableContext(viewport) {
   const browser = await getBrowser();
   const context = await browser.newContext({
-    viewport: opts.viewport,
+    viewport,
     deviceScaleFactor: 1,
     reducedMotion: "reduce",
     forcedColors: "none",
@@ -119,12 +128,39 @@ async function openStableContext(opts) {
     },
     { frozenNow: FROZEN_NOW }
   );
-  const page = await context.newPage();
+  return context;
+}
+async function acquireStableContext(viewport) {
+  const key = viewportKey(viewport);
+  const pool = contextPool.get(key);
+  if (pool && pool.length > 0) {
+    const context2 = pool.pop();
+    return { context: context2, viewport };
+  }
+  const context = await createStableContext(viewport);
+  return { context, viewport };
+}
+async function releaseStableContext(handle) {
+  const key = viewportKey(handle.viewport);
+  if (!cachedBrowser?.isConnected()) {
+    await handle.context.close().catch(() => {
+    });
+    return;
+  }
+  const pool = contextPool.get(key);
+  if (pool) {
+    pool.push(handle.context);
+  } else {
+    contextPool.set(key, [handle.context]);
+  }
+}
+async function openStablePage(handle) {
+  const page = await handle.context.newPage();
   const injectStability = () => page.addStyleTag({ content: STABILITY_CSS }).catch(() => {
   });
   await injectStability();
   page.on("load", injectStability);
-  return { context, page };
+  return page;
 }
 async function waitForStability(page, waitFor) {
   for (const w of waitFor) {
@@ -254,6 +290,7 @@ var paths = (cwd = process.cwd()) => {
     baselines: path2__default.default.join(root, "baselines"),
     actual: path2__default.default.join(root, "actual"),
     judgments: path2__default.default.join(root, "judgments"),
+    checkpoints: path2__default.default.join(root, "checkpoints"),
     summary: path2__default.default.join(root, "summary.md"),
     gitignore: path2__default.default.join(root, ".gitignore"),
     serverLog: path2__default.default.join(root, "dev-server.log"),
@@ -267,7 +304,8 @@ async function captureScreenshot(baseUrl, opts, cwd = process.cwd()) {
   const waitFor = opts.waitFor ?? DEFAULT_WAIT_FOR;
   const masks = opts.mask ?? [];
   const fullPage = opts.fullPage ?? DEFAULT_FULL_PAGE;
-  const { context, page } = await openStableContext({ viewport});
+  const handle = await acquireStableContext(viewport);
+  const page = await openStablePage(handle);
   try {
     const url = new URL(opts.url, baseUrl).toString();
     await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
@@ -289,8 +327,9 @@ async function captureScreenshot(baseUrl, opts, cwd = process.cwd()) {
     });
     return { id: opts.id, outputPath, mode: opts.mode, bytes: buffer.length };
   } finally {
-    await context.close().catch(() => {
+    await page.close().catch(() => {
     });
+    await releaseStableContext(handle);
   }
 }
 async function loadConfig(cwd = process.cwd()) {
@@ -314,6 +353,30 @@ function resolveBaseUrl(config, override) {
   throw new Error("no baseUrl: pass --base-url or run `blazediff-agent init`");
 }
 
+// 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();
+    }
+  }
+};
+
 // src/types.ts
 var STABILITY_HOOKS_VERSION = 1;
 
@@ -439,55 +502,62 @@ async function runCaptures(opts) {
   });
   let manifest = writeManifest ? await loadOrCreateManifest(cwd) : null;
   let manifestUpdates = 0;
+  const slot = new Array(valid.length);
+  const semaphore = new Semaphore(opts.concurrency ?? defaultConcurrency());
   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({
+    await Promise.all(
+      valid.map(
+        (r, i) => semaphore.run(async () => {
+          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
+            );
+            slot[i] = {
               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
-        });
-      }
-    }
+              mode,
+              ok: true,
+              outputPath: shot.outputPath,
+              bytes: shot.bytes
+            };
+            if (mode === "baseline" && manifest) {
+              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) {
+            slot[i] = {
+              id: r.id,
+              url: r.url,
+              mode,
+              ok: false,
+              error: err.message
+            };
+          }
+        })
+      )
+    );
+    for (const r of slot) results.push(r);
     if (manifest && manifestUpdates > 0) await saveManifest(manifest, cwd);
   } finally {
     await closeBrowser();
@@ -508,6 +578,29 @@ function parseViewport(value) {
   if (!w || !h) throw new Error(`invalid viewport: ${value} (expected WxH)`);
   return { width: w, height: h };
 }
+function parsePositiveInteger(value, flagName) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`invalid ${flagName}: ${value} (expected integer >= 1)`);
+  }
+  return parsed;
+}
+function parsePort(value, flagName = "--port") {
+  const parsed = parsePositiveInteger(value, flagName);
+  if (parsed > 65535) {
+    throw new Error(
+      `invalid ${flagName}: ${value} (expected integer <= 65535)`
+    );
+  }
+  return parsed;
+}
+function parseThreshold(value, flagName = "--threshold") {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+    throw new Error(`invalid ${flagName}: ${value} (expected number 0-1)`);
+  }
+  return parsed;
+}
 function parseMaskList(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
@@ -609,6 +702,7 @@ function registerCapture(program, out) {
 var ENTRIES = [
   "actual/",
   "judgments/",
+  "checkpoints/",
   "summary.md",
   "dev-server.log",
   "dev-server.pid",
@@ -640,343 +734,126 @@ ${missing.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"
-    };
+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}`);
   }
-  if (result.reason === "layout-diff") {
-    return {
-      id,
-      baselinePath,
-      actualPath,
-      diffPath,
-      match: false,
-      reason: "layout-diff"
-    };
+  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 interpretation = await coreNative.interpret(baselinePath, actualPath, {
-    threshold,
-    antialiasing
-  }).catch(() => void 0);
+  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 {
-    id,
-    baselinePath,
-    actualPath,
-    diffPath,
-    match: false,
-    reason: "pixel-diff",
-    diffCount: result.diffCount,
-    diffPercentage: result.diffPercentage,
-    interpretation
+    locatorPath: locatorName,
+    tilesPath: tilesName,
+    regions: regionData.map((r) => ({
+      bbox: r.region.bbox,
+      pixelCount: r.region.pixelCount
+    }))
   };
 }
 
-// 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;
+// 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 = {
@@ -997,22 +874,299 @@ var noneJudge = {
     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("/");
+var ROOT_NS_SENTINEL = "_root";
+function nsDir(ns) {
+  return ns === "" ? ROOT_NS_SENTINEL : ns;
 }
-function img(src, alt) {
-  return `<img src="${src}" width="${PREVIEW_WIDTH}" alt="${alt}">`;
+function encode(buf) {
+  return Buffer.from(buf).toString("base64");
 }
-function baselineCell(r, cwd) {
-  const rel = toBlazediffRel(cwd, r.baselinePath) ?? `baselines/${r.id}.png`;
-  return img(rel, `${r.id} baseline`);
+function decode(s) {
+  return Buffer.from(s, "base64");
+}
+async function readJson(file) {
+  try {
+    const raw = await promises.readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+async function writeJsonAtomic(file, value) {
+  const tmp = `${file}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  await promises.writeFile(tmp, JSON.stringify(value), "utf8");
+  await promises.rename(tmp, file);
+}
+var FsCheckpointSaver = class extends langgraphCheckpoint.BaseCheckpointSaver {
+  constructor(root, serde) {
+    super(serde);
+    this.locks = /* @__PURE__ */ new Map();
+    this.root = root;
+  }
+  threadDir(thread) {
+    return path2__default.default.join(this.root, thread);
+  }
+  nsPath(thread, ns) {
+    return path2__default.default.join(this.threadDir(thread), nsDir(ns));
+  }
+  ckptFile(thread, ns, id) {
+    return path2__default.default.join(this.nsPath(thread, ns), `${id}.ckpt.json`);
+  }
+  writesFile(thread, ns, id) {
+    return path2__default.default.join(this.nsPath(thread, ns), `${id}.writes.json`);
+  }
+  async withLock(key, fn) {
+    const prev = this.locks.get(key) ?? Promise.resolve();
+    const next = prev.then(fn, fn);
+    this.locks.set(key, next);
+    try {
+      return await next;
+    } finally {
+      if (this.locks.get(key) === next) this.locks.delete(key);
+    }
+  }
+  async listCheckpointIds(thread, ns) {
+    try {
+      const names = await promises.readdir(this.nsPath(thread, ns));
+      const suffix = ".ckpt.json";
+      return names.filter((n) => n.endsWith(suffix)).map((n) => n.slice(0, -suffix.length));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async listNamespaces(thread) {
+    try {
+      return await promises.readdir(this.threadDir(thread));
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  async listThreads() {
+    try {
+      return await promises.readdir(this.root);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  decodeNs(nsDirName) {
+    return nsDirName === ROOT_NS_SENTINEL ? "" : nsDirName;
+  }
+  async loadPendingWrites(thread, ns, ckptId) {
+    const data = await readJson(
+      this.writesFile(thread, ns, ckptId)
+    );
+    if (!data) return [];
+    const out = [];
+    for (const [taskId, channel, serialized] of Object.values(data)) {
+      const value = await this.serde.loadsTyped("json", decode(serialized));
+      out.push([taskId, channel, value]);
+    }
+    return out;
+  }
+  async migratePendingSends(checkpoint, thread, ns, parentCheckpointId) {
+    const data = await readJson(
+      this.writesFile(thread, ns, parentCheckpointId)
+    );
+    const pendingSends = data ? await Promise.all(
+      Object.values(data).filter(([, channel]) => channel === langgraphCheckpoint.TASKS).map(
+        ([, , serialized]) => this.serde.loadsTyped("json", decode(serialized))
+      )
+    ) : [];
+    const m = checkpoint;
+    m.channel_values ?? (m.channel_values = {});
+    m.channel_values[langgraphCheckpoint.TASKS] = pendingSends;
+    m.channel_versions ?? (m.channel_versions = {});
+    const versions = Object.values(m.channel_versions);
+    m.channel_versions[langgraphCheckpoint.TASKS] = versions.length > 0 ? langgraphCheckpoint.maxChannelVersion(...versions) : this.getNextVersion(void 0);
+  }
+  async readTuple(thread, ns, ckptId, config) {
+    const data = await readJson(this.ckptFile(thread, ns, ckptId));
+    if (!data) return void 0;
+    const checkpoint = await this.serde.loadsTyped(
+      "json",
+      decode(data.checkpoint)
+    );
+    const metadata = await this.serde.loadsTyped(
+      "json",
+      decode(data.metadata)
+    );
+    if (checkpoint.v < 4 && data.parentCheckpointId !== void 0) {
+      await this.migratePendingSends(
+        checkpoint,
+        thread,
+        ns,
+        data.parentCheckpointId
+      );
+    }
+    const pendingWrites = await this.loadPendingWrites(thread, ns, ckptId);
+    const tuple = {
+      config,
+      checkpoint,
+      metadata,
+      pendingWrites
+    };
+    if (data.parentCheckpointId !== void 0) {
+      tuple.parentConfig = {
+        configurable: {
+          thread_id: thread,
+          checkpoint_ns: ns,
+          checkpoint_id: data.parentCheckpointId
+        }
+      };
+    }
+    return tuple;
+  }
+  async getTuple(config) {
+    const thread = config.configurable?.thread_id;
+    if (!thread) return void 0;
+    const ns = config.configurable?.checkpoint_ns ?? "";
+    const explicitId = langgraphCheckpoint.getCheckpointId(config);
+    if (explicitId) {
+      return this.readTuple(thread, ns, explicitId, config);
+    }
+    const ids = (await this.listCheckpointIds(thread, ns)).sort(
+      (a, b) => b.localeCompare(a)
+    );
+    if (ids.length === 0) return void 0;
+    const ckptId = ids[0];
+    return this.readTuple(thread, ns, ckptId, {
+      configurable: {
+        thread_id: thread,
+        checkpoint_ns: ns,
+        checkpoint_id: ckptId
+      }
+    });
+  }
+  async *list(config, options) {
+    const filter = options?.filter;
+    const before = options?.before;
+    let limit = options?.limit;
+    const configThread = config.configurable?.thread_id;
+    const configNs = config.configurable?.checkpoint_ns;
+    const configCkptId = config.configurable?.checkpoint_id;
+    const threads = configThread ? [configThread] : await this.listThreads();
+    for (const thread of threads) {
+      const nsNames = await this.listNamespaces(thread);
+      for (const nsName of nsNames) {
+        const ns = this.decodeNs(nsName);
+        if (configNs !== void 0 && ns !== configNs) continue;
+        const ids = (await this.listCheckpointIds(thread, ns)).sort(
+          (a, b) => b.localeCompare(a)
+        );
+        for (const ckptId of ids) {
+          if (configCkptId && ckptId !== configCkptId) continue;
+          if (before?.configurable?.checkpoint_id && ckptId >= before.configurable.checkpoint_id)
+            continue;
+          const tuple = await this.readTuple(thread, ns, ckptId, {
+            configurable: {
+              thread_id: thread,
+              checkpoint_ns: ns,
+              checkpoint_id: ckptId
+            }
+          });
+          if (!tuple) continue;
+          if (filter) {
+            const md = tuple.metadata;
+            const matches = Object.entries(filter).every(
+              ([k, v]) => md?.[k] === v
+            );
+            if (!matches) continue;
+          }
+          if (limit !== void 0) {
+            if (limit <= 0) return;
+            limit -= 1;
+          }
+          yield tuple;
+        }
+      }
+    }
+  }
+  async put(config, checkpoint, metadata) {
+    const thread = config.configurable?.thread_id;
+    if (!thread) {
+      throw new Error(
+        'FsCheckpointSaver: missing "thread_id" in configurable. Pass `{ configurable: { thread_id } }` when streaming.'
+      );
+    }
+    const ns = config.configurable?.checkpoint_ns ?? "";
+    const parentCheckpointId = config.configurable?.checkpoint_id;
+    const prepared = langgraphCheckpoint.copyCheckpoint(checkpoint);
+    const [[, serializedCheckpoint], [, serializedMetadata]] = await Promise.all([
+      this.serde.dumpsTyped(prepared),
+      this.serde.dumpsTyped(metadata)
+    ]);
+    await promises.mkdir(this.nsPath(thread, ns), { recursive: true });
+    const file = this.ckptFile(thread, ns, checkpoint.id);
+    const body = {
+      checkpoint: encode(serializedCheckpoint),
+      metadata: encode(serializedMetadata),
+      parentCheckpointId
+    };
+    await writeJsonAtomic(file, body);
+    return {
+      configurable: {
+        thread_id: thread,
+        checkpoint_ns: ns,
+        checkpoint_id: checkpoint.id
+      }
+    };
+  }
+  async putWrites(config, writes, taskId) {
+    const thread = config.configurable?.thread_id;
+    if (!thread) {
+      throw new Error(
+        'FsCheckpointSaver: missing "thread_id" in configurable for putWrites.'
+      );
+    }
+    const ns = config.configurable?.checkpoint_ns ?? "";
+    const ckptId = config.configurable?.checkpoint_id;
+    if (!ckptId) {
+      throw new Error(
+        'FsCheckpointSaver: missing "checkpoint_id" in configurable for putWrites.'
+      );
+    }
+    const key = `${thread}|${ns}|${ckptId}`;
+    await this.withLock(key, async () => {
+      const existing = await readJson(this.writesFile(thread, ns, ckptId)) ?? {};
+      let mutated = false;
+      for (let idx = 0; idx < writes.length; idx++) {
+        const [channel, value] = writes[idx];
+        const writeIdx = langgraphCheckpoint.WRITES_IDX_MAP[channel] ?? idx;
+        const innerKey = `${taskId},${writeIdx}`;
+        if (writeIdx >= 0 && innerKey in existing) continue;
+        const [, serialized] = await this.serde.dumpsTyped(value);
+        existing[innerKey] = [taskId, channel, encode(serialized)];
+        mutated = true;
+      }
+      if (!mutated) return;
+      await promises.mkdir(this.nsPath(thread, ns), { recursive: true });
+      await writeJsonAtomic(this.writesFile(thread, ns, ckptId), existing);
+    });
+  }
+  async deleteThread(threadId) {
+    await promises.rm(this.threadDir(threadId), { recursive: true, force: true });
+  }
+};
+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);
@@ -1109,6 +1263,14 @@ function parseVerdict(raw) {
     confidence: typeof r.confidence === "number" ? r.confidence : void 0
   };
 }
+async function fileExists(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readJsonOrNull(file) {
   try {
     return JSON.parse(await promises.readFile(file, "utf8"));
@@ -1139,7 +1301,7 @@ async function readJudgmentDirs(root) {
     const verdictFile = path2__default.default.join(dir, "verdict.json");
     let verdict = null;
     let verdictInvalid = false;
-    if (fs.existsSync(verdictFile)) {
+    if (await fileExists(verdictFile)) {
       const raw = await readJsonOrNull(verdictFile);
       verdict = raw ? parseVerdict(raw) : null;
       if (raw && !verdict) verdictInvalid = true;
@@ -1152,7 +1314,7 @@ 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) {
+function fromDiskResult(cwd, dir, entry) {
   const req = dir.request;
   const finalVerdict = dir.verdict?.verdict ?? req?.heuristicVerdict;
   const status = req ? dir.verdict ? "fail" : req.status : "fail";
@@ -1171,7 +1333,7 @@ function buildResult(cwd, dir, entry) {
     message
   };
 }
-function passResult(entry, cwd) {
+async function passResultFromDisk(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 {
@@ -1179,37 +1341,27 @@ function passResult(entry, cwd) {
     url: entry.url,
     status: "pass",
     baselinePath: baselineAbs,
-    actualPath: fs.existsSync(actualAbs) ? actualAbs : void 0
+    actualPath: await fileExists(actualAbs) ? actualAbs : void 0
   };
 }
-async function applyJudgments(cwd = process.cwd()) {
-  const p = paths(cwd);
+async function reconstructFromDisk(cwd, dirs) {
   const manifest = await loadManifest(cwd);
   if (!manifest) {
     throw new Error(
-      `no manifest at ${p.manifest}. Run \`blazediff-agent init\` first.`
+      `no manifest at ${paths(cwd).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 nonPassResults = dirs.map(
+    (d) => fromDiskResult(
+      cwd,
+      d,
+      manifest.entries.find((e) => e.id === d.id)
+    )
+  );
+  const passResults = await Promise.all(
+    manifest.entries.filter((entry) => !dirById.has(entry.id)).map((entry) => passResultFromDisk(entry, cwd))
+  );
   const results = [...passResults, ...nonPassResults];
   const passed = results.filter((r) => r.status === "pass").length;
   const pendingJudgments = results.filter(
@@ -1224,6 +1376,57 @@ async function applyJudgments(cwd = process.cwd()) {
     results
   };
   await writeSummaryMarkdown(report, cwd);
+  return report;
+}
+async function hasCheckpoint(cwd, threadId) {
+  const dir = path2__default.default.join(paths(cwd).checkpoints, threadId);
+  try {
+    const names = await promises.readdir(dir);
+    return names.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function applyJudgments(opts = process.cwd()) {
+  const options = typeof opts === "string" ? { cwd: opts } : opts;
+  const cwd = options.cwd ?? process.cwd();
+  const manifest = await loadManifest(cwd);
+  if (!manifest) {
+    throw new Error(
+      `no manifest at ${paths(cwd).manifest}. Run \`blazediff-agent init\` first.`
+    );
+  }
+  const dirs = await readJudgmentDirs(paths(cwd).judgments);
+  const applied = [];
+  const missing = [];
+  const invalid = [];
+  const verdicts = {};
+  for (const d of dirs) {
+    if (d.verdictInvalid) {
+      invalid.push(path2__default.default.join(paths(cwd).judgments, d.id));
+      continue;
+    }
+    if (d.verdict) {
+      verdicts[d.id] = d.verdict.verdict;
+      applied.push(d.id);
+      continue;
+    }
+    missing.push(d.id);
+  }
+  const threadId = threadIdFor(cwd);
+  const checkpointExists = await hasCheckpoint(cwd, threadId);
+  if (!checkpointExists) {
+    const report2 = await reconstructFromDisk(cwd, dirs);
+    return { report: report2, applied, missing, invalid };
+  }
+  const report = await resumeGraph({
+    cwd,
+    verdicts,
+    threadId,
+    onEvent: options.onEvent,
+    junitPath: options.junitPath
+  });
+  await new FsCheckpointSaver(paths(cwd).checkpoints).deleteThread(threadId).catch(() => void 0);
   return { report, applied, missing, invalid };
 }
 var HOST_INSTRUCTIONS = [
@@ -1245,6 +1448,14 @@ function signatureOf(r) {
   const severity = r.severity ?? "?";
   return `${r.status}|diff:${pct}|regions:${regions}|severity:${severity}`;
 }
+async function fileExists2(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readJsonOrNull2(file) {
   try {
     return JSON.parse(await promises.readFile(file, "utf8"));
@@ -1298,9 +1509,13 @@ function autoVerdict(result) {
 async function discoverTiles(dir) {
   const locatorAbs = path2__default.default.join(dir, "locator.png");
   const tilesAbs = path2__default.default.join(dir, "regions.png");
+  const [locator, tiles] = await Promise.all([
+    fileExists2(locatorAbs),
+    fileExists2(tilesAbs)
+  ]);
   return {
-    locatorPath: fs.existsSync(locatorAbs) ? "locator.png" : void 0,
-    tilesPath: fs.existsSync(tilesAbs) ? "regions.png" : void 0
+    locatorPath: locator ? "locator.png" : void 0,
+    tilesPath: tiles ? "regions.png" : void 0
   };
 }
 async function writeJudgments(opts) {
@@ -1309,53 +1524,61 @@ async function writeJudgments(opts) {
   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 Promise.all(
+    opts.report.results.map(async (result) => {
+      const dir = path2__default.default.join(root, result.id);
+      if (result.status === "pass") {
+        if (await fileExists2(dir))
+          await promises.rm(dir, { recursive: true, force: true });
+        return;
+      }
+      const entry = entryById(opts.manifest, result.id);
+      if (!entry) return;
+      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 verdictFile = path2__default.default.join(dir, "verdict.json");
+      const [prior, priorVerdict] = await Promise.all([
+        readJsonOrNull2(requestFile),
+        fileExists2(verdictFile).then(
+          (exists) => exists ? readJsonOrNull2(verdictFile) : null
+        )
+      ]);
+      const signatureMatches = prior !== null && prior.signature === request.signature;
       await promises.writeFile(
-        verdictFile,
-        `${JSON.stringify(auto, null, 2)}
+        requestFile,
+        `${JSON.stringify(request, null, 2)}
 `,
         "utf8"
       );
-    } else if (priorVerdict && !signatureMatches) {
-      await promises.rm(verdictFile, { force: true });
-    }
-  }
+      if (priorVerdict && signatureMatches) {
+        return;
+      }
+      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 });
-  }
+  await Promise.all(
+    entries.filter((name) => !knownIds.has(name)).map(
+      (name) => promises.rm(path2__default.default.join(root, name), { recursive: true, force: true })
+    )
+  );
 }
 
 // src/judge/index.ts
@@ -1393,7 +1616,7 @@ ${cases.join("\n")}
   return destPath;
 }
 
-// src/check.ts
+// src/graph/nodes/results.ts
 function narrowRegion(r) {
   return {
     bbox: r.bbox,
@@ -1403,29 +1626,6 @@ function narrowRegion(r) {
     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 };
 }
@@ -1437,6 +1637,15 @@ function staleResult(entry) {
     message: "captureHash mismatch: entry was edited without re-capturing"
   };
 }
+function passResult(entry, baselinePath, actualPath) {
+  return {
+    id: entry.id,
+    url: entry.url,
+    status: "pass",
+    baselinePath,
+    actualPath
+  };
+}
 function missingBaselineResult(entry, baselinePath) {
   return {
     id: entry.id,
@@ -1461,1594 +1670,1755 @@ function failResult(entry, outcome, actualPath, baselinePath, verdict) {
     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}`
+
+// src/graph/nodes/capture.ts
+function makeCaptureNode(semaphore) {
+  return async function captureNode(state) {
+    const entry = state.entry;
+    const options = state.options;
+    if (!entry || !options) {
+      throw new Error("captureNode: entry or options missing");
+    }
+    if (entry.auth === "required") {
+      return {
+        captureOutput: {
+          id: entry.id,
+          skipResult: skipResult(
+            entry,
+            "skipped: auth required (deferred to v0.2)"
+          )
+        }
+      };
+    }
+    if (isEntryStale(entry)) {
+      return {
+        captureOutput: { id: entry.id, skipResult: staleResult(entry) }
+      };
+    }
+    const baselinePath = path2__default.default.join(options.baselinesDir, `${entry.id}.png`);
+    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
+      )
+    );
+    return {
+      captureOutput: {
+        id: entry.id,
+        captureOutputPath: capture.outputPath,
+        baselinePath
+      }
+    };
   };
 }
-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);
+async function fileExists3(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
   }
-  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.`
-    );
+async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.cwd()) {
+  const [hasBaseline, hasActual] = await Promise.all([
+    fileExists3(baselinePath),
+    fileExists3(actualPath)
+  ]);
+  if (!hasBaseline || !hasActual) {
+    return {
+      id,
+      baselinePath,
+      actualPath,
+      match: false,
+      reason: "file-not-exists"
+    };
   }
-  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();
+  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 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);
+  const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
+  const antialiasing = opts.antialiasing ?? true;
+  const result = await coreNative.compare(baselinePath, actualPath, diffPath, {
+    threshold,
+    antialiasing,
+    interpret: true
+  });
+  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"
+    };
   }
-  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)
+    id,
+    baselinePath,
+    actualPath,
+    diffPath,
+    match: false,
+    reason: "pixel-diff",
+    diffCount: result.diffCount,
+    diffPercentage: result.diffPercentage,
+    interpretation: result.interpretation
   };
 }
-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}`);
+
+// src/graph/nodes/diff.ts
+function makeDiffNode(semaphore) {
+  return async function diffNode(state) {
+    const entry = state.entry;
+    const options = state.options;
+    const capture = state.captureOutput;
+    if (!entry || !options || !capture) {
+      throw new Error("diffNode: entry, options, or capture missing");
     }
-    if (r.status === "needs-judgment" && r.message) {
-      lines.push(`      ${r.message}`);
+    if (capture.skipResult) {
+      return {
+        diffOutput: { id: capture.id, skipResult: capture.skipResult }
+      };
     }
-    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;
+    if (!capture.captureOutputPath || !capture.baselinePath) {
+      throw new Error("diffNode: capture output paths missing");
     }
-    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"}`
+    const outcome = await semaphore.run(
+      () => diffEntry(
+        entry.id,
+        capture.baselinePath,
+        capture.captureOutputPath,
+        { threshold: options.threshold, emitDiffPng: options.emitDiffPng },
+        options.cwd
+      )
     );
-    if (!outcome.match) process.exitCode = 1;
-  });
+    if (outcome.reason === "file-not-exists") {
+      return {
+        diffOutput: {
+          id: entry.id,
+          skipResult: missingBaselineResult(entry, capture.baselinePath)
+        }
+      };
+    }
+    return {
+      diffOutput: {
+        id: entry.id,
+        outcome,
+        baselinePath: capture.baselinePath,
+        captureOutputPath: capture.captureOutputPath
+      }
+    };
+  };
 }
 
-// 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 {
+// 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 out;
+  return best;
 }
-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;
+function topPosition(regions) {
+  let best;
+  for (const r of regions)
+    if (!best || r.pixelCount > best.pixelCount) best = r;
+  return best?.position;
 }
-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 meanConfidence(regions) {
+  if (regions.length === 0) return 0;
+  return regions.reduce((a, r) => a + (r.confidence ?? 0), 0) / regions.length;
 }
-function isPublicRoute(route) {
-  if (DYNAMIC_SEGMENT.test(route)) return false;
-  if (route === "/api" || route.startsWith("/api/")) return false;
-  return true;
+function formatBreakdown(counts) {
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([type, n]) => `${n} ${type}`).join(", ");
 }
-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);
+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 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);
+  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 out;
+  return `${regions.length} regions: ${formatBreakdown(counts)}${pos ? ` @ ${pos}` : ""} (${pct}, ${sev})`;
 }
-
-// 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 {
-    }
+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"
+    };
   }
-  return [];
+  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"
+  };
 }
-
-// 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 interruptForJudgment(payload) {
+  const resume = langgraph.interrupt(payload);
+  if (!resume || typeof resume !== "object") return void 0;
+  return resume[payload.entryId];
 }
-function mergeBy(routes, into) {
-  for (const r of routes) {
-    const key = normalizePath(r.url);
-    if (!into.has(key)) into.set(key, { ...r, url: key });
+
+// src/graph/nodes/judge.ts
+async function judgeNode(state) {
+  const entry = state.entry;
+  const options = state.options;
+  const diff = state.diffOutput;
+  if (!entry || !options || !diff) {
+    throw new Error("judgeNode: entry, options, or diff missing");
   }
-}
-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
-      );
+  if (diff.skipResult) {
+    return { results: [diff.skipResult] };
+  }
+  const outcome = diff.outcome;
+  const baselinePath = diff.baselinePath;
+  const captureOutputPath = diff.captureOutputPath;
+  if (!outcome || !baselinePath || !captureOutputPath) {
+    throw new Error("judgeNode: diff outputs missing");
+  }
+  if (outcome.match) {
+    return { results: [passResult(entry, baselinePath, captureOutputPath)] };
+  }
+  const verdict = deriveVerdict({
+    reason: outcome.reason,
+    interpretation: outcome.interpretation,
+    diffCount: outcome.diffCount,
+    diffPercentage: outcome.diffPercentage
+  });
+  let result = failResult(
+    entry,
+    outcome,
+    captureOutputPath,
+    baselinePath,
+    verdict
+  );
+  if (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 ?? verdict
+      },
+      options.cwd
+    );
+    if (output.kind === "judged") {
+      result = { ...result, verdict: output.verdict };
+    } else {
+      const pending = {
+        ...result,
+        status: "needs-judgment",
+        message: `awaiting judgment in ${output.requestPath}`
+      };
+      const resumed = interruptForJudgment({
+        kind: "host-judgment-required",
+        entryId: entry.id,
+        url: entry.url,
+        requestPath: output.requestPath,
+        signature: signatureOf(result),
+        pendingResult: pending
+      });
+      result = resumed ? { ...result, verdict: resumed } : pending;
     }
   }
-  return Array.from(merged.values()).sort((a, b) => a.url.localeCompare(b.url));
+  return { results: [result] };
 }
 
-// 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/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.`
     );
-  });
-}
-
-// 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"));
+  return { entries: manifest.entries, manifest };
 }
-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 resultsChannel = langgraph.Annotation({
+  reducer: (acc, next) => [...acc, ...next],
+  default: () => []
+});
+var BranchState = langgraph.Annotation.Root({
+  entry: langgraph.Annotation({
+    reducer: (_, next) => next,
+    default: () => void 0
+  }),
+  options: langgraph.Annotation({
+    reducer: (acc, next) => next ?? acc,
+    default: () => void 0
+  }),
+  captureOutput: langgraph.Annotation({
+    reducer: (_, next) => next,
+    default: () => void 0
+  }),
+  diffOutput: langgraph.Annotation({
+    reducer: (_, next) => next,
+    default: () => void 0
+  }),
+  results: resultsChannel
+});
+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: () => []
+  }),
+  results: resultsChannel,
+  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 cpuParallelism() {
+  const cores = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+  if (!cores || !Number.isFinite(cores)) return 2;
+  return Math.max(2, cores);
 }
-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 threadIdFor(cwd) {
+  return crypto$1.createHash("sha1").update(paths(cwd).manifest).digest("hex").slice(0, 16);
 }
-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 buildBranchGraph(captureSemaphore, diffSemaphore) {
+  return new langgraph.StateGraph(BranchState).addNode("capture", makeCaptureNode(captureSemaphore)).addNode("diff", makeDiffNode(diffSemaphore)).addNode("judge", judgeNode).addEdge(langgraph.START, "capture").addEdge("capture", "diff").addEdge("diff", "judge").addEdge("judge", langgraph.END).compile();
 }
-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)
-      });
+function buildGraph(captureSemaphore, diffSemaphore, checkpointer) {
+  const branch = buildBranchGraph(captureSemaphore, diffSemaphore);
+  return new langgraph.StateGraph(GraphState).addNode("load", loadNode).addNode("branch", branch).addEdge(langgraph.START, "load").addConditionalEdges(
+    "load",
+    (state) => state.entries.map(
+      (entry) => new langgraph.Send("branch", { entry, options: state.options })
+    ),
+    ["branch"]
+  ).addEdge("branch", langgraph.END).compile({ checkpointer });
+}
+async function streamGraph(graph, input, threadId, onEvent) {
+  const collect = { results: [], interrupts: [] };
+  const stream = await graph.stream(input, {
+    streamMode: "updates",
+    configurable: { thread_id: threadId }
+  });
+  for await (const chunk of stream) {
+    if (!chunk || typeof chunk !== "object") continue;
+    for (const [node, partial] of Object.entries(
+      chunk
+    )) {
+      if (node === "__interrupt__") {
+        const arr = partial;
+        if (!arr) continue;
+        for (const i of arr) {
+          const v = i?.value;
+          if (!v || v.kind !== "host-judgment-required") continue;
+          collect.interrupts.push(v);
+          onEvent?.({ type: "interrupt", interrupt: v });
+        }
+        continue;
+      }
+      const part = partial;
+      if (!part) continue;
+      if (part.results) {
+        for (const r of part.results) {
+          collect.results.push(r);
+          onEvent?.({ type: "result", result: r });
+        }
+      }
+      if (part.manifest) collect.manifest = part.manifest;
+      if (part.report) {
+        collect.report = part.report;
+        onEvent?.({ type: "report", report: part.report });
+      }
     }
   }
-  return out;
+  return collect;
 }
-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
+async function buildPartialReport(collect, cwd) {
+  const manifest = collect.manifest ?? await loadManifest(cwd);
+  const synthesized = collect.interrupts.map((i) => ({
+    ...i.pendingResult,
+    status: "needs-judgment",
+    message: i.pendingResult.message ?? `awaiting judgment in ${i.requestPath}`
+  }));
+  const results = [...collect.results, ...synthesized];
+  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
   };
+  if (manifest) {
+    await writeJudgments({ report, manifest, cwd });
+  }
+  await writeSummaryMarkdown(report, cwd);
+  await ensureGitignore(cwd);
+  return report;
 }
-
-// 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"
-      );
+async function runGraph(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const concurrency = opts.concurrency ?? defaultConcurrency();
+  const captureSemaphore = new Semaphore(concurrency);
+  const diffSemaphore = new Semaphore(cpuParallelism());
+  const baselinesDir = paths(cwd).baselines;
+  const checkpointer = new FsCheckpointSaver(paths(cwd).checkpoints);
+  const graph = buildGraph(captureSemaphore, diffSemaphore, checkpointer);
+  const threadId = opts.threadId ?? threadIdFor(cwd);
+  if (!opts.resume) {
+    await checkpointer.deleteThread(threadId);
+  }
+  const input = opts.resume ? new langgraph.Command({ resume: opts.resume }) : {
+    options: {
+      baseUrl: opts.baseUrl ?? "",
+      cwd,
+      threshold: opts.threshold,
+      concurrency,
+      emitDiffPng: opts.emitDiffPng ?? true,
+      judge: opts.judge ?? "none",
+      baselinesDir
     }
-    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}`
-    };
+  };
+  let collect;
+  try {
+    collect = await streamGraph(graph, input, threadId, opts.onEvent);
+  } finally {
+    await closeBrowser();
   }
-  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>."
-    );
+  const report = collect.report ?? await buildPartialReport(collect, 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);
   }
-  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;
+  if (collect.interrupts.length === 0) {
+    await checkpointer.deleteThread(threadId).catch(() => void 0);
   }
-  const port = opts.port ? Number(opts.port) : chosen.port;
+  return report;
+}
+async function resumeGraph(opts) {
+  return runGraph({
+    cwd: opts.cwd,
+    threadId: opts.threadId,
+    resume: opts.verdicts,
+    onEvent: opts.onEvent,
+    junitPath: opts.junitPath
+  });
+}
+
+// src/cli/check-output.ts
+function slimResult(r) {
   return {
-    devServer: {
-      command: chosen.command,
-      port,
-      readyTimeoutMs: DEFAULT_READY_TIMEOUT_MS
-    },
-    framework: detectFramework(pkg),
-    packageManager: pkg.packageManager,
-    baseUrl: `http://127.0.0.1:${port}`
+    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 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;
+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}`);
     }
-    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
-    );
+    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)`);
+}
 
-// 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
+// src/cli/commands/check.ts
+function glyphFor(status) {
+  switch (status) {
+    case "pass":
+      return "\u2713";
+    case "needs-judgment":
+      return "?";
+    case "stale-baseline":
+    case "missing-baseline":
+      return "!";
+    default:
+      return "\u2717";
+  }
+}
+function makeProgressReporter(out) {
+  if (out.isJson() || out.isQuiet()) return void 0;
+  let done = 0;
+  let total = 0;
+  const counter = () => total > 0 ? `[${done}/${total}]` : `[${done}]`;
+  return (event) => {
+    if (event.type === "report") {
+      total = event.report.totalEntries;
+      return;
+    }
+    if (event.type === "result") {
+      done += 1;
+      const r = event.result;
+      const detail = r.status === "fail" && typeof r.diffPercentage === "number" ? `  (${r.diffPercentage.toFixed(3)}%)` : r.status !== "pass" && r.message ? `  (${r.message})` : "";
+      process.stderr.write(
+        `${counter()} ${glyphFor(r.status)} ${r.id}${detail}
+`
+      );
+      return;
+    }
+    if (event.type === "interrupt") {
+      done += 1;
+      process.stderr.write(
+        `${counter()} ? ${event.interrupt.entryId}  (awaiting judgment)
+`
+      );
+    }
+  };
+}
+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 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"
+  ).option(
+    "--apply-judgments",
+    "resume the suspended graph using .blazediff/judgments/<id>/verdict.json files"
+  ).action(async (opts) => {
+    if (opts.applyJudgments) {
+      const { report: report2, applied, missing, invalid } = await applyJudgments({
+        onEvent: makeProgressReporter(out),
+        junitPath: opts.junit
+      });
+      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 runGraph({
+      baseUrl,
+      threshold: parseThreshold(opts.threshold),
+      concurrency: opts.concurrency ? parsePositiveInteger(opts.concurrency, "--concurrency") : void 0,
+      emitDiffPng: opts.diffPng,
+      junitPath: opts.junit,
+      judge: parseJudge(opts.judge),
+      onEvent: makeProgressReporter(out)
     });
-    await saveManifest(addOrReplaceEntry(manifest, entry));
-    out.emit(
-      { ok: true, entry },
-      out.isTTY() ? `manifest: added ${id} (${entry.url})` : "."
-    );
+    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;
   });
-  cmd.command("remove <id>").action(async (id) => {
+}
+
+// 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");
-    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;
-    }
+    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(
-      { entries: manifest.entries },
-      manifest.entries.map((e) => `${e.id.padEnd(30)} ${e.url}`).join("\n") || "no entries"
+      outcome,
+      outcome.match ? `${id}: match` : `${id}: ${outcome.reason ?? "diff"}`
     );
+    if (!outcome.match) process.exitCode = 1;
   });
 }
-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];
+
+// src/discover/crawl.ts
+function extractInternalLinks(base, target, hrefs) {
   const out = [];
-  for (const t of tokens) {
-    if (!(t in HARNESSES)) {
-      throw new Error(
-        `unknown harness "${t}". valid: ${[...ALL_HARNESSES, "all"].join(", ")}`
-      );
+  for (const href of hrefs) {
+    if (!href || href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      continue;
     }
-    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;
+    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 {
     }
   }
-  throw new Error(
-    `could not locate bundled SKILL.md (looked in: ${candidates.join(", ")}). reinstall @blazediff/agent.`
-  );
+  return out;
 }
-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;
+var CRAWL_VIEWPORT = { width: 1024, height: 768 };
+var CRAWL_WORKERS = 4;
+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 }];
+  const discovered = [];
+  const handle = await acquireStableContext(CRAWL_VIEWPORT);
+  const fetchOne = async () => {
+    while (queue.length && discovered.length < maxRoutes) {
+      const item = queue.shift();
+      if (!item) return;
+      if (discovered.length >= maxRoutes) return;
+      discovered.push({ url: item.url, source: "crawl" });
+      if (item.depth >= maxDepth) continue;
+      const page = await handle.context.newPage();
+      try {
+        const target = new URL(item.url, base).toString();
+        await page.goto(target, {
+          waitUntil: "domcontentloaded",
+          timeout: 15e3
+        });
+        const hrefs = await page.evaluate(
+          () => Array.from(
+            document.querySelectorAll("a[href]")
+          ).map((a) => a.getAttribute("href") ?? "")
+        );
+        for (const p of extractInternalLinks(base, target, hrefs)) {
+          if (visited.has(p)) continue;
+          visited.add(p);
+          queue.push({ url: p, depth: item.depth + 1 });
+        }
+      } catch {
+      } finally {
+        await page.close().catch(() => {
+        });
       }
     }
-    if (end > 0)
-      return lines.slice(end + 1).join("\n").trimStart();
+  };
+  try {
+    await Promise.all(Array.from({ length: CRAWL_WORKERS }, () => fetchOne()));
+  } finally {
+    await releaseStableContext(handle);
   }
-  return content;
+  return discovered.slice(0, maxRoutes);
 }
-
-// src/onboard/install.ts
-function ensureTrailingNewline(s) {
-  return s.endsWith("\n") ? s : `${s}
-`;
+var DYNAMIC_SEGMENT = /\[[^\]]+\]/;
+async function readJson2(file) {
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(await promises.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
 }
-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}
-`;
+function isPublicRoute(route) {
+  if (DYNAMIC_SEGMENT.test(route)) return false;
+  if (route === "/api" || route.startsWith("/api/")) return false;
+  return true;
 }
-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";
+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 readJson2(
+    path2__default.default.join(nextDir, "routes-manifest.json")
+  );
+  for (const r of routes?.staticRoutes ?? []) {
+    if (isPublicRoute(r.page)) add(r.page);
   }
-  if (exists) {
-    const current = fs.readFileSync(target, "utf8");
-    if (current === content) return "unchanged";
-    if (!force) return "skipped-exists";
+  const appPaths = await readJson2(
+    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);
   }
-  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";
+  return out;
 }
-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);
+
+// 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 { harness, path: target, status: combineStatuses(statuses) };
+  return [];
 }
 
-// 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}`;
+// 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;
 }
-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"`
+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 [ALL_HARNESSES[idx - 1]];
-  } finally {
-    rl.close();
   }
+  return Array.from(merged.values()).sort((a, b) => a.url.localeCompare(b.url));
 }
-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}`;
+
+// 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"
+    );
   });
-  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)
-    );
-  });
+
+// 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";
 }
-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 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"));
 }
-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));
+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);
   }
-  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;
+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 null;
+  return DEFAULT_PORT;
 }
-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(() => {
+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 {
-      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" })
+  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
   );
-  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;
-  }
+  if (!candidates.length) return null;
+  const chosen = candidates[0];
   return {
-    pid: child.pid,
-    port: opts.port,
-    url: `http://127.0.0.1:${opts.port}`
+    packageManager,
+    devScript: chosen.name,
+    devCommand: chosen.command,
+    port: chosen.port,
+    candidates,
+    devDependencies,
+    dependencies,
+    allDependencies
   };
 }
-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";
+
+// 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 (!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" };
+  if (opts.devCommand) {
+    const port2 = opts.port ? parsePort(opts.port) : DEFAULT_PORT;
+    return {
+      devServer: {
+        command: opts.devCommand,
+        port: port2,
+        readyTimeoutMs: DEFAULT_READY_TIMEOUT_MS
+      },
+      baseUrl: `http://127.0.0.1:${port2}`
+    };
   }
-  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;
+  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>."
+    );
   }
-}
-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;
+  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>.`
+      );
     }
-    if (ch === " " && !inQuote) {
-      if (current) {
-        out.push(current);
-        current = "";
-      }
-      continue;
+    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}`
+      );
     }
-    current += ch;
+    chosen = match;
   }
-  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", () => {
-      });
-    }
+  const port = opts.port ? parsePort(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}`
   };
-  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)) {
+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, removed: false, root },
-        `nothing to reset (no ${root})`
+        {
+          ok: true,
+          created: false,
+          config: existing,
+          configHash: configHash(existing)
+        },
+        `config exists at ${paths().config} (use --force to overwrite)`
       );
       return;
     }
-    if (out.isTTY() && !opts.yes && !out.isJson()) {
-      throw new Error(
-        `refusing to wipe ${root} without --yes (interactive run)`
-      );
+    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;
     }
-    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}`
+      { entries: manifest.entries },
+      manifest.entries.map((e) => `${e.id.padEnd(30)} ${e.url}`).join("\n") || "no entries"
     );
   });
 }
-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)) {
+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(
-        `no judgments at ${judgmentsDir}. Run \`blazediff-agent check\` first.`
+        `unknown harness "${t}". valid: ${[...ALL_HARNESSES, "all"].join(", ")}`
       );
     }
-    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);
+    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;
     }
-    return failed;
   }
-  const targets = new Set(ids);
-  const missing = ids.filter(
-    (id) => !manifest.entries.some((e) => e.id === id)
+  throw new Error(
+    `could not locate bundled SKILL.md (looked in: ${candidates.join(", ")}). reinstall @blazediff/agent.`
   );
-  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;
+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;
+      }
     }
-    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;
-  });
+    if (end > 0)
+      return lines.slice(end + 1).join("\n").trimStart();
+  }
+  return content;
 }
 
-// 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/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) => `
 
-// src/graph/nodes/load.ts
-async function loadNode(state) {
-  if (!state.options) {
-    throw new Error("loadNode: graph options missing");
+---
+
+<!-- ${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";
   }
-  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.`
-    );
+  if (exists) {
+    const current = fs.readFileSync(target, "utf8");
+    if (current === content) return "unchanged";
+    if (!force) return "skipped-exists";
   }
-  return { entries: manifest.entries, manifest };
-}
-function narrowRegion2(r) {
-  return {
-    bbox: r.bbox,
-    pixelCount: r.pixelCount,
-    percentage: r.percentage,
-    changeType: r.changeType,
-    confidence: r.confidence
-  };
+  await promises.mkdir(path2.dirname(target), { recursive: true });
+  await promises.writeFile(target, content, "utf8");
+  return exists ? "updated" : "created";
 }
-function skipResult2(entry, message) {
-  return { id: entry.id, url: entry.url, status: "pass", message };
+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";
 }
-function staleResult2(entry) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "stale-baseline",
-    message: "captureHash mismatch: entry was edited without re-capturing"
-  };
+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) };
 }
-function passResult3(entry, baselinePath, actualPath) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "pass",
-    baselinePath,
-    actualPath
-  };
+
+// 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}`;
 }
-function missingBaselineResult2(entry, baselinePath) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "missing-baseline",
-    message: `baseline missing at ${baselinePath}`
-  };
+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 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 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 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)")
-        ]
-      };
+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."
+        );
+      }
     }
-    if (isEntryStale(entry)) {
-      return { results: [staleResult2(entry)] };
+    const results = [];
+    for (const t of targets) {
+      results.push(await installHarness(t, cwd, { force: opts.force }));
     }
-    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
+    out.emit(
+      {
+        ok: true,
+        detected: detectHarnesses(cwd),
+        installed: results
+      },
+      humanizeResults(results)
     );
-    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
+  });
+}
+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);
     });
-    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] };
-  };
+    socket.once("error", () => resolve(false));
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
 }
-
-// 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 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));
   }
-  async run(fn) {
-    if (this.current >= this.limit) {
-      await new Promise((resolve) => this.queue.push(resolve));
+  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;
     }
-    this.current++;
-    try {
-      return await fn();
-    } finally {
-      this.current--;
-      const next = this.queue.shift();
-      if (next) next();
+    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 child = child_process.spawn(opts.command, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    shell: 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";
     }
   }
-};
-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();
+  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 };
 }
-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;
+function processExists(pid) {
   try {
-    finalState = await graph.invoke({
-      options: {
-        baseUrl: opts.baseUrl,
-        cwd,
-        threshold: opts.threshold,
-        concurrency,
-        emitDiffPng: opts.emitDiffPng ?? true,
-        judge: opts.judge ?? "none",
-        baselinesDir
+    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();
     });
-  } 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
+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);
 }
-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)
-  };
+
+// 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 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}`
+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})`
       );
-      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}`);
+      return;
     }
-    if (r.status === "needs-judgment" && r.message) {
-      lines.push(`      ${r.message}`);
+    if (out.isTTY() && !opts.yes && !out.isJson()) {
+      throw new Error(
+        `refusing to wipe ${root} without --yes (interactive run)`
+      );
     }
-    if (r.diffPath) lines.push(`      diff: ${r.diffPath}`);
-    return lines;
+    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}`
+    );
   });
 }
-function parseJudge2(input) {
-  if (input === "host" || input === "none") return input;
-  throw new Error(`unknown --judge backend: ${input} (expected: host | none)`);
+async function cleanupAfterRewrite(rewrittenIds, scopeAll) {
+  const p = paths();
+  if (scopeAll) {
+    await Promise.all([
+      promises.rm(p.actual, { recursive: true, force: true }),
+      promises.rm(p.judgments, { recursive: true, force: true }),
+      promises.rm(p.checkpoints, { recursive: true, force: true }),
+      promises.rm(p.summary, { force: true })
+    ]);
+    return;
+  }
+  const perId = rewrittenIds.flatMap((id) => [
+    promises.rm(path2__default.default.join(p.actual, `${id}.png`), { force: true }),
+    promises.rm(path2__default.default.join(p.actual, `${id}.diff.png`), { force: true }),
+    promises.rm(path2__default.default.join(p.judgments, id), { recursive: true, force: true })
+  ]);
+  await Promise.all([
+    ...perId,
+    promises.rm(p.summary, { force: true }),
+    promises.rm(p.checkpoints, { recursive: true, force: true })
+  ]);
 }
-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."
-    );
+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;
   }
-  throw new Error(`unknown --mode: ${input} (expected: actual)`);
+  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 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);
+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 report = await runGraph({
+    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,
-      threshold: Number(opts.threshold),
-      concurrency: opts.concurrency ? Number(opts.concurrency) : void 0,
-      emitDiffPng: opts.diffPng,
-      junitPath: opts.junit,
-      judge: parseJudge2(opts.judge)
+      routes,
+      mode: "baseline",
+      writeManifest: true
     });
-    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);
+    const succeededIds = report.results.filter((r) => r.ok).map((r) => r.id);
+    if (succeededIds.length > 0) {
+      await cleanupAfterRewrite(succeededIds, Boolean(opts.all));
+    }
+    const failureLines2 = 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):`,
+      ...failureLines2
+    ].join("\n");
+    out.emit(report, human);
     if (report.failed > 0) process.exitCode = 1;
   });
 }
@@ -3072,7 +3442,7 @@ function registerServeStatus(program, out) {
       );
       return;
     }
-    const port = opts.port ? Number(opts.port) : config.devServer.port;
+    const port = opts.port ? parsePort(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}`;
@@ -3167,7 +3537,6 @@ function buildProgram() {
   registerDiff(program, out);
   registerManifest(program, out);
   registerCheck(program, out);
-  registerRun(program, out);
   registerRewrite(program, out);
   registerReset(program, out);
   return program;