@blazediff/agent 0.0.1 → 0.1.0

package/dist/index.js

@@ -9,8 +9,9 @@ var fs = require('fs');
 var module$1 = require('module');
 var crypto$1 = require('crypto');
 var coreNative = require('@blazediff/core-native');
-var sharp = require('sharp');
 var langgraph = require('@langchain/langgraph');
+var sharp = require('sharp');
+var langgraphCheckpoint = require('@langchain/langgraph-checkpoint');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -43,6 +44,7 @@ var paths = (cwd = process.cwd()) => {
     baselines: path__default.default.join(root, "baselines"),
     actual: path__default.default.join(root, "actual"),
     judgments: path__default.default.join(root, "judgments"),
+    checkpoints: path__default.default.join(root, "checkpoints"),
     summary: path__default.default.join(root, "summary.md"),
     gitignore: path__default.default.join(root, ".gitignore"),
     serverLog: path__default.default.join(root, "dev-server.log"),
@@ -73,6 +75,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;
@@ -89,15 +92,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",
@@ -142,12 +152,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) {
@@ -197,7 +234,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 });
@@ -219,8 +257,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);
   }
 }
 function resolvePlaywrightCli() {
@@ -291,6 +330,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;
 
@@ -410,55 +473,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();
@@ -472,42 +542,20 @@ async function runCaptures(opts) {
     results
   };
 }
-var ENTRIES = [
-  "actual/",
-  "judgments/",
-  "summary.md",
-  "dev-server.log",
-  "dev-server.pid",
-  "*.tmp"
-];
-var STALE_ENTRIES = /* @__PURE__ */ new Set(["diffs/", "pending-judgments/", "report.json"]);
-var HEADER = "# blazediff: generated artifacts (committed: config.json, manifest.json, baselines/)\n";
-async function ensureGitignore(cwd) {
-  const file = paths(cwd).gitignore;
-  await promises.mkdir(path__default.default.dirname(file), { recursive: true });
-  const existing = fs.existsSync(file) ? await promises.readFile(file, "utf8") : "";
-  const lines = existing.split("\n").map((l) => l.trim());
-  const hasStale = lines.some((l) => STALE_ENTRIES.has(l));
-  const missing = ENTRIES.filter((e) => !lines.includes(e));
-  if (!missing.length && !hasStale && existing) return;
-  if (hasStale) {
-    const kept = lines.filter(
-      (l) => !STALE_ENTRIES.has(l) && !ENTRIES.includes(l) && l !== ""
-    );
-    const body2 = `${kept.length ? `${kept.join("\n")}
-` : HEADER}${ENTRIES.join("\n")}
-`;
-    await promises.writeFile(file, body2, "utf8");
-    return;
+async function fileExists(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
   }
-  const body = existing ? `${existing.replace(/\n+$/, "")}
-${missing.join("\n")}
-` : `${HEADER}${ENTRIES.join("\n")}
-`;
-  await promises.writeFile(file, body, "utf8");
 }
 async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.cwd()) {
-  if (!fs.existsSync(baselinePath) || !fs.existsSync(actualPath)) {
+  const [hasBaseline, hasActual] = await Promise.all([
+    fileExists(baselinePath),
+    fileExists(actualPath)
+  ]);
+  if (!hasBaseline || !hasActual) {
     return {
       id,
       baselinePath,
@@ -526,7 +574,8 @@ async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.
   const antialiasing = opts.antialiasing ?? true;
   const result = await coreNative.compare(baselinePath, actualPath, diffPath, {
     threshold,
-    antialiasing
+    antialiasing,
+    interpret: true
   });
   if (result.match) return { id, baselinePath, actualPath, match: true };
   if (result.reason === "file-not-exists") {
@@ -548,10 +597,6 @@ async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.
       reason: "layout-diff"
     };
   }
-  const interpretation = await coreNative.interpret(baselinePath, actualPath, {
-    threshold,
-    antialiasing
-  }).catch(() => void 0);
   return {
     id,
     baselinePath,
@@ -561,167 +606,200 @@ async function diffEntry(id, baselinePath, actualPath, opts = {}, cwd = process.
     reason: "pixel-diff",
     diffCount: result.diffCount,
     diffPercentage: result.diffPercentage,
-    interpretation
+    interpretation: result.interpretation
   };
 }
 
-// src/diff/verdict.ts
-var REGRESSIVE_TYPES = /* @__PURE__ */ new Set(["content-change", "addition", "deletion"]);
-var INTENTIONAL_TYPES = /* @__PURE__ */ new Set(["color-change", "shift"]);
-var NOISE_TYPES = /* @__PURE__ */ new Set(["rendering-noise"]);
-var ELEVATED_SEVERITY = /* @__PURE__ */ new Set(["medium", "high"]);
-var SUB_PERCEPTUAL_PCT = 0.01;
-function pctText(pct) {
-  if (typeof pct !== "number") return "?%";
-  return pct >= 0.01 ? `${pct.toFixed(2)}%` : `${pct.toFixed(3)}%`;
-}
-function countByType(regions) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const r of regions)
-    counts.set(r.changeType, (counts.get(r.changeType) ?? 0) + 1);
-  return counts;
-}
-function dominantType(counts) {
-  let best = "";
-  let bestN = 0;
-  for (const [type, n] of counts) {
-    if (n > bestN) {
-      best = type;
-      bestN = n;
+// 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 path18 = u.pathname + u.search;
+      if (path18.startsWith("/api/")) continue;
+      out.push(path18);
+    } catch {
     }
   }
-  return best;
+  return out;
 }
-function topPosition(regions) {
-  let best;
-  for (const r of regions)
-    if (!best || r.pixelCount > best.pixelCount) best = r;
-  return best?.position;
+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(() => {
+        });
+      }
+    }
+  };
+  try {
+    await Promise.all(Array.from({ length: CRAWL_WORKERS }, () => fetchOne()));
+  } finally {
+    await releaseStableContext(handle);
+  }
+  return discovered.slice(0, maxRoutes);
 }
-function meanConfidence(regions) {
-  if (regions.length === 0) return 0;
-  return regions.reduce((a, r) => a + (r.confidence ?? 0), 0) / regions.length;
+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 formatBreakdown(counts) {
-  return [...counts].sort((a, b) => b[1] - a[1]).map(([type, n]) => `${n} ${type}`).join(", ");
+function isPublicRoute(route) {
+  if (DYNAMIC_SEGMENT.test(route)) return false;
+  if (route === "/api" || route.startsWith("/api/")) return false;
+  return true;
 }
-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`;
+async function discoverFromNextManifest(cwd = process.cwd()) {
+  const nextDir = path__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(
+    path__default.default.join(nextDir, "routes-manifest.json")
+  );
+  for (const r of routes?.staticRoutes ?? []) {
+    if (isPublicRoute(r.page)) add(r.page);
   }
-  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})`;
+  const appPaths = await readJson(
+    path__default.default.join(nextDir, "server", "app-paths-manifest.json")
+  );
+  for (const route of Object.keys(appPaths ?? {})) {
+    const normalized = route.replace(/\/page$/, "") || "/";
+    if (isPublicRoute(normalized)) add(normalized);
   }
-  return `${regions.length} regions: ${formatBreakdown(counts)}${pos ? ` @ ${pos}` : ""} (${pct}, ${sev})`;
+  return out;
 }
-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"
-    };
+
+// 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 {
+    }
   }
-  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"
-    };
+  return [];
+}
+
+// src/discover/index.ts
+function normalizePath(url) {
+  const [pathPart, query = ""] = url.split("?", 2);
+  const trimmed = pathPart.replace(/\/+$/, "");
+  const normalizedPath = trimmed === "" ? "/" : trimmed;
+  return query ? `${normalizedPath}?${query}` : normalizedPath;
+}
+function mergeBy(routes, into) {
+  for (const r of routes) {
+    const key = normalizePath(r.url);
+    if (!into.has(key)) into.set(key, { ...r, url: key });
   }
-  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"
-    };
+}
+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 (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 Array.from(merged.values()).sort((a, b) => a.url.localeCompare(b.url));
+}
+var ENTRIES = [
+  "actual/",
+  "judgments/",
+  "checkpoints/",
+  "summary.md",
+  "dev-server.log",
+  "dev-server.pid",
+  "*.tmp"
+];
+var STALE_ENTRIES = /* @__PURE__ */ new Set(["diffs/", "pending-judgments/", "report.json"]);
+var HEADER = "# blazediff: generated artifacts (committed: config.json, manifest.json, baselines/)\n";
+async function ensureGitignore(cwd) {
+  const file = paths(cwd).gitignore;
+  await promises.mkdir(path__default.default.dirname(file), { recursive: true });
+  const existing = fs.existsSync(file) ? await promises.readFile(file, "utf8") : "";
+  const lines = existing.split("\n").map((l) => l.trim());
+  const hasStale = lines.some((l) => STALE_ENTRIES.has(l));
+  const missing = ENTRIES.filter((e) => !lines.includes(e));
+  if (!missing.length && !hasStale && existing) return;
+  if (hasStale) {
+    const kept = lines.filter(
+      (l) => !STALE_ENTRIES.has(l) && !ENTRIES.includes(l) && l !== ""
+    );
+    const body2 = `${kept.length ? `${kept.join("\n")}
+` : HEADER}${ENTRIES.join("\n")}
+`;
+    await promises.writeFile(file, body2, "utf8");
+    return;
   }
-  return {
-    label: "ambiguous",
-    headline,
-    rationale: [
-      `mix of change types (${formatBreakdown(counts)}) at "${severity ?? "?"}" severity`,
-      `${pctText(pct)} of image differs`
-    ],
-    action: "investigate"
-  };
+  const body = existing ? `${existing.replace(/\n+$/, "")}
+${missing.join("\n")}
+` : `${HEADER}${ENTRIES.join("\n")}
+`;
+  await promises.writeFile(file, body, "utf8");
 }
 var DEFAULT_TOP_N = 5;
 var DEFAULT_PADDING = 16;
@@ -863,6 +941,283 @@ var noneJudge = {
     return { kind: "judged", verdict: input.heuristicVerdict };
   }
 };
+var ROOT_NS_SENTINEL = "_root";
+function nsDir(ns) {
+  return ns === "" ? ROOT_NS_SENTINEL : ns;
+}
+function encode(buf) {
+  return Buffer.from(buf).toString("base64");
+}
+function decode(s) {
+  return Buffer.from(s, "base64");
+}
+async function readJson2(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 path__default.default.join(this.root, thread);
+  }
+  nsPath(thread, ns) {
+    return path__default.default.join(this.threadDir(thread), nsDir(ns));
+  }
+  ckptFile(thread, ns, id) {
+    return path__default.default.join(this.nsPath(thread, ns), `${id}.ckpt.json`);
+  }
+  writesFile(thread, ns, id) {
+    return path__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 readJson2(
+      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 readJson2(
+      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 readJson2(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 readJson2(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, " ");
@@ -975,6 +1330,14 @@ function parseVerdict(raw) {
     confidence: typeof r.confidence === "number" ? r.confidence : void 0
   };
 }
+async function fileExists2(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readJsonOrNull(file) {
   try {
     return JSON.parse(await promises.readFile(file, "utf8"));
@@ -1005,7 +1368,7 @@ async function readJudgmentDirs(root) {
     const verdictFile = path__default.default.join(dir, "verdict.json");
     let verdict = null;
     let verdictInvalid = false;
-    if (fs.existsSync(verdictFile)) {
+    if (await fileExists2(verdictFile)) {
       const raw = await readJsonOrNull(verdictFile);
       verdict = raw ? parseVerdict(raw) : null;
       if (raw && !verdict) verdictInvalid = true;
@@ -1018,7 +1381,7 @@ function toAbs(cwd, rel) {
   if (!rel) return void 0;
   return path__default.default.isAbsolute(rel) ? rel : path__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";
@@ -1037,7 +1400,7 @@ function buildResult(cwd, dir, entry) {
     message
   };
 }
-function passResult(entry, cwd) {
+async function passResultFromDisk(entry, cwd) {
   const baselineAbs = path__default.default.join(paths(cwd).baselines, `${entry.id}.png`);
   const actualAbs = path__default.default.join(paths(cwd).actual, `${entry.id}.png`);
   return {
@@ -1045,37 +1408,27 @@ function passResult(entry, cwd) {
     url: entry.url,
     status: "pass",
     baselinePath: baselineAbs,
-    actualPath: fs.existsSync(actualAbs) ? actualAbs : void 0
+    actualPath: await fileExists2(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(path__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(
@@ -1090,6 +1443,57 @@ async function applyJudgments(cwd = process.cwd()) {
     results
   };
   await writeSummaryMarkdown(report, cwd);
+  return report;
+}
+async function hasCheckpoint(cwd, threadId) {
+  const dir = path__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(path__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 = [
@@ -1111,6 +1515,14 @@ function signatureOf(r) {
   const severity = r.severity ?? "?";
   return `${r.status}|diff:${pct}|regions:${regions}|severity:${severity}`;
 }
+async function fileExists3(p) {
+  try {
+    await promises.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readJsonOrNull2(file) {
   try {
     return JSON.parse(await promises.readFile(file, "utf8"));
@@ -1164,9 +1576,13 @@ function autoVerdict(result) {
 async function discoverTiles(dir) {
   const locatorAbs = path__default.default.join(dir, "locator.png");
   const tilesAbs = path__default.default.join(dir, "regions.png");
+  const [locator, tiles] = await Promise.all([
+    fileExists3(locatorAbs),
+    fileExists3(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) {
@@ -1175,53 +1591,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 = path__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 = path__default.default.join(dir, "request.json");
-    const prior = await readJsonOrNull2(requestFile);
-    const verdictFile = path__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 = path__default.default.join(root, result.id);
+      if (result.status === "pass") {
+        if (await fileExists3(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 = path__default.default.join(dir, "request.json");
+      const verdictFile = path__default.default.join(dir, "verdict.json");
+      const [prior, priorVerdict] = await Promise.all([
+        readJsonOrNull2(requestFile),
+        fileExists3(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(path__default.default.join(root, name), { recursive: true, force: true });
-  }
+  await Promise.all(
+    entries.filter((name) => !knownIds.has(name)).map(
+      (name) => promises.rm(path__default.default.join(root, name), { recursive: true, force: true })
+    )
+  );
 }
 
 // src/judge/index.ts
@@ -1259,7 +1683,7 @@ ${cases.join("\n")}
   return destPath;
 }
 
-// src/check.ts
+// src/graph/nodes/results.ts
 function narrowRegion(r) {
   return {
     bbox: r.bbox,
@@ -1269,38 +1693,24 @@ 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 skipResult(entry, message) {
+  return { id: entry.id, url: entry.url, status: "pass", message };
 }
-function passResult2(entry, baselinePath, actualPath) {
+function staleResult(entry) {
   return {
     id: entry.id,
     url: entry.url,
-    status: "pass",
-    baselinePath,
-    actualPath
+    status: "stale-baseline",
+    message: "captureHash mismatch: entry was edited without re-capturing"
   };
 }
-function skipResult(entry, message) {
-  return { id: entry.id, url: entry.url, status: "pass", message };
-}
-function staleResult(entry) {
+function passResult(entry, baselinePath, actualPath) {
   return {
     id: entry.id,
     url: entry.url,
-    status: "stale-baseline",
-    message: "captureHash mismatch: entry was edited without re-capturing"
+    status: "pass",
+    baselinePath,
+    actualPath
   };
 }
 function missingBaselineResult(entry, baselinePath) {
@@ -1327,300 +1737,334 @@ 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}`
-  };
-}
-async function checkEntry(entry, opts, cwd, baselinesDir, judge) {
-  if (entry.auth === "required") {
-    return skipResult(entry, "skipped: auth required (deferred to v0.2)");
-  }
-  if (isEntryStale(entry)) {
-    return staleResult(entry);
-  }
-  const baselinePath = path__default.default.join(baselinesDir, `${entry.id}.png`);
-  const capture = await captureScreenshot(
-    opts.baseUrl,
-    {
-      id: entry.id,
-      url: entry.url,
-      viewport: entry.viewport,
-      mask: entry.mask,
-      waitFor: entry.waitFor,
-      fullPage: entry.fullPage ?? DEFAULT_FULL_PAGE,
-      mode: "actual"
-    },
-    cwd
-  );
-  const outcome = await diffEntry(
-    entry.id,
-    baselinePath,
-    capture.outputPath,
-    { threshold: opts.threshold, emitDiffPng: opts.emitDiffPng ?? true },
-    cwd
-  );
-  if (outcome.match) return passResult2(entry, baselinePath, capture.outputPath);
-  if (outcome.reason === "file-not-exists")
-    return missingBaselineResult(entry, baselinePath);
-  const verdict = deriveVerdict({
-    reason: outcome.reason,
-    interpretation: outcome.interpretation,
-    diffCount: outcome.diffCount,
-    diffPercentage: outcome.diffPercentage
-  });
-  const failed = failResult(
-    entry,
-    outcome,
-    capture.outputPath,
-    baselinePath,
-    verdict
-  );
-  return judgeAmbiguous(failed, entry, judge, cwd);
-}
-async function runCheck(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  const manifest = await loadManifest(cwd);
-  if (!manifest) {
-    throw new Error(
-      `no manifest found at ${paths(cwd).manifest}. Run \`blazediff init\` then \`/blazediff\` (or capture manually) first.`
-    );
-  }
-  const baselinesDir = paths(cwd).baselines;
-  const concurrency = opts.concurrency ?? defaultConcurrency();
-  const judge = resolveJudge(opts.judge ?? "none");
-  let results;
-  try {
-    results = await pool(
-      manifest.entries,
-      concurrency,
-      (entry) => checkEntry(entry, opts, cwd, baselinesDir, judge)
+
+// 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 = path__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
+      )
     );
-  } finally {
-    await closeBrowser();
-  }
-  const passed = results.filter((r) => r.status === "pass").length;
-  const pendingJudgments = results.filter(
-    (r) => r.status === "needs-judgment"
-  ).length;
-  const report = {
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    totalEntries: results.length,
-    passed,
-    failed: results.length - passed - pendingJudgments,
-    pendingJudgments,
-    results
+    return {
+      captureOutput: {
+        id: entry.id,
+        captureOutputPath: capture.outputPath,
+        baselinePath
+      }
+    };
   };
-  await writeJudgments({ report, manifest, cwd });
-  await writeSummaryMarkdown(report, cwd);
-  await ensureGitignore(cwd);
-  if (opts.junitPath) {
-    const target = path__default.default.isAbsolute(opts.junitPath) ? opts.junitPath : path__default.default.join(cwd, opts.junitPath);
-    await writeJunit(report, target);
-  }
-  return report;
 }
 
-// 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;
+// 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");
     }
-    try {
-      const u = new URL(href, target);
-      if (u.origin !== base.origin) continue;
-      const path18 = u.pathname + u.search;
-      if (path18.startsWith("/api/")) continue;
-      out.push(path18);
-    } catch {
+    if (capture.skipResult) {
+      return {
+        diffOutput: { id: capture.id, skipResult: capture.skipResult }
+      };
     }
-  }
-  return out;
-}
-async function crawlRoutes(opts) {
-  const maxRoutes = opts.maxRoutes ?? 50;
-  const maxDepth = opts.maxDepth ?? 2;
-  const base = new URL(opts.baseUrl);
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [{ url: "/", depth: 0 }];
-  visited.add("/");
-  const discovered = [];
-  const browser = await getBrowser();
-  const context = await browser.newContext({
-    viewport: { width: 1024, height: 768 },
-    deviceScaleFactor: 1
-  });
-  try {
-    while (queue.length && discovered.length < maxRoutes) {
-      const { url, depth } = queue.shift();
-      const page = await context.newPage();
-      try {
-        const target = new URL(url, base).toString();
-        await page.goto(target, {
-          waitUntil: "domcontentloaded",
-          timeout: 15e3
-        });
-        discovered.push({ url, source: "crawl" });
-        if (depth >= maxDepth) continue;
-        const hrefs = await page.evaluate(
-          () => Array.from(
-            document.querySelectorAll("a[href]")
-          ).map((a) => a.getAttribute("href") ?? "")
-        );
-        for (const path18 of extractInternalLinks(base, target, hrefs)) {
-          if (visited.has(path18)) continue;
-          visited.add(path18);
-          queue.push({ url: path18, depth: depth + 1 });
+    if (!capture.captureOutputPath || !capture.baselinePath) {
+      throw new Error("diffNode: capture output paths missing");
+    }
+    const outcome = await semaphore.run(
+      () => diffEntry(
+        entry.id,
+        capture.baselinePath,
+        capture.captureOutputPath,
+        { threshold: options.threshold, emitDiffPng: options.emitDiffPng },
+        options.cwd
+      )
+    );
+    if (outcome.reason === "file-not-exists") {
+      return {
+        diffOutput: {
+          id: entry.id,
+          skipResult: missingBaselineResult(entry, capture.baselinePath)
         }
-      } catch {
-      } finally {
-        await page.close().catch(() => {
-        });
+      };
+    }
+    return {
+      diffOutput: {
+        id: entry.id,
+        outcome,
+        baselinePath: capture.baselinePath,
+        captureOutputPath: capture.captureOutputPath
       }
+    };
+  };
+}
+
+// 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;
     }
-  } finally {
-    await context.close().catch(() => {
-    });
   }
-  return discovered;
+  return best;
 }
-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 topPosition(regions) {
+  let best;
+  for (const r of regions)
+    if (!best || r.pixelCount > best.pixelCount) best = r;
+  return best?.position;
 }
-function isPublicRoute(route) {
-  if (DYNAMIC_SEGMENT.test(route)) return false;
-  if (route === "/api" || route.startsWith("/api/")) return false;
-  return true;
+function meanConfidence(regions) {
+  if (regions.length === 0) return 0;
+  return regions.reduce((a, r) => a + (r.confidence ?? 0), 0) / regions.length;
 }
-async function discoverFromNextManifest(cwd = process.cwd()) {
-  const nextDir = path__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(
-    path__default.default.join(nextDir, "routes-manifest.json")
-  );
-  for (const r of routes?.staticRoutes ?? []) {
-    if (isPublicRoute(r.page)) add(r.page);
+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 appPaths = await readJson(
-    path__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"
+    };
+  }
+  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"
+    };
   }
-  return [];
-}
-
-// src/discover/index.ts
-function normalizePath(url) {
-  const [pathPart, query = ""] = url.split("?", 2);
-  const trimmed = pathPart.replace(/\/+$/, "");
-  const normalizedPath = trimmed === "" ? "/" : trimmed;
-  return query ? `${normalizedPath}?${query}` : normalizedPath;
-}
-function mergeBy(routes, into) {
-  for (const r of routes) {
-    const key = normalizePath(r.url);
-    if (!into.has(key)) into.set(key, { ...r, url: key });
+  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"
+  };
 }
-async function discover(opts) {
-  const cwd = opts.cwd ?? process.cwd();
-  const merged = /* @__PURE__ */ new Map();
-  mergeBy(await discoverFromNextManifest(cwd), merged);
-  mergeBy(await discoverFromSitemap(opts.baseUrl), merged);
-  if (!opts.skipCrawl) {
-    const crawlMax = Math.max(0, (opts.maxRoutes ?? 50) - merged.size);
-    if (crawlMax > 0) {
-      mergeBy(
-        await crawlRoutes({ baseUrl: opts.baseUrl, maxRoutes: crawlMax }),
-        merged
-      );
-    }
-  }
-  return Array.from(merged.values()).sort((a, b) => a.url.localeCompare(b.url));
+function interruptForJudgment(payload) {
+  const resume = langgraph.interrupt(payload);
+  if (!resume || typeof resume !== "object") return void 0;
+  return resume[payload.entryId];
 }
 
-// src/graph/nodes/aggregate.ts
-async function aggregateNode(state) {
+// src/graph/nodes/judge.ts
+async function judgeNode(state) {
+  const entry = state.entry;
   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 };
+  const diff = state.diffOutput;
+  if (!entry || !options || !diff) {
+    throw new Error("judgeNode: entry, options, or diff missing");
+  }
+  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 { results: [result] };
 }
 
 // src/graph/nodes/load.ts
@@ -1636,187 +2080,39 @@ async function loadNode(state) {
   }
   return { entries: manifest.entries, manifest };
 }
-function narrowRegion2(r) {
-  return {
-    bbox: r.bbox,
-    pixelCount: r.pixelCount,
-    percentage: r.percentage,
-    changeType: r.changeType,
-    confidence: r.confidence
-  };
-}
-function skipResult2(entry, message) {
-  return { id: entry.id, url: entry.url, status: "pass", message };
-}
-function staleResult2(entry) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "stale-baseline",
-    message: "captureHash mismatch: entry was edited without re-capturing"
-  };
-}
-function passResult3(entry, baselinePath, actualPath) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "pass",
-    baselinePath,
-    actualPath
-  };
-}
-function missingBaselineResult2(entry, baselinePath) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "missing-baseline",
-    message: `baseline missing at ${baselinePath}`
-  };
-}
-function failResult2(entry, outcome, actualPath, baselinePath, verdict) {
-  return {
-    id: entry.id,
-    url: entry.url,
-    status: "fail",
-    diffCount: outcome.diffCount,
-    diffPercentage: outcome.diffPercentage,
-    severity: outcome.interpretation?.severity,
-    regions: outcome.interpretation?.regions?.map(narrowRegion2),
-    verdict,
-    diffPath: outcome.diffPath,
-    baselinePath,
-    actualPath,
-    message: outcome.reason === "layout-diff" ? "layout differs (dimensions changed)" : `${outcome.diffCount ?? 0} pixels differ (${(outcome.diffPercentage ?? 0).toFixed(3)}%)`
-  };
-}
-function makeProcessNode(semaphore) {
-  return async function processNode(state) {
-    const entry = state.entry;
-    const options = state.options;
-    if (!entry || !options) {
-      throw new Error("processNode: entry or options missing");
-    }
-    if (entry.auth === "required") {
-      return {
-        results: [
-          skipResult2(entry, "skipped: auth required (deferred to v0.2)")
-        ]
-      };
-    }
-    if (isEntryStale(entry)) {
-      return { results: [staleResult2(entry)] };
-    }
-    const capture = await semaphore.run(
-      () => captureScreenshot(
-        options.baseUrl,
-        {
-          id: entry.id,
-          url: entry.url,
-          viewport: entry.viewport,
-          mask: entry.mask,
-          waitFor: entry.waitFor,
-          fullPage: entry.fullPage ?? DEFAULT_FULL_PAGE,
-          mode: "actual"
-        },
-        options.cwd
-      )
-    );
-    const baselinePath = path__default.default.join(options.baselinesDir, `${entry.id}.png`);
-    const outcome = await diffEntry(
-      entry.id,
-      baselinePath,
-      capture.outputPath,
-      { threshold: options.threshold, emitDiffPng: options.emitDiffPng },
-      options.cwd
-    );
-    if (outcome.match) {
-      return { results: [passResult3(entry, baselinePath, capture.outputPath)] };
-    }
-    if (outcome.reason === "file-not-exists") {
-      return { results: [missingBaselineResult2(entry, baselinePath)] };
-    }
-    const verdict = deriveVerdict({
-      reason: outcome.reason,
-      interpretation: outcome.interpretation,
-      diffCount: outcome.diffCount,
-      diffPercentage: outcome.diffPercentage
-    });
-    let result = failResult2(
-      entry,
-      outcome,
-      capture.outputPath,
-      baselinePath,
-      verdict
-    );
-    if (result.verdict?.label === "ambiguous" && result.baselinePath && result.actualPath) {
-      const judge = resolveJudge(options.judge);
-      const output = await judge.judge(
-        {
-          entry,
-          baselinePath: result.baselinePath,
-          actualPath: result.actualPath,
-          diffPath: result.diffPath,
-          regions: result.regions,
-          diffPercentage: result.diffPercentage,
-          severity: result.severity,
-          heuristicVerdict: result.verdict
-        },
-        options.cwd
-      );
-      if (output.kind === "judged") {
-        result = { ...result, verdict: output.verdict };
-      } else {
-        result = {
-          ...result,
-          status: "needs-judgment",
-          message: `awaiting judgment in ${output.requestPath}`
-        };
-      }
-    }
-    return { results: [result] };
-  };
-}
-
-// src/graph/semaphore.ts
-var Semaphore = class {
-  constructor(limit) {
-    this.limit = limit;
-    this.current = 0;
-    this.queue = [];
-    if (limit < 1)
-      throw new Error(`semaphore limit must be >= 1 (got ${limit})`);
-  }
-  async run(fn) {
-    if (this.current >= this.limit) {
-      await new Promise((resolve) => this.queue.push(resolve));
-    }
-    this.current++;
-    try {
-      return await fn();
-    } finally {
-      this.current--;
-      const next = this.queue.shift();
-      if (next) next();
-    }
-  }
-};
-var GraphState = langgraph.Annotation.Root({
+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
   }),
-  entries: langgraph.Annotation({
-    reducer: (acc, next) => next ?? acc,
-    default: () => []
+  captureOutput: langgraph.Annotation({
+    reducer: (_, next) => next,
+    default: () => void 0
   }),
-  entry: langgraph.Annotation({
+  diffOutput: langgraph.Annotation({
     reducer: (_, next) => next,
     default: () => void 0
   }),
-  results: langgraph.Annotation({
-    reducer: (acc, next) => [...acc, ...next],
+  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
@@ -1828,47 +2124,144 @@ var GraphState = langgraph.Annotation.Root({
 });
 
 // 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(
+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);
+}
+function threadIdFor(cwd) {
+  return crypto$1.createHash("sha1").update(paths(cwd).manifest).digest("hex").slice(0, 16);
+}
+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 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("process", { entry, options: state.options })
+      (entry) => new langgraph.Send("branch", { entry, options: state.options })
     ),
-    ["process"]
-  ).addEdge("process", "aggregate").addEdge("aggregate", langgraph.END).compile();
+    ["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 collect;
+}
+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;
 }
 async function runGraph(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const concurrency = opts.concurrency ?? defaultConcurrency();
-  const semaphore = new Semaphore(concurrency);
+  const captureSemaphore = new Semaphore(concurrency);
+  const diffSemaphore = new Semaphore(cpuParallelism());
   const baselinesDir = paths(cwd).baselines;
-  const graph = buildGraph(semaphore);
-  let finalState;
+  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
+    }
+  };
+  let collect;
   try {
-    finalState = await graph.invoke({
-      options: {
-        baseUrl: opts.baseUrl,
-        cwd,
-        threshold: opts.threshold,
-        concurrency,
-        emitDiffPng: opts.emitDiffPng ?? true,
-        judge: opts.judge ?? "none",
-        baselinesDir
-      }
-    });
+    collect = await streamGraph(graph, input, threadId, opts.onEvent);
   } finally {
     await closeBrowser();
   }
-  const report = finalState.report;
-  if (!report) {
-    throw new Error("runGraph: graph completed without producing a report");
-  }
+  const report = collect.report ?? await buildPartialReport(collect, cwd);
   if (opts.junitPath) {
     const target = path__default.default.isAbsolute(opts.junitPath) ? opts.junitPath : path__default.default.join(cwd, opts.junitPath);
     await writeJunit(report, target);
   }
+  if (collect.interrupts.length === 0) {
+    await checkpointer.deleteThread(threadId).catch(() => void 0);
+  }
   return report;
 }
+async function resumeGraph(opts) {
+  return runGraph({
+    cwd: opts.cwd,
+    threadId: opts.threadId,
+    resume: opts.verdicts,
+    onEvent: opts.onEvent,
+    junitPath: opts.junitPath
+  });
+}
+function runCheck(opts) {
+  return runGraph(opts);
+}
 
 exports.STABILITY_HOOKS_VERSION = STABILITY_HOOKS_VERSION;
 exports.applyJudgments = applyJudgments;
@@ -1882,8 +2275,10 @@ exports.loadManifest = loadManifest;
 exports.paths = paths;
 exports.resolveBaseUrl = resolveBaseUrl;
 exports.resolveJudge = resolveJudge;
+exports.resumeGraph = resumeGraph;
 exports.runCaptures = runCaptures;
 exports.runCheck = runCheck;
 exports.runGraph = runGraph;
 exports.saveConfig = saveConfig;
 exports.saveManifest = saveManifest;
+exports.threadIdFor = threadIdFor;