@bendyline/gezel 0.1.0

package/dist/checks/index.js

@@ -0,0 +1,1848 @@
+// src/checks/html.ts
+var MIN_INLINE_JS_BYTES = 2048;
+var SCRIPT_RE = /<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi;
+var SCRIPT_OPEN_RE = /<script\b[^>]*>/gi;
+var SCRIPT_CLOSE_RE = /<\/script\s*>/gi;
+function detectUnclosedScript(html) {
+  const opens = (html.match(SCRIPT_OPEN_RE) ?? []).length;
+  const closes = (html.match(SCRIPT_CLOSE_RE) ?? []).length;
+  return { opens, closes, unclosed: opens > closes };
+}
+function extractInlineScripts(html) {
+  const out = [];
+  for (const m of html.matchAll(SCRIPT_RE)) {
+    const attrs = m[1] ?? "";
+    const body = m[2] ?? "";
+    if (/\bsrc\s*=/.test(attrs)) continue;
+    const typeMatch = attrs.match(/\btype\s*=\s*["']([^"']+)["']/i);
+    if (typeMatch) {
+      const t = typeMatch[1].toLowerCase().trim();
+      if (t !== "text/javascript" && t !== "application/javascript" && t !== "module") {
+        continue;
+      }
+    }
+    out.push({ body, attrs });
+  }
+  return out;
+}
+function validateScriptSyntax(scripts) {
+  const perScript = [];
+  let totalBytes = 0;
+  let allParse = true;
+  let firstError;
+  for (const s of scripts) {
+    const bytes = s.body.length;
+    totalBytes += bytes;
+    if (bytes === 0) {
+      perScript.push({ bytes: 0, parses: true });
+      continue;
+    }
+    const isModule = /\btype\s*=\s*["']module["']/i.test(s.attrs);
+    if (isModule) {
+      perScript.push({ bytes, parses: true });
+      continue;
+    }
+    try {
+      new Function(s.body);
+      perScript.push({ bytes, parses: true });
+    } catch (err) {
+      let message = err instanceof Error ? err.message : String(err);
+      const tsism = detectTypeScriptOnlySyntax(s.body);
+      if (tsism) {
+        message = `${message} \u2014 the script uses TypeScript-only syntax (${tsism}) which browsers cannot parse; rewrite the inline <script> as plain JavaScript (no type annotations, no \`!\` assertions, no \`as\` casts)`;
+      }
+      perScript.push({ bytes, parses: false, error: message });
+      allParse = false;
+      if (firstError === void 0) firstError = message;
+    }
+  }
+  return {
+    totalBytes,
+    allParse,
+    perScript,
+    ...firstError !== void 0 ? { firstError } : {}
+  };
+}
+function detectTypeScriptOnlySyntax(body) {
+  const probes = [
+    [/\w[)\]]?!(?=\s*[,);.\]])/, "a postfix `!` non-null assertion"],
+    [/\)\s*as\s+[A-Z]\w*/, "an `as Type` cast"],
+    [/\b(?:private|public|readonly)\s+\w+\s*[:=]/, "a class property modifier"],
+    [/^\s*(?:export\s+)?(?:interface|enum)\s+\w+/m, "an `interface`/`enum` declaration"],
+    [/\(\s*\w+\s*:\s*(?:string|number|boolean|any|\w+\[\])\s*[,)]/, "a parameter type annotation"]
+  ];
+  for (const [re, label] of probes) {
+    const m = body.match(re);
+    if (m) return `${label}, e.g. \`${m[0].trim().slice(0, 40)}\``;
+  }
+  return null;
+}
+function inlineJsBytes(html) {
+  let total = 0;
+  for (const m of html.matchAll(SCRIPT_RE)) {
+    total += (m[2] ?? "").trim().length;
+  }
+  return total;
+}
+function htmlCompleteSniff(html) {
+  const lower = html.toLowerCase();
+  const opens = (lower.match(/<script\b/g) ?? []).length;
+  const closes = (lower.match(/<\/script>/g) ?? []).length;
+  const scriptsBalanced = opens === closes;
+  const closedDoc = lower.includes("</body>") || lower.includes("</html>");
+  return scriptsBalanced && closedDoc;
+}
+function htmlGameSniff(html, minJsBytes = 400) {
+  const lower = html.toLowerCase();
+  const hasRenderTarget = /<canvas\b/.test(lower) || /<svg\b/.test(lower);
+  const hasFrameLoop = /requestanimationframe\s*\(/.test(lower) || /set(?:interval|timeout)\s*\(/.test(lower) || /\bfunction\s+(?:tick|update|loop|gameloop|gametick|step|render|frame)\b/.test(lower);
+  const hasSurface = hasRenderTarget || hasFrameLoop;
+  const opens = (lower.match(/<script\b/g) ?? []).length;
+  const closes = (lower.match(/<\/script>/g) ?? []).length;
+  const scriptClosed = opens > 0 && opens === closes;
+  const jsSubstantial = inlineJsBytes(html) >= minJsBytes;
+  return hasSurface && scriptClosed && jsSubstantial;
+}
+
+// src/checks/files.ts
+async function fileMinBytes(ws, file, bytes, trim = false) {
+  const content = await ws.read(file);
+  const n = (trim ? content?.trim() : content)?.length ?? 0;
+  return n >= bytes ? { ok: true, detail: `${file} is ${n} bytes` } : { ok: false, detail: `${file} is ${n} bytes, need \u2265 ${bytes}` };
+}
+async function fileMinLines(ws, file, minLines) {
+  const content = await ws.read(file);
+  const lines = (content ?? "").split("\n").filter((l) => l.trim().length > 0).length;
+  return lines >= minLines ? { ok: true, detail: `${file} has ${lines} non-blank lines` } : { ok: false, detail: `${file} has ${lines} non-blank line(s), need \u2265 ${minLines}` };
+}
+async function totalMinBytes(ws, files, bytes) {
+  let total = 0;
+  for (const f of files) total += (await ws.read(f))?.length ?? 0;
+  return total >= bytes ? { ok: true, detail: `${files.join(" + ")} total ${total} bytes` } : { ok: false, detail: `${files.join(" + ")} total ${total} bytes, need \u2265 ${bytes}` };
+}
+function isValidRasterAsset(bytes) {
+  if (bytes.length < 12) return false;
+  const containsAscii = (token) => {
+    const wanted = [...token].map((char) => char.charCodeAt(0));
+    outer: for (let i = 0; i <= bytes.length - wanted.length; i++) {
+      for (let j = 0; j < wanted.length; j++) {
+        if (bytes[i + j] !== wanted[j]) continue outer;
+      }
+      return true;
+    }
+    return false;
+  };
+  const ascii = (from, to) => String.fromCharCode(...bytes.slice(from, to));
+  const pngSignature = [137, 80, 78, 71, 13, 10, 26, 10].every(
+    (value, index) => bytes[index] === value
+  );
+  const png = pngSignature && ascii(12, 16) === "IHDR" && containsAscii("IDAT") && containsAscii("IEND");
+  const jpeg = bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 && bytes[bytes.length - 2] === 255 && bytes[bytes.length - 1] === 217;
+  const gif = (ascii(0, 6) === "GIF87a" || ascii(0, 6) === "GIF89a") && bytes.includes(44) && bytes[bytes.length - 1] === 59;
+  const webp = ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP" && ["VP8 ", "VP8L", "VP8X"].includes(ascii(12, 16));
+  return bytes.length >= 1024 && (png || jpeg || gif || webp);
+}
+var RASTER_EXTS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "gif", "webp"]);
+async function fileCountByExt(ws, ext, min, dir, opts) {
+  const all = await ws.list();
+  const exts = new Set(ext.map((e) => e.toLowerCase().replace(/^\./, "")));
+  const dirPrefix = dir ? `${dir.toLowerCase().replace(/\/+$/, "")}/` : null;
+  let matched = all.filter((p) => {
+    const lower = p.toLowerCase();
+    if (dirPrefix && !lower.startsWith(dirPrefix)) return false;
+    return exts.has(lower.split(".").pop() ?? "");
+  });
+  let unverifiable = false;
+  if (opts?.verifyImageBytes) {
+    const readBytes = ws.readBytes?.bind(ws);
+    if (!readBytes) {
+      unverifiable = true;
+    } else {
+      const verdicts = await Promise.all(
+        matched.map(async (p) => {
+          const fileExt = p.toLowerCase().split(".").pop() ?? "";
+          if (!RASTER_EXTS.has(fileExt)) return true;
+          const bytes = await readBytes(p).catch(() => null);
+          return bytes !== null && isValidRasterAsset(bytes);
+        })
+      );
+      matched = matched.filter((_, i) => verdicts[i]);
+    }
+  }
+  if (unverifiable) {
+    return {
+      ok: false,
+      detail: `cannot verify image bytes for ${ext.join("/")} files \u2014 this workspace view serves no binary reads, so the count would only prove filenames exist`,
+      matched
+    };
+  }
+  const where = dir ? ` in ${dir.replace(/\/+$/, "")}/` : "";
+  const verified = opts?.verifyImageBytes ? " real (byte-verified)" : "";
+  const stubNote = opts?.verifyImageBytes ? " A file with an image name but placeholder/text bytes does not count \u2014 generate the actual image." : "";
+  return matched.length >= min ? {
+    ok: true,
+    detail: `found ${matched.length}${verified} ${ext.join("/")} file(s)${where}`,
+    matched
+  } : {
+    ok: false,
+    detail: `found ${matched.length}${verified} ${ext.join("/")} file(s)${where}, need \u2265 ${min} \u2014 create the missing ${ext[0] ?? ""} file(s)${where ? ` under ${dir.replace(/\/+$/, "")}/` : ""}.${stubNote}`,
+    matched
+  };
+}
+async function cssMinBytes(ws, bytes, file = "index.html") {
+  const html = await ws.read(file) ?? "";
+  let css = 0;
+  for (const m of html.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/gi)) {
+    css += (m[1] ?? "").trim().length;
+  }
+  for (const m of html.matchAll(/\bstyle\s*=\s*(?:"([^"]*)"|'([^']*)')/gi)) {
+    css += (m[1] ?? m[2] ?? "").trim().length;
+  }
+  for (const m of html.matchAll(
+    /<link\b[^>]*rel=["']?stylesheet["']?[^>]*href=["']([^"']+)["']/gi
+  )) {
+    const href = m[1];
+    if (href && !/^https?:/i.test(href)) {
+      css += (await ws.read(href.replace(/^\.?\//, "")))?.length ?? 0;
+    }
+  }
+  return css >= bytes ? { ok: true, detail: `CSS is ${css} bytes (inline + linked in ${file})` } : { ok: false, detail: `CSS is ${css} bytes (inline + linked in ${file}), need \u2265 ${bytes}` };
+}
+async function containsPattern(ws, file, pattern, flags, label) {
+  const content = await ws.read(file);
+  if (content === null) return { ok: false, detail: `${file} not found` };
+  let re;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch {
+    return { ok: false, detail: `invalid gate pattern /${pattern}/` };
+  }
+  const target = label ? `: ${label}` : ` /${pattern}/`;
+  return re.test(content) ? { ok: true, detail: `${file} contains required content${target}` } : {
+    ok: false,
+    detail: `${file} is missing required content${target} \u2014 nothing in its ${content.length} bytes matches${label ? ` /${pattern}/` : ""}. Add that content.`
+  };
+}
+async function notContainsPattern(ws, file, pattern, flags, label) {
+  const content = await ws.read(file);
+  if (content === null) return { ok: false, detail: `${file} not found` };
+  let re;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch {
+    return { ok: false, detail: `invalid gate pattern /${pattern}/` };
+  }
+  const match = re.exec(content);
+  const target = label ? `: ${label}` : ` /${pattern}/`;
+  const matchedText = match?.[0]?.replace(/\s+/g, " ").slice(0, 180);
+  const matchedSuffix = label && matchedText ? ` (matched "${matchedText}")` : "";
+  return match ? { ok: false, detail: `${file} contains forbidden content${target}${matchedSuffix}` } : { ok: true, detail: `${file} excludes forbidden content${target}` };
+}
+async function grepMatches(ws, pattern, opts = {}) {
+  const min = opts.minMatches ?? 1;
+  let re;
+  try {
+    re = new RegExp(pattern, opts.flags);
+  } catch {
+    return { ok: false, detail: `invalid grep pattern /${pattern}/`, matched: [] };
+  }
+  const dirPrefix = opts.dir ? `${opts.dir.toLowerCase().replace(/\/+$/, "")}/` : null;
+  const exts = opts.ext?.length ? new Set(opts.ext.map((e) => e.toLowerCase().replace(/^\./, ""))) : null;
+  const matched = [];
+  for (const p of await ws.list()) {
+    const lower = p.toLowerCase();
+    if (dirPrefix && !lower.startsWith(dirPrefix)) continue;
+    if (exts && !exts.has(lower.split(".").pop() ?? "")) continue;
+    const content = await ws.read(p);
+    if (content !== null && re.test(content)) {
+      matched.push(p);
+      if (matched.length >= Math.max(min, 5)) break;
+    }
+  }
+  return matched.length >= min ? { ok: true, detail: `${matched.length} file(s) match /${pattern}/`, matched } : {
+    ok: false,
+    detail: `${matched.length} file(s) match /${pattern}/, need \u2265 ${min}`,
+    matched
+  };
+}
+
+// src/checks/refs.ts
+var IMG_EXT = /\.(png|jpe?g|webp|gif|svg)$/i;
+function resolveRelative(basePath, srcRaw) {
+  if (/^(?:[a-z]+:|\/\/|#|data:|mailto:)/i.test(srcRaw)) return null;
+  const src = srcRaw.replace(/[?#].*$/, "").trim();
+  if (!src) return null;
+  if (src.startsWith("/")) return src.slice(1);
+  const baseDirParts = basePath.split(/[\\/]+/);
+  baseDirParts.pop();
+  const parts = src.split(/[\\/]+/);
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (baseDirParts.length === 0) return null;
+      baseDirParts.pop();
+    } else {
+      baseDirParts.push(part);
+    }
+  }
+  return baseDirParts.join("/");
+}
+function findImageRefs(html) {
+  const refs = [];
+  for (const m of html.matchAll(/<img\b[^>]*\bsrc\s*=\s*("([^"]+)"|'([^']+)')/gi)) {
+    const src = m[2] ?? m[3];
+    if (src) refs.push(src);
+  }
+  return refs;
+}
+function imageRefsResolve(html, htmlPath, projectFiles, requireAll = false) {
+  const fileSet = new Set(projectFiles.map((p) => p.replace(/\\/g, "/")));
+  const refs = findImageRefs(html).filter((src) => IMG_EXT.test(src.replace(/[?#].*$/, "")));
+  const broken = [];
+  let working = 0;
+  for (const src of refs) {
+    const resolved = resolveRelative(htmlPath, src);
+    if (resolved !== null && fileSet.has(resolved)) working++;
+    else broken.push(src);
+  }
+  const ok = requireAll ? refs.length > 0 && broken.length === 0 : working > 0;
+  const detail = ok ? `${working}/${refs.length} image ref(s) resolve` : refs.length === 0 ? `${htmlPath} has no image references` : `${broken.length} image ref(s) point at missing files: ${broken.slice(0, 4).join(", ")}`;
+  return { ok, detail, broken, working, total: refs.length };
+}
+
+// src/checks/esm.ts
+var NODE_BUILTIN_EXPORTS = {
+  "node:path": [
+    "dirname",
+    "basename",
+    "extname",
+    "join",
+    "resolve",
+    "normalize",
+    "relative",
+    "isAbsolute",
+    "sep",
+    "delimiter",
+    "parse",
+    "format",
+    "toNamespacedPath",
+    "matchesGlob",
+    "posix",
+    "win32"
+  ],
+  "node:url": [
+    "fileURLToPath",
+    "pathToFileURL",
+    "URL",
+    "URLSearchParams",
+    "format",
+    "parse",
+    "resolve",
+    "domainToASCII",
+    "domainToUnicode",
+    "urlToHttpOptions",
+    "Url"
+  ]
+};
+var UNIQUE_OWNER = (() => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [mod, names] of Object.entries(NODE_BUILTIN_EXPORTS)) {
+    for (const name of names) {
+      const arr = seen.get(name) ?? [];
+      arr.push(mod);
+      seen.set(name, arr);
+    }
+  }
+  const owner = /* @__PURE__ */ new Map();
+  for (const [name, mods] of seen) {
+    if (mods.length === 1 && mods[0]) owner.set(name, mods[0]);
+  }
+  return owner;
+})();
+var NAMED_IMPORT_RE = /import\s+[^{}'"]*\{([^}]*)\}\s*from\s*['"](node:[a-z/]+)['"]/g;
+var REQUIRE_CALL_RE = /(?<![.\w])require\s*\(/;
+function esmImports(content, file = "") {
+  for (const m of content.matchAll(NAMED_IMPORT_RE)) {
+    const mod = m[2] ?? "";
+    for (const raw of (m[1] ?? "").split(",")) {
+      const name = raw.trim().split(/\s+as\s+/)[0]?.trim();
+      if (!name) continue;
+      const owner = UNIQUE_OWNER.get(name);
+      if (owner && owner !== mod) {
+        const label = file || "this file";
+        return {
+          ok: false,
+          detail: `${label} imports { ${name} } from '${mod}', but '${mod}' has no '${name}' export \u2014 it is a '${owner}' export. Import it from '${owner}' (e.g. \`import { ${name} } from '${owner}'\`, or \`import path from 'node:path'\` then \`path.${name}(\u2026)\`). A wrong-source named import throws "SyntaxError: \u2026 does not provide an export named \u2026" at load and nothing runs.`
+        };
+      }
+    }
+  }
+  if (file.endsWith(".mjs") && REQUIRE_CALL_RE.test(content)) {
+    return {
+      ok: false,
+      detail: `${file} is an ES module (.mjs) but calls require(...) \u2014 \`require\` is not defined in ESM and throws at runtime. Use \`import\` instead (read JSON via node:fs, or import a module's exports directly).`
+    };
+  }
+  return { ok: true, detail: "node: named imports resolve; no require() in ESM" };
+}
+function standaloneJsParses(content, file = "") {
+  const stripped = content.replace(/^[ \t]*import\b[\s\S]*?from\s*['"][^'"]*['"];?[ \t]*$/gm, "").replace(/^[ \t]*import\s*['"][^'"]*['"];?[ \t]*$/gm, "").replace(/^[ \t]*export\s+default\s+/gm, "").replace(/^[ \t]*export\s*\{[^}]*\}\s*(?:from\s*['"][^'"]*['"])?;?[ \t]*$/gm, "").replace(/^[ \t]*export\s+(?=(?:async\s+)?(?:const|let|var|function|class)\b)/gm, "").replace(/^([ \t]*)await\b/gm, "$1void ");
+  try {
+    new Function(stripped);
+    return { ok: true, detail: `${file || "source"} parses` };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      detail: `${file || "source"} does not parse: ${message}. The file will not load until this is fixed \u2014 commonly a truncated file or an unbalanced brace/parenthesis.`
+    };
+  }
+}
+
+// src/checks/text.ts
+function countDistinctMatches(text, pattern) {
+  const seen = /* @__PURE__ */ new Set();
+  const re = pattern.flags.includes("g") ? pattern : new RegExp(pattern.source, `${pattern.flags}g`);
+  for (const m of text.matchAll(re)) {
+    const key = (m[1] ?? m[0]).toLowerCase();
+    if (key.length > 0) seen.add(key);
+  }
+  return seen.size;
+}
+function requireOrderedSections(text, headers) {
+  let cursor = 0;
+  for (const header of headers) {
+    const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^#+\\s+${escaped}\\s*$`, "im");
+    const slice = text.slice(cursor);
+    const m = slice.match(re);
+    if (!m || m.index === void 0) {
+      return { ok: false, missing: header, foundIndex: cursor };
+    }
+    cursor += m.index + m[0].length;
+  }
+  return { ok: true };
+}
+function jsonValid(content) {
+  try {
+    JSON.parse(content);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function parseJsonPath(path) {
+  const trimmed = path.trim().replace(/^\$\.?/, "");
+  if (trimmed.length === 0) return [];
+  const parts = [];
+  for (const rawPart of trimmed.split(".")) {
+    if (rawPart.length === 0) return null;
+    const keyMatch = rawPart.match(/^[^\[\]]+/);
+    if (keyMatch) parts.push(keyMatch[0]);
+    const rest = rawPart.slice(keyMatch?.[0].length ?? 0);
+    if (rest.length === 0) continue;
+    const bracketRe = /\[(\d+)\]/g;
+    let consumed = "";
+    for (const match of rest.matchAll(bracketRe)) {
+      consumed += match[0];
+      parts.push(Number(match[1]));
+    }
+    if (consumed !== rest) return null;
+  }
+  return parts;
+}
+function getPathValue(root, path) {
+  let cursor = root;
+  for (const part of path) {
+    if (typeof part === "number") {
+      if (!Array.isArray(cursor) || part >= cursor.length) return void 0;
+      cursor = cursor[part];
+      continue;
+    }
+    if (cursor === null || typeof cursor !== "object" || !(part in cursor)) return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function printableValue(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+async function jsonPathEquals(ws, file, path, expected, label) {
+  const content = await ws.read(file);
+  if (content === null) {
+    return { ok: false, detail: `${file} not found`, actual: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, detail: `${file} is not valid JSON: ${detail}`, actual: void 0 };
+  }
+  const parts = parseJsonPath(path);
+  if (parts === null) {
+    return { ok: false, detail: `${path} is not a supported JSON path`, actual: void 0 };
+  }
+  const actual = getPathValue(parsed, parts);
+  if (Object.is(actual, expected)) {
+    return { ok: true, detail: `${file} ${path} equals ${printableValue(expected)}`, actual };
+  }
+  const guidance = label ? `: ${label}` : "";
+  return {
+    ok: false,
+    detail: `${file} ${path} should equal ${printableValue(expected)} but was ${printableValue(actual)}${guidance}`,
+    actual
+  };
+}
+
+// src/checks/grounding.ts
+function normalizeDigitGroups(text) {
+  return text.replace(/(\d)[,\s](?=\d{3}(?:\D|$))/g, "$1");
+}
+function safeRegExp(src, flags) {
+  try {
+    return new RegExp(src, flags);
+  } catch {
+    return null;
+  }
+}
+function valueGrounding(text, facts, opts = {}) {
+  const haystack = opts.normalizeDigits === false ? text : normalizeDigitGroups(text);
+  const signals = [];
+  const decoysDetected = [];
+  let firstFailure = null;
+  if (facts.length === 0) {
+    return { ok: false, detail: "no grounding facts configured", signals, decoysDetected };
+  }
+  for (const fact of facts) {
+    const label = fact.label ?? fact.id;
+    const hasRequired = fact.required.some((src) => safeRegExp(src, "i")?.test(haystack) ?? false);
+    const hitForbidden = (fact.forbidden ?? []).filter(
+      (src) => safeRegExp(src, "i")?.test(haystack) ?? false
+    );
+    decoysDetected.push(...hitForbidden);
+    if (hasRequired && hitForbidden.length === 0) {
+      signals.push(fact.id);
+      continue;
+    }
+    if (firstFailure === null) {
+      firstFailure = hitForbidden.length > 0 ? `${label}: forbidden value /${hitForbidden[0]}/ appears \u2014 that figure comes from an unauthorized source and must not appear at all (not even to contrast it).` : `${label}: no authorized value found \u2014 quote the exact value from an authorized source (expected one of: ${fact.required.map((r) => `/${r}/`).join(", ")}).`;
+    }
+  }
+  return {
+    ok: firstFailure === null,
+    detail: firstFailure ?? `all ${facts.length} facts grounded (no forbidden values present)`,
+    signals,
+    decoysDetected
+  };
+}
+var DEFAULT_CITATION_RE = /\(source:\s*([^)\s]+)(?:\s+\[[^\]]*\])*\s*\)|\]\(\s*(?!#)([^)\s]+?)\s*\)|`([^`]*\/[^`]+)`/gi;
+function extractCitations(text, re) {
+  const flags = re.flags.includes("g") ? re.flags : `${re.flags}g`;
+  const global = new RegExp(re.source, flags);
+  const out = [];
+  for (const m of text.matchAll(global)) {
+    const cap = m.slice(1).find((x) => x !== void 0) ?? m[0];
+    if (cap) out.push(cap);
+  }
+  return out;
+}
+function cleanCitation(raw) {
+  return raw.trim().replace(/^[<'"`(]+/, "").replace(/[>'"`).,;:]+$/, "");
+}
+function normalizePath(p) {
+  return p.trim().toLowerCase().replace(/^\.?\//, "").replace(/^workspace\//, "");
+}
+async function citationsResolve(ws, file, opts = {}) {
+  const content = await ws.read(file);
+  if (content === null) {
+    return {
+      ok: false,
+      detail: `${file} not found \u2014 write the deliverable before advancing.`,
+      resolved: [],
+      unresolved: [],
+      urls: []
+    };
+  }
+  const re = opts.pattern ? safeRegExp(opts.pattern, opts.flags ?? "gi") : new RegExp(DEFAULT_CITATION_RE.source, "gi");
+  if (!re) {
+    return {
+      ok: false,
+      detail: `invalid citation pattern /${opts.pattern}/`,
+      resolved: [],
+      unresolved: [],
+      urls: []
+    };
+  }
+  const cites = [...new Set(extractCitations(content, re).map(cleanCitation).filter(Boolean))];
+  const min = opts.minCitations ?? 1;
+  const listing = new Set((await ws.list()).map(normalizePath));
+  const corpus = opts.corpus ? new Set(opts.corpus.map((c) => c.toLowerCase())) : null;
+  const resolved = [];
+  const unresolved = [];
+  const urls = [];
+  for (const c of cites) {
+    if (/^[a-z][\w+.-]*:\/\//i.test(c) || c.startsWith("mailto:")) {
+      urls.push(c);
+      if (corpus && !corpus.has(c.toLowerCase())) unresolved.push(c);
+      continue;
+    }
+    if (listing.has(normalizePath(c)) || corpus?.has(c.toLowerCase())) resolved.push(c);
+    else unresolved.push(c);
+  }
+  if (cites.length < min) {
+    return {
+      ok: false,
+      detail: `${file} has ${cites.length} citation(s), need \u2265 ${min} \u2014 cite the source path/URL for each claim.`,
+      resolved,
+      unresolved,
+      urls
+    };
+  }
+  if (unresolved.length > 0) {
+    return {
+      ok: false,
+      detail: `${file} cites ${unresolved.length} source(s) that do not exist: ${unresolved.slice(0, 5).join(", ")} \u2014 every cited path must resolve to a real file in the workspace${corpus ? "/corpus" : ""} (no fabricated citations).`,
+      resolved,
+      unresolved,
+      urls
+    };
+  }
+  return {
+    ok: true,
+    detail: `${file} cites ${resolved.length} resolvable source(s)${urls.length ? ` (+${urls.length} URL(s) not checked offline)` : ""}`,
+    resolved,
+    unresolved,
+    urls
+  };
+}
+function valuesSubsetOf(outputText, sourceTexts, spec) {
+  const flags = (spec.flags ?? "").includes("g") ? spec.flags ?? "" : `${spec.flags ?? ""}g`;
+  const re = safeRegExp(spec.pattern, flags);
+  if (!re) {
+    return { ok: false, detail: `invalid pattern /${spec.pattern}/`, checked: 0, invented: [] };
+  }
+  const extract = (text) => {
+    const out = [];
+    for (const m of text.matchAll(new RegExp(re.source, flags))) {
+      const v = (m[1] ?? m[0]).trim();
+      if (v) out.push(v);
+    }
+    return out;
+  };
+  const caseInsensitive = flags.includes("i");
+  const sourceHaystacks = sourceTexts.map((t) => caseInsensitive ? t.toLowerCase() : t);
+  const appearsInSources = (value) => {
+    const needle = caseInsensitive ? value.toLowerCase() : value;
+    return sourceHaystacks.some((t) => t.includes(needle));
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const invented = [];
+  let checked = 0;
+  for (const v of extract(outputText)) {
+    if (seen.has(v)) continue;
+    seen.add(v);
+    checked += 1;
+    if (!appearsInSources(v)) invented.push(v);
+  }
+  const min = spec.minMatches ?? 0;
+  if (checked < min) {
+    return {
+      ok: false,
+      detail: `output carries ${checked} value(s) matching /${spec.pattern}/, need \u2265 ${min} \u2014 the transform must preserve the source values, not drop them.`,
+      checked,
+      invented
+    };
+  }
+  if (invented.length > 0) {
+    return {
+      ok: false,
+      detail: `${invented.length} value(s) in the output appear in no source: ${invented.slice(0, 3).join(", ")}${invented.length > 3 ? ", \u2026" : ""} \u2014 copy identifiers verbatim from the source data; never renumber or invent them.`,
+      checked,
+      invented
+    };
+  }
+  return {
+    ok: true,
+    detail: `all ${checked} output value(s) trace back to the sources`,
+    checked,
+    invented
+  };
+}
+
+// src/checks/security-report.ts
+var DEFAULT_SECTIONS = [
+  "Verdict",
+  "Systemic Themes",
+  "Findings",
+  "Verified Safe",
+  "Not Statically Verifiable"
+];
+var VALID_SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info"]);
+function str(x) {
+  return typeof x === "string" ? x.trim() : "";
+}
+function normalizePath2(p) {
+  return p.trim().replace(/^`+|`+$/g, "").replace(/[:#].*$/, "").replace(/^\.\//, "").replace(/^\/+/, "").replace(/^workspace\//i, "").toLowerCase();
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasSection(content, name) {
+  return new RegExp(`^#{1,4}\\s+${escapeRe(name)}\\b`, "im").test(content);
+}
+function sectionBody(content, name) {
+  const m = new RegExp(`^(#{1,4})\\s+${escapeRe(name)}\\b`, "im").exec(content);
+  if (!m) return "";
+  const level = m[1].length;
+  const start = m.index + m[0].length;
+  const rest = content.slice(start);
+  const next = new RegExp(`^#{1,${level}}\\s+\\S`, "m").exec(rest);
+  return next ? rest.slice(0, next.index) : rest;
+}
+function countThemeItems(section) {
+  let n = 0;
+  for (const line of section.split(/\r?\n/)) {
+    if (/^\s*(#{3,4}\s+\S|[-*]\s+\S|\d+\.\s+\S|\*\*[^*]+\*\*)/.test(line)) n++;
+  }
+  return n;
+}
+function uniq(xs) {
+  return [...new Set(xs)];
+}
+async function securityReport(ws, reportFile, opts = {}) {
+  const fail = (detail, count = 0, fabricated2 = []) => ({
+    ok: false,
+    detail,
+    findingCount: count,
+    fabricated: fabricated2
+  });
+  const content = await ws.read(reportFile);
+  if (content === null) {
+    return fail(`${reportFile} not found \u2014 write the security report before advancing.`);
+  }
+  const findingsPath = opts.findings ?? "security-review/findings.json";
+  const raw = await ws.read(findingsPath);
+  if (raw === null) {
+    return fail(
+      `${findingsPath} not found \u2014 emit a machine-readable findings JSON alongside the report.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return fail(
+      `${findingsPath} is not valid JSON (${e instanceof Error ? e.message : "parse error"}). Emit a JSON array of findings.`
+    );
+  }
+  const arr = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.findings) ? parsed.findings : null;
+  if (!arr) {
+    return fail(`${findingsPath} must be a JSON array of findings (or { "findings": [...] }).`);
+  }
+  const listing = new Set((await ws.list()).map(normalizePath2));
+  const problems = [];
+  const fabricated = [];
+  let critHigh = 0;
+  arr.forEach((raw2, i) => {
+    const f = raw2 ?? {};
+    const file = str(f.file ?? f.path);
+    const sev = str(f.severity).toLowerCase();
+    const remediation = str(f.remediation ?? f.fix ?? f.recommendation);
+    const title = str(f.title ?? f.description ?? f.summary);
+    const line = f.line ?? f.lineStart;
+    const label = file || `#${i + 1}`;
+    if (!file) problems.push(`finding #${i + 1} has no file`);
+    else if (!listing.has(normalizePath2(file))) fabricated.push(file);
+    if (!VALID_SEVERITIES.has(sev)) problems.push(`${label} has an invalid severity "${sev}"`);
+    if (!remediation) problems.push(`${label} has no remediation`);
+    if (!title) problems.push(`${label} has no title/description`);
+    if (typeof line !== "number") problems.push(`${label} is not pinned to a line`);
+    if (sev === "critical" || sev === "high") critHigh++;
+  });
+  if (fabricated.length > 0) {
+    return fail(
+      `findings cite ${fabricated.length} file(s) that don't exist in the workspace: ${uniq(fabricated).slice(0, 5).join(", ")} \u2014 every finding must point at a real file:line (no fabricated citations).`,
+      arr.length,
+      uniq(fabricated)
+    );
+  }
+  if (problems.length > 0) {
+    return fail(
+      `${problems.length} finding(s) are incomplete: ${problems.slice(0, 4).join("; ")} \u2014 every finding needs a real file:line, a severity, and a concrete remediation.`,
+      arr.length
+    );
+  }
+  const requiredSections = opts.requiredSections ?? DEFAULT_SECTIONS;
+  const missing = requiredSections.filter((s) => !hasSection(content, s));
+  if (missing.length > 0) {
+    return fail(
+      `the report is missing required section(s): ${missing.map((s) => `## ${s}`).join(", ")}.`,
+      arr.length
+    );
+  }
+  const themeThreshold = opts.themeThreshold ?? 3;
+  const minThemes = opts.minThemes ?? 2;
+  if (arr.length >= themeThreshold) {
+    const themes = sectionBody(content, "Systemic Themes");
+    const items = countThemeItems(themes);
+    if (items < minThemes) {
+      return fail(
+        `the "Systemic Themes" section lists ${items} theme(s); a review with ${arr.length} findings needs \u2265 ${minThemes}, each naming a root cause and its blast radius.`,
+        arr.length
+      );
+    }
+    if (!/root[\s-]?cause/i.test(themes) || !/(blast[\s-]?radius|impact|scope|reach)/i.test(themes)) {
+      return fail(
+        `the "Systemic Themes" section must analyze each theme's root cause and blast radius \u2014 that analysis is absent.`,
+        arr.length
+      );
+    }
+  }
+  const verdict = sectionBody(content, "Verdict").toLowerCase();
+  if (critHigh > 0 && /(safe[\s-]?to[\s-]?merge|no (security )?(issues|findings|vulnerabilities)|looks secure|no concerns|all clear)/.test(
+    verdict
+  ) && !/(block|after[\s-]?fix|merge[\s-]?after|do not merge|concern|open (critical|high))/.test(
+    verdict
+  )) {
+    return fail(
+      `the verdict reads "safe" but there ${critHigh === 1 ? "is" : "are"} ${critHigh} critical/high finding(s) \u2014 the verdict must reflect the open severity.`,
+      arr.length
+    );
+  }
+  return {
+    ok: true,
+    detail: `security report OK: ${arr.length} finding(s), all cite real files, required sections present${arr.length >= themeThreshold ? ", systemic themes analyzed" : ""}.`,
+    findingCount: arr.length,
+    fabricated: []
+  };
+}
+
+// src/checks/records.ts
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isRealIsoDate(value) {
+  if (!ISO_DATE_RE.test(value)) return false;
+  const parts = value.split("-").map(Number);
+  const y = parts[0] ?? 0;
+  const m = parts[1] ?? 0;
+  const d = parts[2] ?? 0;
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
+}
+function checkCellType(value, type) {
+  switch (type) {
+    case "string":
+    case "nonempty":
+      return value.length > 0 ? { ok: true, detail: "" } : { ok: false, detail: "empty value" };
+    case "number":
+      return /^-?\d+(\.\d+)?$/.test(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" is not a number` };
+    case "integer":
+      return /^-?\d+$/.test(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" is not an integer` };
+    case "boolean":
+      return /^(true|false)$/i.test(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" is not a boolean` };
+    case "date":
+    case "iso-date":
+      return isRealIsoDate(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" is not an ISO yyyy-mm-dd date` };
+    case "email":
+      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" is not an email` };
+    default: {
+      let re = null;
+      try {
+        re = new RegExp(type);
+      } catch {
+        return { ok: false, detail: `invalid column type /${type}/` };
+      }
+      return re.test(value) ? { ok: true, detail: "" } : { ok: false, detail: `"${value}" does not match /${type}/` };
+    }
+  }
+}
+function splitTableRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|")) s = s.slice(0, -1);
+  return s.split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|"));
+}
+function isDelimiterRow(line) {
+  if (!line.includes("-")) return false;
+  const cells = splitTableRow(line);
+  return cells.length > 0 && cells.every((c) => /^:?-{1,}:?$/.test(c.trim()));
+}
+function parseMarkdownTable(text) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length - 1; i++) {
+    const header = lines[i];
+    const delim = lines[i + 1];
+    if (!header || !header.includes("|") || !delim || !isDelimiterRow(delim)) continue;
+    const headers = splitTableRow(header);
+    if (headers.length === 0) continue;
+    const rows = [];
+    for (let j = i + 2; j < lines.length; j++) {
+      const l = lines[j];
+      if (!l || l.trim() === "" || !l.includes("|")) break;
+      rows.push(splitTableRow(l));
+    }
+    return { headers, rows };
+  }
+  return null;
+}
+function tableShape(text, spec) {
+  const table = parseMarkdownTable(text);
+  if (!table) {
+    return {
+      ok: false,
+      detail: 'no Markdown table found \u2014 provide a "| header | \u2026 |" row with a "|---|" delimiter.',
+      headers: [],
+      rowCount: 0
+    };
+  }
+  const headersLower = table.headers.map((h) => h.toLowerCase());
+  const base = { headers: table.headers, rowCount: table.rows.length };
+  for (const col of spec.requiredColumns ?? []) {
+    if (!headersLower.includes(col.toLowerCase())) {
+      return {
+        ok: false,
+        detail: `table is missing required column "${col}" \u2014 found: ${table.headers.join(", ")}.`,
+        ...base
+      };
+    }
+  }
+  const minRows = spec.minRows ?? 0;
+  if (table.rows.length < minRows) {
+    return {
+      ok: false,
+      detail: `table has ${table.rows.length} row(s), need \u2265 ${minRows}.`,
+      ...base
+    };
+  }
+  for (const [col, type] of Object.entries(spec.columnTypes ?? {})) {
+    const idx = headersLower.indexOf(col.toLowerCase());
+    if (idx === -1) {
+      return { ok: false, detail: `column-type check names unknown column "${col}".`, ...base };
+    }
+    for (let r = 0; r < table.rows.length; r++) {
+      const cell = (table.rows[r]?.[idx] ?? "").trim();
+      const v = checkCellType(cell, type);
+      if (!v.ok) {
+        return { ok: false, detail: `row ${r + 1} column "${col}": ${v.detail}`, ...base };
+      }
+    }
+  }
+  return {
+    ok: true,
+    detail: `table has ${table.headers.length} column(s) and ${table.rows.length} row(s)`,
+    ...base
+  };
+}
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let inQuotes = false;
+  let started = false;
+  const s = text.replace(/^\uFEFF/, "");
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    started = true;
+    if (inQuotes) {
+      if (ch === '"') {
+        if (s[i + 1] === '"') {
+          cell += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        cell += ch;
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === ",") {
+      row.push(cell);
+      cell = "";
+    } else if (ch === "\n") {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else if (ch !== "\r") {
+      cell += ch;
+    }
+  }
+  if (started && (cell.length > 0 || row.length > 0)) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows;
+}
+function csvQuoteError(text) {
+  let inQuotes = false;
+  const s = text.replace(/^\uFEFF/, "");
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (s[i + 1] === '"') {
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    }
+  }
+  return inQuotes ? "CSV has an unclosed quoted field" : null;
+}
+function dataTableSniff(text) {
+  const stripped = text.replace(/^\uFEFF/, "").trim();
+  if (stripped.length === 0) return false;
+  if (stripped[0] === "[") {
+    try {
+      const parsed = JSON.parse(stripped);
+      return Array.isArray(parsed) && parsed.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  const md = parseMarkdownTable(stripped);
+  if (md && md.headers.length > 0 && md.rows.length > 0) return true;
+  const grid = parseCsv(stripped).filter((r) => r.some((c) => c.trim().length > 0));
+  if (grid.length >= 2) {
+    const cols = grid[0]?.length ?? 0;
+    if (cols >= 2 && grid.slice(1).some((r) => r.length === cols)) return true;
+  }
+  return false;
+}
+function csvShapeFailure(detail, headers = [], rowCount = 0) {
+  return { ok: false, detail, headers, rowCount };
+}
+function summarizeCsvRow(row, max = 180) {
+  const summary = row.map((cell) => cell.trim()).join(" | ");
+  return summary.length <= max ? summary : `${summary.slice(0, max - 3)}...`;
+}
+function csvShape(text, spec) {
+  if (text === null) {
+    return csvShapeFailure("CSV file not found");
+  }
+  const quoteError = csvQuoteError(text);
+  if (quoteError) {
+    return csvShapeFailure(quoteError);
+  }
+  const grid = parseCsv(text).filter((r) => r.some((c) => c.trim().length > 0));
+  if (grid.length === 0) {
+    return csvShapeFailure("CSV has no rows");
+  }
+  const headers = (grid[0] ?? []).map((h) => h.trim());
+  const dataRows = grid.slice(1);
+  const base = { headers, rowCount: dataRows.length };
+  if (headers.length === 0 || headers.every((h) => h.length === 0)) {
+    return csvShapeFailure("CSV header row is empty", headers, dataRows.length);
+  }
+  if (spec.exactColumns) {
+    const expected = spec.exactColumns;
+    const matches = headers.length === expected.length && headers.every((header, index) => header === expected[index]);
+    if (!matches) {
+      return {
+        ok: false,
+        detail: `CSV header should be exactly: ${expected.join(", ")}; found: ${headers.join(", ")}`,
+        ...base
+      };
+    }
+  }
+  for (const column of spec.requiredColumns ?? []) {
+    if (!headers.includes(column)) {
+      return {
+        ok: false,
+        detail: `CSV is missing required column "${column}" \u2014 found: ${headers.join(", ")}`,
+        ...base
+      };
+    }
+  }
+  const minRows = spec.minRows ?? 0;
+  if (dataRows.length < minRows) {
+    return {
+      ok: false,
+      detail: `CSV has ${dataRows.length} data row(s), need \u2265 ${minRows}`,
+      ...base
+    };
+  }
+  if (spec.consistentColumns ?? true) {
+    for (let i = 0; i < dataRows.length; i++) {
+      const row = dataRows[i] ?? [];
+      if (row.length !== headers.length) {
+        return {
+          ok: false,
+          detail: `CSV row ${i + 2} has ${row.length} column(s), expected ${headers.length}. Keep empty placeholders as adjacent commas so every row matches the header. Header order: ${headers.join(" | ")}. Row ${i + 2}: ${summarizeCsvRow(row)}`,
+          ...base
+        };
+      }
+    }
+  }
+  for (const [column, allowedValues] of Object.entries(spec.allowedValues ?? {})) {
+    const index = headers.indexOf(column);
+    if (index === -1) {
+      return {
+        ok: false,
+        detail: `CSV allowed-values check names unknown column "${column}"`,
+        ...base
+      };
+    }
+    for (let i = 0; i < dataRows.length; i++) {
+      const value = (dataRows[i]?.[index] ?? "").trim();
+      if (value.length > 0 && !allowedValues.includes(value)) {
+        return {
+          ok: false,
+          detail: `CSV row ${i + 2} column "${column}" has "${value}", expected one of: ${allowedValues.join(", ")}`,
+          ...base
+        };
+      }
+    }
+  }
+  return {
+    ok: true,
+    detail: `CSV has ${headers.length} column(s) and ${dataRows.length} data row(s)`,
+    ...base
+  };
+}
+function recordSchema(text, spec) {
+  if (text === null) {
+    return {
+      ok: false,
+      detail: "deliverable not found \u2014 write the records file before advancing.",
+      rowCount: 0
+    };
+  }
+  if (spec.fields.length === 0) {
+    return { ok: false, detail: 'no fields configured \u2014 set the schema "fields".', rowCount: 0 };
+  }
+  const stripped = text.replace(/^\uFEFF/, "");
+  const fmt = spec.format && spec.format !== "auto" ? spec.format : /^\s*[[{]/.test(stripped) ? "json" : "csv";
+  let records;
+  if (fmt === "json") {
+    let parsed;
+    try {
+      parsed = JSON.parse(stripped);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { ok: false, detail: `not valid JSON: ${msg.slice(0, 160)}`, rowCount: 0 };
+    }
+    if (!Array.isArray(parsed)) {
+      return {
+        ok: false,
+        detail: `expected a top-level JSON array, got ${typeof parsed}`,
+        rowCount: 0
+      };
+    }
+    records = parsed;
+  } else {
+    const grid = parseCsv(text).filter((r) => r.some((c) => c.trim().length > 0));
+    if (grid.length === 0) return { ok: false, detail: "CSV has no rows", rowCount: 0 };
+    const headers = (grid[0] ?? []).map((h) => h.trim());
+    records = grid.slice(1).map((cells) => {
+      const o = {};
+      headers.forEach((h, i) => {
+        o[h] = (cells[i] ?? "").trim();
+      });
+      return o;
+    });
+  }
+  const fieldNames = spec.fields.map((f) => f.name);
+  const allowExtra = spec.allowExtraFields ?? false;
+  for (let i = 0; i < records.length; i++) {
+    const row = records[i];
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      return {
+        ok: false,
+        detail: `record ${i} is not an object: ${JSON.stringify(row)?.slice(0, 120)}`,
+        rowCount: records.length
+      };
+    }
+    for (const f of spec.fields) {
+      const required = f.required !== false;
+      const raw = row[f.name];
+      const present = Object.prototype.hasOwnProperty.call(row, f.name) && raw !== "" && raw !== null && raw !== void 0;
+      if (!present) {
+        if (required) {
+          return {
+            ok: false,
+            detail: `record ${i} is missing required field "${f.name}"`,
+            rowCount: records.length
+          };
+        }
+        continue;
+      }
+      if (f.type && f.type !== "string") {
+        const v = checkCellType(String(raw), f.type);
+        if (!v.ok) {
+          return {
+            ok: false,
+            detail: `record ${i} field "${f.name}": ${v.detail}`,
+            rowCount: records.length
+          };
+        }
+      }
+    }
+    if (!allowExtra) {
+      const extra = Object.keys(row).filter((k) => !fieldNames.includes(k));
+      if (extra.length > 0) {
+        return {
+          ok: false,
+          detail: `record ${i} has unexpected field(s) ${extra.join(", ")} \u2014 allowed: ${fieldNames.join(", ")}`,
+          rowCount: records.length
+        };
+      }
+    }
+  }
+  if (spec.minRows !== void 0 && records.length < spec.minRows) {
+    return {
+      ok: false,
+      detail: `${records.length} record(s), need \u2265 ${spec.minRows}`,
+      rowCount: records.length
+    };
+  }
+  if (spec.uniqueBy) {
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < records.length; i++) {
+      const key = String(records[i][spec.uniqueBy] ?? "");
+      if (seen.has(key)) {
+        return {
+          ok: false,
+          detail: `duplicate ${spec.uniqueBy} "${key}" at record ${i} \u2014 values must be unique`,
+          rowCount: records.length
+        };
+      }
+      seen.add(key);
+    }
+  }
+  return {
+    ok: true,
+    detail: `${records.length} record(s) validate against the schema`,
+    rowCount: records.length
+  };
+}
+
+// src/checks/prose.ts
+function stripMarkdown(md) {
+  return md.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^[#>\-*+\s]+/gm, " ").replace(/[*_~]/g, " ");
+}
+function countWords(text) {
+  return (text.match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) ?? []).length;
+}
+function wordBand(text, opts = {}) {
+  const cleaned = opts.stripMarkdown === false ? text : stripMarkdown(text);
+  const words = countWords(cleaned);
+  if (opts.min !== void 0 && words < opts.min) {
+    return { ok: false, detail: `${words} words, need \u2265 ${opts.min}`, words };
+  }
+  if (opts.max !== void 0 && words > opts.max) {
+    return {
+      ok: false,
+      detail: `${words} words, need \u2264 ${opts.max} \u2014 trim it (verbosity is a failure mode too)`,
+      words
+    };
+  }
+  const band = opts.min !== void 0 && opts.max !== void 0 ? ` (band ${opts.min}\u2013${opts.max})` : "";
+  return { ok: true, detail: `${words} words${band}`, words };
+}
+function countSyllables(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (w.length === 0) return 0;
+  if (w.length <= 3) return 1;
+  const groups = w.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "").replace(/^y/, "").match(/[aeiouy]{1,2}/g);
+  return Math.max(1, groups ? groups.length : 1);
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+function readingLevel(text, opts = {}) {
+  const cleaned = opts.stripMarkdown === false ? text : stripMarkdown(text);
+  const sentences = Math.max(1, (cleaned.match(/[.!?]+(?=\s|$)/g) ?? []).length);
+  const wordTokens = cleaned.match(/[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu) ?? [];
+  const words = wordTokens.length;
+  if (words === 0) {
+    return { ok: false, detail: "no words to score", grade: 0, ease: 0, words: 0, sentences };
+  }
+  const syllables = wordTokens.reduce((s, w) => s + countSyllables(w), 0);
+  const wps = words / sentences;
+  const spw = syllables / words;
+  const grade = round1(0.39 * wps + 11.8 * spw - 15.59);
+  const ease = round1(206.835 - 1.015 * wps - 84.6 * spw);
+  let fail = null;
+  if (opts.maxGrade !== void 0 && grade > opts.maxGrade) {
+    fail = `grade ${grade} > max ${opts.maxGrade} \u2014 simplify sentences and word choice`;
+  } else if (opts.minGrade !== void 0 && grade < opts.minGrade) {
+    fail = `grade ${grade} < min ${opts.minGrade}`;
+  } else if (opts.minEase !== void 0 && ease < opts.minEase) {
+    fail = `reading-ease ${ease} < min ${opts.minEase} \u2014 too dense, shorten sentences`;
+  } else if (opts.maxEase !== void 0 && ease > opts.maxEase) {
+    fail = `reading-ease ${ease} > max ${opts.maxEase}`;
+  }
+  return {
+    ok: fail === null,
+    detail: fail ?? `grade ${grade}, reading-ease ${ease}`,
+    grade,
+    ease,
+    words,
+    sentences
+  };
+}
+function literalWordRegExp(s) {
+  const esc = s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  try {
+    return new RegExp(`(?<!\\w)${esc}(?!\\w)`);
+  } catch {
+    return null;
+  }
+}
+function namedEntitiesConsistent(text, entities) {
+  const violations = [];
+  for (const e of entities) {
+    for (const variant of e.variants) {
+      if (variant === e.canonical) continue;
+      const re = literalWordRegExp(variant);
+      if (re?.test(text)) violations.push({ canonical: e.canonical, variant });
+    }
+  }
+  if (violations.length > 0) {
+    const v = violations[0];
+    return {
+      ok: false,
+      detail: `inconsistent reference: "${v.variant}" appears \u2014 use the canonical form "${v.canonical}" consistently throughout.`,
+      violations
+    };
+  }
+  return {
+    ok: true,
+    detail: `all ${entities.length} entit${entities.length === 1 ? "y" : "ies"} referenced consistently`,
+    violations
+  };
+}
+function normalizedProse(text) {
+  return stripMarkdown(text).replace(/\s+/g, " ").trim().toLowerCase();
+}
+function regexFlags(flags) {
+  const base = flags === void 0 ? "i" : flags;
+  const seen = /* @__PURE__ */ new Set();
+  let out = "";
+  for (const flag of `${base}g`) {
+    if (seen.has(flag)) continue;
+    seen.add(flag);
+    out += flag;
+  }
+  return out;
+}
+function shortList(paths) {
+  if (paths.length <= 3) return paths.join(", ");
+  return `${paths.slice(0, 3).join(", ")} and ${paths.length - 3} more`;
+}
+async function unsupportedClaims(ws, file, sourceFiles, patterns, opts = {}) {
+  const content = await ws.read(file);
+  if (content === null) {
+    return {
+      ok: false,
+      detail: `${file} not found`,
+      violations: [],
+      missingSources: []
+    };
+  }
+  if (sourceFiles.length === 0) {
+    return {
+      ok: false,
+      detail: `${file} has no source files to ground claim wording against`,
+      violations: [],
+      missingSources: []
+    };
+  }
+  const missingSources = [];
+  const sourceParts = [];
+  for (const sourceFile of sourceFiles) {
+    const source = await ws.read(sourceFile);
+    if (source === null) {
+      missingSources.push(sourceFile);
+    } else {
+      sourceParts.push(source);
+    }
+  }
+  if (missingSources.length > 0) {
+    return {
+      ok: false,
+      detail: `${shortList(missingSources)} not found (needed to ground claim wording in ${file})`,
+      violations: [],
+      missingSources
+    };
+  }
+  const sourceText = normalizedProse(sourceParts.join("\n"));
+  const violations = [];
+  const maxViolations = opts.maxViolations ?? 5;
+  for (const candidate of patterns) {
+    let re;
+    try {
+      re = new RegExp(candidate.pattern, regexFlags(opts.flags));
+    } catch {
+      return {
+        ok: false,
+        detail: `invalid unsupported-claims pattern /${candidate.pattern}/`,
+        violations: [],
+        missingSources: []
+      };
+    }
+    for (const match of content.matchAll(re)) {
+      const rawMatch = match[0]?.replace(/\s+/g, " ").trim();
+      if (!rawMatch) continue;
+      const grounded = sourceText.includes(normalizedProse(rawMatch));
+      if (!grounded) {
+        violations.push({
+          pattern: candidate.pattern,
+          ...candidate.label ? { label: candidate.label } : {},
+          match: rawMatch.slice(0, 120)
+        });
+        if (violations.length >= maxViolations) break;
+      }
+    }
+    if (violations.length >= maxViolations) break;
+  }
+  if (violations.length > 0) {
+    const first = violations[0];
+    const guidance = first.label ? `: ${first.label}` : "";
+    return {
+      ok: false,
+      detail: `${file} has unsupported claim wording${guidance} (matched "${first.match}") \u2014 rewrite it using only source facts from ${shortList(sourceFiles)} or remove it.`,
+      violations,
+      missingSources: []
+    };
+  }
+  return {
+    ok: true,
+    detail: `${file} claim wording is grounded in ${shortList(sourceFiles)}`,
+    violations: [],
+    missingSources: []
+  };
+}
+
+// src/checks/runtime-hints.ts
+function wrapperReturnHint(outputLines) {
+  let wrapperKey = null;
+  let hits = 0;
+  for (const line of outputLines) {
+    const m = line.match(/expected (\[.*?), got (\{.*)$/);
+    if (!m) continue;
+    hits += 1;
+    const got = m[2];
+    if (wrapperKey === null && got) {
+      const k = got.match(/^\{\s*"([^"]+)"/);
+      if (k?.[1]) wrapperKey = k[1];
+    }
+  }
+  if (hits === 0) return null;
+  const example = wrapperKey ? `{ "${wrapperKey}": [...] }` : "{ ... }";
+  return `Hint: the function is returning an OBJECT where the caller expects an ARRAY \u2014 it received a wrapper like \`${example}\`. Return the array itself (\`return result;\`), not an object with it nested inside.`;
+}
+
+// src/checks/markdown.ts
+function cleanHeading(text) {
+  return text.replace(/\s+#+\s*$/, "").replace(/[*_`]/g, "").replace(/[–—]/g, "-").replace(/[^\p{L}\p{N}]+/gu, " ").trim().toLocaleLowerCase();
+}
+function documentH1s(markdown) {
+  return [...markdown.matchAll(/^#\s+(.+?)\s*$/gm)].map((match) => match[1].trim());
+}
+function outlineSlideHeadings(markdown) {
+  const headings = [];
+  for (const match of markdown.matchAll(/^#{2,6}\s+(.+?)\s*$/gm)) {
+    const raw = match[1].trim();
+    const numbered = /^(?:slide\s+)?\d+(?:\s*[.:\-–—]\s*|\s+)(\S.*)$/i.exec(raw);
+    if (numbered?.[1]) headings.push(numbered[1].trim());
+  }
+  return headings;
+}
+async function markdownHeadingsMatch(ws, file, outlineFile) {
+  const [document, outline] = await Promise.all([ws.read(file), ws.read(outlineFile)]);
+  if (document === null) {
+    return {
+      ok: false,
+      detail: `${file} not found \u2014 write the Markdown document before advancing.`,
+      outlineHeadings: [],
+      documentHeadings: []
+    };
+  }
+  if (outline === null) {
+    return {
+      ok: false,
+      detail: `${outlineFile} not found \u2014 the locked outline is required before writing ${file}.`,
+      outlineHeadings: [],
+      documentHeadings: documentH1s(document)
+    };
+  }
+  const expected = outlineSlideHeadings(outline);
+  const actual = documentH1s(document);
+  if (expected.length === 0) {
+    return {
+      ok: false,
+      detail: `${outlineFile} has no numbered slide headings. Use \`## Slide 1 \u2014 Title\` through the final slide so the deck can be checked mechanically.`,
+      outlineHeadings: expected,
+      documentHeadings: actual
+    };
+  }
+  if (actual.length !== expected.length) {
+    return {
+      ok: false,
+      detail: `${file} has ${actual.length} H1 slide headings, but ${outlineFile} locks ${expected.length}. Add or remove slides without merging outline items.`,
+      outlineHeadings: expected,
+      documentHeadings: actual
+    };
+  }
+  for (let index = 0; index < expected.length; index += 1) {
+    if (cleanHeading(actual[index]) === cleanHeading(expected[index])) continue;
+    return {
+      ok: false,
+      detail: `${file} slide ${index + 1} is "${actual[index]}", but ${outlineFile} requires "${expected[index]}" in that position. Preserve the locked slide titles and order.`,
+      outlineHeadings: expected,
+      documentHeadings: actual,
+      mismatchIndex: index
+    };
+  }
+  return {
+    ok: true,
+    detail: `${file}: ${actual.length} H1 slide headings match ${outlineFile} exactly and in order`,
+    outlineHeadings: expected,
+    documentHeadings: actual
+  };
+}
+
+// src/checks/sniff-explain.ts
+function explainSniff(name, content) {
+  switch (name) {
+    case "html-complete": {
+      const scripts = detectUnclosedScript(content);
+      if (scripts.unclosed) {
+        return `${scripts.opens} <script> tag${scripts.opens === 1 ? "" : "s"} open but only ${scripts.closes} close${scripts.closes === 1 ? "s" : ""} \u2014 the document is truncated mid-script. Finish the file: close the script and end with </body></html>.`;
+      }
+      const lower = content.toLowerCase();
+      if (!lower.includes("</body>") && !lower.includes("</html>")) {
+        return "missing a closing </body> or </html> \u2014 the document is incomplete; finish it.";
+      }
+      return "the document is incomplete \u2014 finish and close it.";
+    }
+    case "html-game": {
+      const lower = content.toLowerCase();
+      const hasRenderTarget = /<canvas\b/.test(lower) || /<svg\b/.test(lower);
+      const hasFrameLoop = /requestanimationframe\s*\(/.test(lower) || /set(?:interval|timeout)\s*\(/.test(lower) || /\bfunction\s+(?:tick|update|loop|gameloop|gametick|step|render|frame)\b/.test(lower);
+      if (!hasRenderTarget && !hasFrameLoop) {
+        return "no render surface (<canvas>/<svg>) and no frame loop (requestAnimationFrame / setInterval / a tick()/update() function) \u2014 add the game loop.";
+      }
+      const scripts = detectUnclosedScript(content);
+      if (scripts.opens === 0) {
+        return "no <script> block \u2014 the page has no game logic; add the inline script.";
+      }
+      if (scripts.unclosed) {
+        return `${scripts.opens} <script> tag${scripts.opens === 1 ? "" : "s"} open but only ${scripts.closes} close${scripts.closes === 1 ? "s" : ""} \u2014 truncated mid-script; close the script.`;
+      }
+      const js = inlineJsBytes(content);
+      if (js < 400) {
+        return `inline JavaScript is ${js} bytes, need >= 400 \u2014 the page has no substantive game logic yet.`;
+      }
+      return "the page does not read as a working game yet \u2014 check the script and game loop.";
+    }
+    case "json-valid": {
+      const parsed = jsonValid(content);
+      if (!parsed.ok) {
+        return `not valid JSON: ${parsed.error ?? "parse failed"} \u2014 fix the syntax error.`;
+      }
+      return "the file must be valid JSON.";
+    }
+    case "nonempty":
+      return "the file is empty \u2014 write the deliverable content.";
+    case "data-table":
+      return "not parseable data \u2014 expected a non-empty JSON array, a comma-delimited table (header + at least one row), or a Markdown table. If you wrote the transform/pipeline code but not its output, RUN it and write the produced data to the file.";
+  }
+}
+
+// src/checks/judge.ts
+var MIN_JUDGE_EVIDENCE_SUBSTRING = 24;
+function buildJudgePrompt(opts) {
+  const sources = (opts.sources ?? []).map((s) => `--- source: ${s.path} ---
+${s.text.slice(0, 8e3)}`).join("\n\n");
+  const evidenceRule = opts.requireEvidence === false ? "" : ' A "fail" verdict MUST include at least one EVIDENCE quote copied from the artifact VERBATIM, character for character \u2014 a verdict with fabricated or paraphrased evidence is discarded.';
+  return [
+    `You are judging one quality of a deliverable. Rubric: ${opts.rubric}`,
+    sources ? `Reference material:
+
+${sources}` : "",
+    `--- artifact: ${opts.file} ---
+${opts.artifactText.slice(0, 24e3)}`,
+    `Reply with STRICT JSON only, matching: {"verdict": "pass" | "fail", "reasons": ["\u2026" (max 5)], "evidence": ["verbatim quote from the artifact", \u2026], "confidence": "low" | "medium" | "high"}.${evidenceRule} No prose outside the JSON.`
+  ].filter(Boolean).join("\n\n");
+}
+function parseJudgeVerdict(raw) {
+  const fenced = /```(?:json)?\s*\n?([\s\S]*?)```/.exec(raw);
+  const candidates = [];
+  if (fenced?.[1]) candidates.push(fenced[1]);
+  candidates.push(raw.trim());
+  const first = raw.indexOf("{");
+  const last = raw.lastIndexOf("}");
+  if (first >= 0 && last > first) candidates.push(raw.slice(first, last + 1));
+  let lastError;
+  for (const candidate of candidates) {
+    try {
+      return validateJudgeVerdict(JSON.parse(candidate));
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("no parseable judge verdict found");
+}
+function validateJudgeVerdict(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("judge verdict must be a JSON object");
+  }
+  const candidate = value;
+  if (candidate.verdict !== "pass" && candidate.verdict !== "fail") {
+    throw new Error('judge verdict must be "pass" or "fail"');
+  }
+  if (!Array.isArray(candidate.reasons) || candidate.reasons.length > 5 || candidate.reasons.some((reason) => typeof reason !== "string" || reason.length === 0)) {
+    throw new Error("judge reasons must be an array of at most five non-empty strings");
+  }
+  const evidence = candidate.evidence ?? [];
+  if (!Array.isArray(evidence) || evidence.some((quote) => typeof quote !== "string")) {
+    throw new Error("judge evidence must be an array of strings");
+  }
+  const confidence = candidate.confidence;
+  if (confidence !== void 0 && confidence !== "low" && confidence !== "medium" && confidence !== "high") {
+    throw new Error('judge confidence must be "low", "medium", or "high"');
+  }
+  return {
+    verdict: candidate.verdict,
+    reasons: candidate.reasons,
+    evidence,
+    ...confidence === void 0 ? {} : { confidence }
+  };
+}
+function normalizeForEvidence(text) {
+  return text.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function validateJudgeEvidence(verdict, artifactText) {
+  const haystack = normalizeForEvidence(artifactText);
+  const kept = [];
+  let dropped = 0;
+  for (const quote of verdict.evidence) {
+    const needle = normalizeForEvidence(quote);
+    if (needle.length >= MIN_JUDGE_EVIDENCE_SUBSTRING && haystack.includes(needle)) {
+      kept.push(quote);
+    } else {
+      dropped += 1;
+    }
+  }
+  return { kept, dropped };
+}
+
+// src/checks/plan.ts
+var REQUIRED_COLUMNS = ["id", "task", "owner", "depends on", "done when"];
+function headerIndex(headers, name) {
+  return headers.findIndex((h) => h.trim().toLowerCase() === name);
+}
+function parseDeps(cell) {
+  const trimmed = cell.trim();
+  if (!trimmed || /^[-\u2010-\u2015\u2212]$/.test(trimmed) || /^(none|n\/a)$/i.test(trimmed)) {
+    return [];
+  }
+  return trimmed.split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+}
+function planStructure(text, spec = {}) {
+  const fail = (detail, partial = {}) => ({
+    ok: false,
+    detail,
+    rows: [],
+    unknownDeps: [],
+    cycleIds: [],
+    missingOwners: [],
+    weakDoneStates: [],
+    ...partial
+  });
+  const table = parseMarkdownTable(text);
+  if (!table) {
+    return fail(
+      "no Markdown table found \u2014 the plan needs a table with columns ID | Task | Owner | Depends on | Done when"
+    );
+  }
+  const headers = table.headers.map((h) => h.trim());
+  const missing = REQUIRED_COLUMNS.filter((c) => headerIndex(headers, c) < 0);
+  if (missing.length > 0) {
+    return fail(
+      `the plan table is missing column(s): ${missing.join(", ")} (found: ${headers.join(" | ")})`
+    );
+  }
+  const col = {
+    id: headerIndex(headers, "id"),
+    task: headerIndex(headers, "task"),
+    owner: headerIndex(headers, "owner"),
+    deps: headerIndex(headers, "depends on"),
+    done: headerIndex(headers, "done when"),
+    estimate: headerIndex(headers, "estimate")
+  };
+  const rows = table.rows.map((cells) => ({
+    id: (cells[col.id] ?? "").trim(),
+    task: (cells[col.task] ?? "").trim(),
+    owner: (cells[col.owner] ?? "").trim(),
+    dependsOn: parseDeps(cells[col.deps] ?? ""),
+    doneWhen: (cells[col.done] ?? "").trim(),
+    ...col.estimate >= 0 && (cells[col.estimate] ?? "").trim() ? { estimate: (cells[col.estimate] ?? "").trim() } : {}
+  }));
+  const minRows = spec.minRows ?? 1;
+  if (rows.length < minRows) {
+    return fail(`the plan table has ${rows.length} row(s) \u2014 at least ${minRows} required`, {
+      rows
+    });
+  }
+  const ids = rows.map((r) => r.id);
+  const idSet = new Set(ids);
+  if (idSet.size !== ids.length) {
+    const dupe = ids.find((id, i) => ids.indexOf(id) !== i);
+    return fail(`duplicate plan row id "${dupe}" \u2014 every ID must be unique`, { rows });
+  }
+  for (const row of rows) {
+    if (!row.id) return fail("a plan row has an empty ID cell", { rows });
+  }
+  const roster = spec.ownerRoster?.map((o) => o.trim().toLowerCase());
+  const missingOwners = [];
+  for (const row of rows) {
+    if (!row.owner) {
+      missingOwners.push(row.id);
+      continue;
+    }
+    if (roster && !roster.includes(row.owner.toLowerCase())) {
+      return fail(
+        `row ${row.id}: Owner "${row.owner}" is not on the roster (${(spec.ownerRoster ?? []).join(", ")})`,
+        { rows, missingOwners }
+      );
+    }
+  }
+  if (missingOwners.length > 0) {
+    return fail(`row ${missingOwners[0]}: the Owner cell is empty \u2014 every task needs an owner`, {
+      rows,
+      missingOwners
+    });
+  }
+  const indexOfId = new Map(rows.map((r, i) => [r.id, i]));
+  const unknownDeps = [];
+  for (const row of rows) {
+    for (const dep of row.dependsOn) {
+      if (!idSet.has(dep)) {
+        unknownDeps.push(`${row.id}\u2192${dep}`);
+        return fail(
+          `row ${row.id}: "Depends on" references ${dep}, which is not a row ID in this plan`,
+          { rows, unknownDeps }
+        );
+      }
+      if (dep === row.id) {
+        return fail(`row ${row.id} depends on itself`, { rows });
+      }
+      if ((spec.requireEarlierOnly ?? true) && indexOfId.get(dep) > indexOfId.get(row.id)) {
+        return fail(
+          `row ${row.id}: "Depends on" references ${dep}, which is a LATER row \u2014 order the plan so dependencies come first`,
+          { rows }
+        );
+      }
+    }
+  }
+  const cycleIds = findCycle(rows);
+  if (cycleIds.length > 0) {
+    return fail(`dependency cycle: ${cycleIds.join(" \u2192 ")} \u2014 break the loop`, { rows, cycleIds });
+  }
+  const doneFloor = spec.doneWhenMinChars ?? 12;
+  const weakDoneStates = rows.filter((r) => r.doneWhen.length < doneFloor).map((r) => r.id);
+  if (weakDoneStates.length > 0) {
+    const row = rows.find((r) => r.id === weakDoneStates[0]);
+    return fail(
+      `row ${row.id}: "Done when" is "${row.doneWhen}" \u2014 too vague to check (write an observable completion state, at least ${doneFloor} characters)`,
+      { rows, weakDoneStates }
+    );
+  }
+  return {
+    ok: true,
+    detail: "",
+    rows,
+    unknownDeps: [],
+    cycleIds: [],
+    missingOwners: [],
+    weakDoneStates: []
+  };
+}
+function findCycle(rows) {
+  const deps = new Map(rows.map((r) => [r.id, r.dependsOn]));
+  const visiting = /* @__PURE__ */ new Set();
+  const done = /* @__PURE__ */ new Set();
+  const path = [];
+  let cycle = [];
+  const visit = (id) => {
+    if (done.has(id)) return false;
+    if (visiting.has(id)) {
+      const start = path.indexOf(id);
+      cycle = [...path.slice(start), id];
+      return true;
+    }
+    visiting.add(id);
+    path.push(id);
+    for (const dep of deps.get(id) ?? []) {
+      if (visit(dep)) return true;
+    }
+    visiting.delete(id);
+    path.pop();
+    done.add(id);
+    return false;
+  };
+  for (const row of rows) {
+    if (visit(row.id)) break;
+  }
+  return cycle;
+}
+export {
+  IMG_EXT,
+  MIN_INLINE_JS_BYTES,
+  MIN_JUDGE_EVIDENCE_SUBSTRING,
+  buildJudgePrompt,
+  citationsResolve,
+  containsPattern,
+  countDistinctMatches,
+  cssMinBytes,
+  csvShape,
+  dataTableSniff,
+  detectTypeScriptOnlySyntax,
+  detectUnclosedScript,
+  esmImports,
+  explainSniff,
+  extractInlineScripts,
+  fileCountByExt,
+  fileMinBytes,
+  fileMinLines,
+  findImageRefs,
+  grepMatches,
+  htmlCompleteSniff,
+  htmlGameSniff,
+  imageRefsResolve,
+  inlineJsBytes,
+  isRealIsoDate,
+  jsonPathEquals,
+  jsonValid,
+  markdownHeadingsMatch,
+  namedEntitiesConsistent,
+  normalizeDigitGroups,
+  notContainsPattern,
+  parseCsv,
+  parseJudgeVerdict,
+  parseMarkdownTable,
+  planStructure,
+  readingLevel,
+  recordSchema,
+  requireOrderedSections,
+  resolveRelative,
+  securityReport,
+  standaloneJsParses,
+  tableShape,
+  totalMinBytes,
+  unsupportedClaims,
+  validateJudgeEvidence,
+  validateScriptSyntax,
+  valueGrounding,
+  valuesSubsetOf,
+  wordBand,
+  wrapperReturnHint
+};